Skip to content

YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context

Reuse recorder screenshots and simplify Workflows storage and UI (#7371)

Louis Beaumontdc2afc2eceef
diff --git a/apps/screenpipe-app-tauri/components/workflows/step-evidence.test.tsx b/apps/screenpipe-app-tauri/components/workflows/step-evidence.test.tsx
index faa233880..dfca9e813 100644
--- a/apps/screenpipe-app-tauri/components/workflows/step-evidence.test.tsx
+++ b/apps/screenpipe-app-tauri/components/workflows/step-evidence.test.tsx
@@ -30,17 +30,18 @@ describe("missing attached screenshots", () => {
fireEvent.click(screen.getByRole("button", { name: `Open recording for ${stage.name}` }));
await waitFor(() => expect(open).toHaveBeenCalledWith(preview.frameId, preview.timestamp));
});
- it("keeps attached images without a lookup", () => {
- const load = vi.fn();
+ it("replaces legacy embedded previews with the recorder frame", async () => {
+ Object.defineProperty(URL, "revokeObjectURL", { value: vi.fn(), configurable: true });
+ const load = vi.fn().mockResolvedValue({ ...stage.screenshot!, dataUrl: "blob:original" });
render(<WorkflowStepEvidence workflow={workflow} stage={stage} platform={{ loadWorkflowScreenshot: load } as unknown as WorkflowsPlatform} />);
- expect(screen.getByRole("img")).toBeVisible();
- expect(load).not.toHaveBeenCalled();
+ expect(await screen.findByRole("img")).toHaveAttribute("src", "blob:original");
+ expect(load).toHaveBeenCalledWith(stage.screenshot!.timestamp, stage.screenshot!.app, expect.any(AbortSignal), stage.screenshot!.frameId);
});
it("recovers the source image when a catalog refresh omits the attachment", async () => {
const load = vi.fn().mockResolvedValue({ ...stage.screenshot!, visualVerified: false });
const platform = { loadWorkflowScreenshot: load } as unknown as WorkflowsPlatform;
const { rerender } = render(<WorkflowStepEvidence workflow={workflow} stage={stage} platform={platform} />);
- expect(load).not.toHaveBeenCalled();
+ await screen.findByRole("img");
rerender(<WorkflowStepEvidence workflow={workflow} stage={bare} platform={platform} />);
expect(await screen.findByRole("img")).toHaveAttribute("src", stage.screenshot!.dataUrl);
expect(screen.getByText(/Source screenshot/)).toBeVisible();
@@ -58,7 +59,7 @@ describe("missing attached screenshots", () => {
expect(load).not.toHaveBeenCalled();
act(() => observe([{ isIntersecting: true }]));
expect(await screen.findByRole("img")).toBeVisible();
- expect(disconnect).toHaveBeenCalled();
+ expect(disconnect).not.toHaveBeenCalled();
} finally { cleanup(); vi.unstubAllGlobals(); }
});
it("tries another source when the first capture is unavailable", async () => {
@@ -200,3 +201,45 @@ describe("step evidence media", () => {
expect(screen.queryByLabelText("Local recording")).toBeNull();
});
});
+
+
+describe("recorder references", () => {
+ it("loads each reference only while visible and releases its image off screen", async () => {
+ const observers = new Map<Element, (entries: { isIntersecting: boolean }[]) => void>();
+ vi.stubGlobal("IntersectionObserver", class {
+ callback: (entries: { isIntersecting: boolean }[]) => void;
+ constructor(callback: (entries: { isIntersecting: boolean }[]) => void) { this.callback = callback; }
+ observe(element: Element) { observers.set(element, this.callback); }
+ disconnect() {}
+ });
+ const revoke = vi.fn();
+ Object.defineProperty(URL, "revokeObjectURL", { value: revoke, configurable: true });
+ const first = { ...stage.screenshot!, dataUrl: "" };
+ const second = { ...first, frameId: 9002, timestamp: "2026-09-22T11:02:00Z" };
+ const load = vi.fn().mockImplementation(async (_timestamp, _app, _signal, id) => ({ ...(id === first.frameId ? first : second), dataUrl: `blob:${id}` }));
+ try {
+ const { container } = render(<WorkflowStepEvidence workflow={workflow} stage={{ ...stage, screenshot: null, screenshots: [first, second] }} platform={{ loadWorkflowScreenshot: load } as unknown as WorkflowsPlatform} />);
+ const figures = container.querySelectorAll("figure");
+ expect(load).not.toHaveBeenCalled();
+ act(() => observers.get(figures[0])!([{ isIntersecting: true }]));
+ await screen.findByRole("img");
+ expect(load).toHaveBeenCalledTimes(1);
+ act(() => observers.get(figures[0])!([{ isIntersecting: false }]));
+ await waitFor(() => expect(revoke).toHaveBeenCalledWith(`blob:${first.frameId}`));
+ expect(load.mock.calls[0][2].aborted).toBe(true);
+ expect(screen.queryByRole("img")).toBeNull();
+ act(() => observers.get(figures[1])!([{ isIntersecting: true }]));
+ expect(await screen.findByRole("img")).toHaveAttribute("src", "blob:9002");
+ expect(load).toHaveBeenCalledTimes(2);
+ } finally { cleanup(); vi.unstubAllGlobals(); }
+ });
+
+ it("keeps another screenshot visible when one capture has expired", async () => {
+ const first = { ...stage.screenshot!, dataUrl: "" };
+ const second = { ...first, frameId: 9002 };
+ const load = vi.fn().mockImplementation(async (_timestamp, _app, _signal, id) => id === first.frameId ? null : { ...second, dataUrl: "blob:available" });
+ render(<WorkflowStepEvidence workflow={workflow} stage={{ ...stage, screenshot: null, screenshots: [first, second] }} platform={{ loadWorkflowScreenshot: load } as unknown as WorkflowsPlatform} />);
+ expect(await screen.findByText("This screenshot is no longer available.")).toBeVisible();
+ expect(await screen.findByRole("img")).toHaveAttribute("src", "blob:available");
+ });
+});
diff --git a/apps/screenpipe-app-tauri/components/workflows/workflow-loading.test.tsx b/apps/screenpipe-app-tauri/components/workflows/workflow-loading.test.tsx
index 6b5323f8e..33a0dc884 100644
--- a/apps/screenpipe-app-tauri/components/workflows/workflow-loading.test.tsx
+++ b/apps/screenpipe-app-tauri/components/workflows/workflow-loading.test.tsx
@@ -201,3 +201,11 @@ it("keeps update activity when opening a map and through missing or failed statu
expect(platform.subscribeAnalysisActivity).toHaveBeenCalledOnce();
expect(off).not.toHaveBeenCalled();
});
+
+it.each(["overview", "time", "bottlenecks", "evidence", "privacy"])("routes obsolete %s links to Home", async (view) => {
+ window.history.replaceState(null, "", `/home?mode=workflows&view=${view}`);
+ const platform = createFixtureWorkflowsPlatform();
+ await mount(platform, true);
+ expect(screen.getByRole("heading", { name: "Your workflows" })).toBeVisible();
+ expect(screen.getByRole("button", { name: "Context", exact: true })).toBeVisible();
+});
diff --git a/apps/screenpipe-app-tauri/lib/workflows/disk-storage.ts b/apps/screenpipe-app-tauri/lib/workflows/disk-storage.ts
index e8fe5cfb6..01dcb0854 100644
--- a/apps/screenpipe-app-tauri/lib/workflows/disk-storage.ts
+++ b/apps/screenpipe-app-tauri/lib/workflows/disk-storage.ts
@@ -11,7 +11,7 @@ import {
writeTextFile,
} from "@tauri-apps/plugin-fs";
import type { WorkProfile, WorkflowAnalysis, WorkflowSkillDraft } from "@screenpipe/workflows-ui";
-import { parseGuide, type WorkflowGuide, isAssistantState, type AssistantState } from "@screenpipe/workflows-ui";
+import { serializeWorkflowData, parseGuide, type WorkflowGuide, isAssistantState, type AssistantState } from "@screenpipe/workflows-ui";
const STORAGE_DIRECTORY = "workflows";
const CATALOG_PATH = `${STORAGE_DIRECTORY}/catalog.json`;
@@ -69,16 +69,24 @@ async function readValidated<T>(
return null;
}
-async function replaceWithBackup(path: string, backupPath: string, value: unknown) {
+async function replaceWithBackup(path: string, backupPath: string, value: unknown, validate: (value: unknown) => boolean) {
await mkdir(STORAGE_DIRECTORY, { ...BASE_OPTIONS, recursive: true });
const temporaryPath = `${path}.${Date.now()}.${Math.random().toString(36).slice(2, 10)}.tmp`;
- await writeTextFile(temporaryPath, JSON.stringify(value), BASE_OPTIONS);
-
+ // Resolve the last valid value before touching either file. A corrupt primary
+ // must never replace the good backup that allowed recovery.
+ const previous = await readValidated(path, backupPath, (v): v is unknown => validate(v), "data");
let movedPrevious = false;
try {
- if (await exists(path, BASE_OPTIONS)) {
- if (await exists(backupPath, BASE_OPTIONS)) await remove(backupPath, BASE_OPTIONS);
- await rename(path, backupPath, RENAME_OPTIONS);
+ await writeTextFile(temporaryPath, serializeWorkflowData(value), BASE_OPTIONS);
+ if (previous !== null) {
+ // Preserve the validated recovery value even when the current primary is corrupt.
+ const backupTemporary = `${temporaryPath}.backup`;
+ try {
+ await writeTextFile(backupTemporary, serializeWorkflowData(previous), BASE_OPTIONS);
+ await rename(backupTemporary, backupPath, RENAME_OPTIONS);
+ } finally {
+ if (await exists(backupTemporary, BASE_OPTIONS)) await remove(backupTemporary, BASE_OPTIONS);
+ }
movedPrevious = true;
}
await rename(temporaryPath, path, RENAME_OPTIONS);
@@ -112,7 +120,7 @@ export function loadWorkflowAnalysisFromDisk() {
}
export function saveWorkflowAnalysisToDisk(analysis: WorkflowAnalysis) {
- return queueWrite(() => replaceWithBackup(CATALOG_PATH, CATALOG_BACKUP_PATH, analysis));
+ return queueWrite(() => replaceWithBackup(CATALOG_PATH, CATALOG_BACKUP_PATH, analysis, isStoredWorkflowAnalysis));
}
export function loadWorkProfileFromDisk() {
@@ -120,7 +128,7 @@ export function loadWorkProfileFromDisk() {
}
export function saveWorkProfileToDisk(profile: WorkProfile) {
- return queueWrite(() => replaceWithBackup(PROFILE_PATH, PROFILE_BACKUP_PATH, profile));
+ return queueWrite(() => replaceWithBackup(PROFILE_PATH, PROFILE_BACKUP_PATH, profile, isStoredWorkProfile));
}
export function resetWorkflowDiskStorageForTests() {
@@ -132,7 +140,7 @@ export function loadAssistantFromDisk() {
}
export function saveAssistantToDisk(state: AssistantState) {
- return queueWrite(() => replaceWithBackup("workflows/assistant.json", "workflows/assistant.backup.json", state));
+ return queueWrite(() => replaceWithBackup("workflows/assistant.json", "workflows/assistant.backup.json", state, isAssistantState));
}
// Guide drafts share the app's serialized, recoverable file writes.
@@ -153,7 +161,7 @@ export function saveGuideToDisk(guide: WorkflowGuide) {
return queueWrite(async () => {
const validated = parseGuide(guide);
const guides = await readGuides();
- await replaceWithBackup("workflows/guides.json", "workflows/guides.backup.json", { ...guides, [validated.workflowKey]: validated });
+ await replaceWithBackup("workflows/guides.json", "workflows/guides.backup.json", { ...guides, [validated.workflowKey]: validated }, isGuideStore);
});
}
@@ -180,6 +188,6 @@ export function saveSkillDraftToDisk(workflowKey: string, draft: WorkflowSkillDr
return queueWrite(async () => {
if (!workflowKey || !isSkillDraftStore({ [workflowKey]: draft })) throw new Error("Invalid skill draft");
const drafts = await readSkillDrafts();
- await replaceWithBackup("workflows/skill-drafts.json", "workflows/skill-drafts.backup.json", { ...drafts, [workflowKey]: draft });
+ await replaceWithBackup("workflows/skill-drafts.json", "workflows/skill-drafts.backup.json", { ...drafts, [workflowKey]: draft }, isSkillDraftStore);
});
}
diff --git a/apps/screenpipe-app-tauri/lib/workflows/guide-images.test.ts b/apps/screenpipe-app-tauri/lib/workflows/guide-images.test.ts
new file mode 100644
index 000000000..f1f3f746f
--- /dev/null
+++ b/apps/screenpipe-app-tauri/lib/workflows/guide-images.test.ts
@@ -0,0 +1,66 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+import { beforeEach, expect, it, vi } from "vitest";
+import { fixtureWorkflowAnalysis } from "@screenpipe/workflows-ui/fixture";
+import { exportGuideHtml } from "../../../../packages/workflows-ui/src/guide-images";
+import { guideKey, type WorkflowGuide } from "../../../../packages/workflows-ui/src/guide";
+const workflow = structuredClone(fixtureWorkflowAnalysis.analysis.workflows[0]);
+const capture = { frameId: 42, timestamp: "2026-09-22T10:00:00Z", app: "Notes", visualVerified: true, matchDistanceSeconds: 0, dataUrl: "" };
+workflow.stages[0].screenshot = capture;
+workflow.stages[0].screenshots = [capture];
+const guide: WorkflowGuide = { version: 1, workflowKey: guideKey(workflow), sourceRevision: workflow.revision ?? 0, title: "Read notes", summary: "", prerequisites: [], exceptions: [], completion: [], questions: [], steps: [{ title: "Read", instruction: "Read the brief", expectedResult: "", sourceStage: 0, includeImage: true }] };
+const revoke = vi.fn();
+beforeEach(() => { revoke.mockClear(); Object.defineProperty(URL, "revokeObjectURL", { value: revoke, configurable: true }); });
+it("copies pixels only into an explicit export and releases the temporary image", async () => {
+ const load = vi.fn().mockResolvedValue({ ...capture, dataUrl: "blob:export" });
+ vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ blob: async () => new Blob(["pixel"], { type: "image/png" }) }));
+ try {
+ const html = await exportGuideHtml(guide, workflow, true, load);
+ expect(html).toContain("data:image/png;base64,");
+ expect(load).toHaveBeenCalledWith(capture.timestamp, capture.app, expect.any(AbortSignal), 42);
+ expect(capture.dataUrl).toBe("");
+ expect(revoke).toHaveBeenCalledWith("blob:export");
+ } finally { vi.unstubAllGlobals(); }
+});
+it("never fetches images for text-only exports or a stale SOP", async () => {
+ const load = vi.fn();
+ await exportGuideHtml(guide, workflow, false, load);
+ await exportGuideHtml({ ...guide, sourceRevision: 999 }, workflow, true, load);
+ expect(load).not.toHaveBeenCalled();
+});
+it("reports a missing selected capture instead of silently exporting an incomplete guide", async () => {
+ await expect(exportGuideHtml(guide, workflow, true, vi.fn().mockResolvedValue(null))).rejects.toThrow("no longer available");
+});
+
+it("preserves analysis and nested frame references while omitting copied pixels", async () => {
+ const { serializeWorkflowData } = await import("../../../../packages/workflows-ui/src/screenshots");
+ const saved = { quality: { grade: "strong", screenshotCount: 1 }, screenshot: { ...capture, dataUrl: "data:image/png;base64,AAAA" }, drafts: [{ screenshot: { ...capture, dataUrl: "data:image/png;base64,BBBB" } }] };
+ const restored = JSON.parse(serializeWorkflowData(saved));
+ expect(restored.quality).toEqual(saved.quality);
+ expect(restored.screenshot).toEqual(capture);
+ expect(restored.drafts[0].screenshot).toEqual(capture);
+ expect(saved.screenshot.dataUrl).toContain("AAAA");
+});
+
+it("does not retrieve a screenshot explicitly excluded by the editor", async () => {
+ const unreviewed = structuredClone(workflow);
+ unreviewed.stages[0].screenshot!.visualVerified = false;
+ unreviewed.stages[0].screenshots![0].visualVerified = false;
+ const load = vi.fn();
+ await exportGuideHtml({ ...guide, steps: guide.steps.map(step => ({ ...step, imageExcluded: true })) }, unreviewed, true, load);
+ expect(load).not.toHaveBeenCalled();
+});
+
+it("preserves selected screenshot order when a stage has multiple captures", async () => {
+ const multiple = structuredClone(workflow);
+ const second = { ...capture, frameId: 43, timestamp: "2026-09-22T10:01:00Z" };
+ multiple.stages[0].screenshots = [capture, second];
+ const load = vi.fn().mockResolvedValue({ ...capture, dataUrl: "blob:export" });
+ vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ blob: async () => new Blob(["pixel"], { type: "image/png" }) }));
+ try {
+ expect(await exportGuideHtml(guide, multiple, true, load)).toContain("data:image/png;base64,");
+ expect(load).toHaveBeenCalledTimes(1);
+ expect(load).toHaveBeenCalledWith(capture.timestamp, capture.app, expect.any(AbortSignal), 42);
+ expect(multiple.stages[0].screenshots).toEqual([capture, second]);
+ } finally { vi.unstubAllGlobals(); }
+});
diff --git a/apps/screenpipe-app-tauri/lib/workflows/guide-storage.test.ts b/apps/screenpipe-app-tauri/lib/workflows/guide-storage.test.ts
index a08549087..824e15907 100644
--- a/apps/screenpipe-app-tauri/lib/workflows/guide-storage.test.ts
+++ b/apps/screenpipe-app-tauri/lib/workflows/guide-storage.test.ts
@@ -88,6 +88,27 @@ it("keeps screenshot review through disk validation and backup recovery", async
expect(await loadGuideFromDisk("research")).toEqual(reviewed);
});
+it("retains the good recovery copy when saving after a corrupt primary", async () => {
+ const original = { research: guide };
+ files.set("workflows/guides.json", "broken");
+ files.set("workflows/guides.backup.json", JSON.stringify(original));
+ await saveGuideToDisk({ ...guide, title: "Recovered and edited" });
+ expect(JSON.parse(files.get("workflows/guides.backup.json")!)).toEqual(original);
+ expect((await loadGuideFromDisk("research"))?.title).toBe("Recovered and edited");
+});
+
+it("keeps recovery readable when replacing the primary fails", async () => {
+ const fs = await import("@tauri-apps/plugin-fs");
+ files.set("workflows/guides.json", "broken");
+ files.set("workflows/guides.backup.json", JSON.stringify({ research: guide }));
+ const rename = vi.mocked(fs.rename);
+ const normal = rename.getMockImplementation()!;
+ rename.mockImplementationOnce(normal).mockRejectedValueOnce(new Error("disk full"));
+ await expect(saveGuideToDisk({ ...guide, title: "Lost write" })).rejects.toThrow("disk full");
+ expect(await loadGuideFromDisk("research")).toEqual(guide);
+ expect([...files.keys()].some(key => key.includes(".tmp"))).toBe(false);
+});
+
it("persists video edits alongside the SOP through reload", async () => {
const video = { version: 1 as const, sourceHash: "abc", scenes: [{ id: "section-0", title: "Video title", narration: "Shorter narration.", includeImage: false }] };
await saveGuideToDisk({ ...guide, video });
diff --git a/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.test.ts b/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.test.ts
index 0a8bc80f4..2248a6449 100644
--- a/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.test.ts
+++ b/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.test.ts
@@ -2,7 +2,7 @@
// https://screenpipe.com
import { beforeEach, describe, expect, it, vi } from "vitest";
import { localFetch } from "@/lib/api";
-import { WORKFLOW_TASKS, disableWorkflowTasks, stopWorkflowJob, ensureWorkflowTask, enableWorkflowTask, loadWorkflowTaskSetup, getWorkflowJob, startWorkflowJob, saveWorkflowCorrections, saveWorkflowFeedback, saveWorkflowAnswers, loadScheduledCatalog } from "./scheduled-discovery";
+import { WORKFLOW_TASKS, latestWorkflowJob, disableWorkflowTasks, stopWorkflowJob, ensureWorkflowTask, enableWorkflowTask, loadWorkflowTaskSetup, getWorkflowJob, startWorkflowJob, saveWorkflowCorrections, saveWorkflowFeedback, saveWorkflowAnswers, loadScheduledCatalog } from "./scheduled-discovery";
import { fixtureWorkflowAnalysis } from "@screenpipe/workflows-ui/fixture";
vi.mock("@/lib/api", () => ({localFetch:vi.fn()}));
vi.mock("@/lib/workflows/rollout", () => ({requireWorkflowsRollout:vi.fn(),syncWorkflowsRollout:vi.fn().mockResolvedValue(undefined)}));
@@ -275,3 +275,11 @@ it("bounds stalled schedule reads so the UI can retry", async () => {
fetchMock.mockResolvedValueOnce(response({ error: "Workflow changed" }, 409));
await expect(saveWorkflowAnswers(workflow, "Another answer")).rejects.toMatchObject({ status: 409 });
});
+
+it("polls each role once without reloading the completed catalog", async () => {
+ ws.cycle.status = "complete";
+ executions["workflow-review"] = { id: 25, status: "completed", started_at: end };
+ expect(await latestWorkflowJob()).toMatchObject({ status: "complete" });
+ expect(fetchMock.mock.calls.filter(([path]) => String(path).includes("/executions?"))).toHaveLength(4);
+ expect(fetchMock.mock.calls.some(([path]) => path === "/workflows/catalog")).toBe(false);
+});
diff --git a/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.ts b/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.ts
index 774b2eac1..dd163b261 100644
--- a/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.ts
+++ b/apps/screenpipe-app-tauri/lib/workflows/scheduled-discovery.ts
@@ -145,9 +145,10 @@ async function latestTasks() {
}));
}
export async function latestWorkflowJob(): Promise<WorkflowAnalysisJob | null> {
- const latest = (await latestTasks()).filter(item => item.execution)
+ const tasks = await latestTasks();
+ const latest = tasks.filter(item => item.execution)
.sort((a,b) => Date.parse(b.execution.started_at) - Date.parse(a.execution.started_at))[0];
- return latest ? getWorkflowJob(`${latest.task}:${latest.execution.id}`) : null;
+ return latest ? resolveWorkflowJob(`${latest.task}:${latest.execution.id}`, tasks, false) : null;
}
async function workspace() {
@@ -155,7 +156,11 @@ async function workspace() {
}
export async function getWorkflowJob(id: string): Promise<WorkflowAnalysisJob> {
- const [state, tasks] = await Promise.all([workspace(), latestTasks()]);
+ return resolveWorkflowJob(id, await latestTasks(), true);
+}
+
+async function resolveWorkflowJob(id: string, tasks: Awaited<ReturnType<typeof latestTasks>>, includeResult: boolean): Promise<WorkflowAnalysisJob> {
+ const state = await workspace();
const ws = state.workspace;
const cycleId = typeof ws.cycle?.id === "string" ? ws.cycle.id : undefined;
const running = tasks.find(item => ["running", "queued"].includes(item.execution?.status));
@@ -163,6 +168,7 @@ export async function getWorkflowJob(id: string): Promise<WorkflowAnalysisJob> {
const startedAt = ws.cycle?.end;
if (ws.cycle?.status === "paused") return { id, cycleId, startedAt, status: "incomplete", message: "Update stopped. Resume to continue from saved progress." };
if (ws.cycle?.status === "complete") {
+ if (!includeResult) return { id, cycleId, startedAt, status: "complete" };
const result = await loadScheduledCatalog();
// Completion is the atomic receipt for this exact requested interval.
if (result && result.checkedThrough === ws.cycle.end) return { id, cycleId, startedAt, status: "complete", result };
diff --git a/apps/screenpipe-app-tauri/lib/workflows/source-screenshot.test.ts b/apps/screenpipe-app-tauri/lib/workflows/source-screenshot.test.ts
index a107e7d9f..3a0d7883c 100644
--- a/apps/screenpipe-app-tauri/lib/workflows/source-screenshot.test.ts
+++ b/apps/screenpipe-app-tauri/lib/workflows/source-screenshot.test.ts
@@ -11,11 +11,11 @@ const lookup = (rows = [frame]) => Response.json({ data: rows.map(content => ({
const create = vi.fn().mockReturnValue("blob:source-preview");
beforeEach(() => { fetch.mockReset(); create.mockClear(); Object.defineProperty(URL, "createObjectURL", { value: create, configurable: true }); });
describe("exact source screenshot adapter", () => {
- it("loads the exact frame thumbnail without borrowing a nearby recording or verifying the claim", async () => {
+ it("loads the original exact frame without borrowing a nearby recording or verifying the claim", async () => {
fetch.mockResolvedValueOnce(lookup()).mockResolvedValueOnce(new Response("image", { headers: { "content-type": "image/jpeg" } }));
const image = await loadWorkflowScreenshot(timestamp, "Obsidian", new AbortController().signal);
expect(image).toMatchObject({ frameId: 42, timestamp: frame.timestamp, visualVerified: false, matchDistanceSeconds: 0, dataUrl: "blob:source-preview" });
- expect(fetch.mock.calls[1][0]).toBe("/frames/42/thumbnail?width=960&quality=80&fallback=false");
+ expect(fetch.mock.calls[1][0]).toBe("/frames/42?fallback=false");
const params = new URLSearchParams(String(fetch.mock.calls[0][0]).split("?")[1]);
expect(params.get("app_name")).toBe("Obsidian");
expect(params.get("content_type")).toBe("ocr");
@@ -45,3 +45,38 @@ describe("exact source screenshot adapter", () => {
expect(create).not.toHaveBeenCalled();
});
});
+
+it("resolves a saved ID through metadata and never searches or loads a reused ID", async () => {
+ fetch.mockResolvedValueOnce(Response.json({ frame_id: 42, timestamp: frame.timestamp }))
+ .mockResolvedValueOnce(new Response("original", { headers: { "content-type": "image/png" } }));
+ expect(await loadWorkflowScreenshot(timestamp, "Obsidian", new AbortController().signal, 42)).toMatchObject({ frameId: 42 });
+ expect(fetch.mock.calls.map(([url]) => url)).toEqual(["/frames/42/metadata", "/frames/42?fallback=false"]);
+ fetch.mockClear();
+ fetch.mockResolvedValueOnce(Response.json({ frame_id: 42, timestamp: "2026-09-24T02:07:42.820688Z" }));
+ expect(await loadWorkflowScreenshot(timestamp, "Obsidian", new AbortController().signal, 42)).toBeNull();
+ expect(fetch).toHaveBeenCalledTimes(1);
+});
+
+it("rejects oversized image streams even without a Content-Length header", async () => {
+ const cancel = vi.fn();
+ const body = new ReadableStream({ start(controller) { controller.enqueue(new Uint8Array(17 * 1024 * 1024)); }, cancel });
+ fetch.mockResolvedValueOnce(lookup()).mockResolvedValueOnce(new Response(body, { headers: { "content-type": "image/png" } }));
+ await expect(loadWorkflowScreenshot(timestamp, "Obsidian", new AbortController().signal)).rejects.toThrow("limit");
+ expect(cancel).toHaveBeenCalled();
+ expect(create).not.toHaveBeenCalled();
+});
+
+it("bounds parallel image requests and removes aborted work from the queue", async () => {
+ const complete: ((value: Response) => void)[] = [];
+ fetch.mockImplementation(() => new Promise(resolve => complete.push(resolve)));
+ const controllers = Array.from({ length: 5 }, () => new AbortController());
+ const calls = controllers.map(controller => loadWorkflowScreenshot(timestamp, "Obsidian", controller.signal, 42).catch(e => e));
+ await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(3));
+ controllers[3].abort();
+ complete[0](new Response(null, { status: 404 }));
+ await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(4));
+ complete.slice(1).forEach(resolve => resolve(new Response(null, { status: 404 })));
+ const results = await Promise.all(calls);
+ expect(results[3]).toMatchObject({ name: "AbortError" });
+ expect(create).not.toHaveBeenCalled();
+});
diff --git a/apps/screenpipe-app-tauri/lib/workflows/source-screenshot.ts b/apps/screenpipe-app-tauri/lib/workflows/source-screenshot.ts
index c9ea05e18..7505ff580 100644
--- a/apps/screenpipe-app-tauri/lib/workflows/source-screenshot.ts
+++ b/apps/screenpipe-app-tauri/lib/workflows/source-screenshot.ts
@@ -12,34 +12,78 @@ function instant(value: string): string | null {
return `${Math.floor(time / 1000)}:${fraction.padEnd(9, "0")}`;
}
-export async function loadWorkflowScreenshot(timestamp: string, app: string, signal: AbortSignal): Promise<WorkflowScreenshot | null> {
- if (!instant(timestamp) || !app.trim()) return null;
+export async function loadWorkflowScreenshot(timestamp: string, app: string, signal: AbortSignal, frameId?: number): Promise<WorkflowScreenshot | null> {
+ if (!instant(timestamp) || !app.trim() || (frameId !== undefined && (!Number.isSafeInteger(frameId) || frameId <= 0))) return null;
const controller = new AbortController();
const abort = () => controller.abort();
signal.addEventListener("abort", abort, { once: true });
if (signal.aborted) abort();
const timeout = setTimeout(abort, 10_000);
+ let release: (() => void) | undefined;
try {
- const frame = await findWorkflowScreenshot(timestamp, app, controller.signal);
- if (!frame) return null;
- const image = await localFetch(`/frames/${frame.frameId}/thumbnail?width=960&quality=80&fallback=false`, { signal: controller.signal });
+ release = await acquire(controller.signal);
+ const source = await findWorkflowScreenshot(timestamp, app, controller.signal, frameId);
+ if (!source) return null;
+ const frame = { frame_id: source.frameId, timestamp: source.timestamp, app_name: source.app };
+ const image = await localFetch(`/frames/${frame.frame_id}?fallback=false`, { signal: controller.signal });
if (image.status === 404 || image.status === 410) return null;
if (!image.ok) throw new Error("Could not load the source screenshot");
- const blob = await image.blob();
- if (!/^image\/(jpeg|png|webp)$/.test(blob.type) || !blob.size || blob.size > 2_000_000) {
+ const mime = image.headers.get("content-type")?.split(";")[0] ?? "";
+ const limit = 16 * 1024 * 1024;
+ if (!/^image\/(jpeg|png|webp)$/.test(mime) || Number(image.headers.get("content-length")) > limit || !image.body) {
+ await image.body?.cancel();
throw new Error("Invalid source screenshot");
}
+ const reader = image.body.getReader();
+ const chunks: Uint8Array[] = [];
+ let size = 0;
+ try {
+ while (true) {
+ controller.signal.throwIfAborted();
+ const { done, value } = await reader.read();
+ if (done) break;
+ size += value.byteLength;
+ if (size > limit) throw new Error("Source screenshot exceeds the image limit");
+ chunks.push(value);
+ }
+ } finally { await reader.cancel().catch(() => {}); reader.releaseLock(); }
+ if (!size) throw new Error("Invalid source screenshot");
+ const blob = new Blob(chunks as BlobPart[], { type: mime });
controller.signal.throwIfAborted();
- return { ...frame, dataUrl: URL.createObjectURL(blob) };
+ return { frameId: frame.frame_id, timestamp: frame.timestamp, app: frame.app_name,
+ matchDistanceSeconds: 0, visualVerified: false, dataUrl: URL.createObjectURL(blob) };
} finally {
+ release?.();
clearTimeout(timeout);
signal.removeEventListener("abort", abort);
}
}
-/** Resolve only the exact captured source. No thumbnails or neighboring frames. */
-export async function findWorkflowScreenshot(timestamp: string, app: string, signal: AbortSignal): Promise<WorkflowScreenshot | null> {
- if (!instant(timestamp) || !app.trim()) return null;
+// Bound simultaneous decoding/transfer without introducing another image cache.
+// Queued requests are cancellable and retain no image bytes.
+let active = 0;
+const waiting: (() => void)[] = [];
+function acquire(signal: AbortSignal): Promise<() => void> {
+ return new Promise((resolve, reject) => {
+ const cancel = () => {
+ const index = waiting.indexOf(start);
+ if (index >= 0) waiting.splice(index, 1);
+ reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+ };
+ const start = () => {
+ signal.removeEventListener("abort", cancel);
+ if (signal.aborted) { cancel(); return; }
+ active++;
+ resolve(() => { active--; waiting.shift()?.(); });
+ };
+ if (signal.aborted) { cancel(); return; }
+ signal.addEventListener("abort", cancel, { once: true });
+ if (active < 3) start(); else waiting.push(start);
+ });
+}
+
+export async function findWorkflowScreenshot(timestamp: string, app: string, signal: AbortSignal, frameId?: number): Promise<WorkflowScreenshot | null> {
+ if (!instant(timestamp) || !app.trim() || (frameId !== undefined && (!Number.isSafeInteger(frameId) || frameId <= 0))) return null;
signal.throwIfAborted();
const controller = new AbortController();
const abort = () => controller.abort();
@@ -47,24 +91,30 @@ export async function findWorkflowScreenshot(timestamp: string, app: string, sig
const timeout = setTimeout(abort, 10_000);
try {
const time = Date.parse(timestamp);
- const query = new URLSearchParams({ content_type: "ocr", app_name: app,
- start_time: new Date(time - 1).toISOString(), end_time: new Date(time + 1).toISOString(),
- limit: "20", offset: "0" });
- const response = await localFetch(`/search?${query}`, { signal: controller.signal });
- if (!response.ok) throw new Error("Could not look up the source screenshot");
- const result = await response.json();
- const frame = result.data?.map((row: { content?: Record<string, unknown> }) => row.content)
- .find((row: Record<string, unknown> | undefined) => row
- && typeof row.timestamp === "string" && instant(row.timestamp) === instant(timestamp)
- && typeof row.app_name === "string" && row.app_name.toLowerCase() === app.toLowerCase()
- && Number.isSafeInteger(row.frame_id) && Number(row.frame_id) > 0);
+ let frame: { frame_id: number; timestamp: string; app_name: string } | undefined;
+ if (frameId !== undefined) {
+ const response = await localFetch(`/frames/${frameId}/metadata`, { signal: controller.signal });
+ if (response.status === 404 || response.status === 410) return null;
+ if (!response.ok) throw new Error("Could not look up the source screenshot");
+ const metadata = await response.json();
+ // IDs can be reused after a recorder/database switch. Never show another capture.
+ if (metadata.frame_id !== frameId || typeof metadata.timestamp !== "string" || instant(metadata.timestamp) !== instant(timestamp)) return null;
+ frame = { frame_id: frameId, timestamp: metadata.timestamp, app_name: app };
+ } else {
+ const query = new URLSearchParams({ content_type: "ocr", app_name: app,
+ start_time: new Date(time - 1).toISOString(), end_time: new Date(time + 1).toISOString(),
+ limit: "20", offset: "0" });
+ const response = await localFetch(`/search?${query}`, { signal: controller.signal });
+ if (!response.ok) throw new Error("Could not look up the source screenshot");
+ const result = await response.json();
+ frame = result.data?.map((row: { content?: Record<string, unknown> }) => row.content)
+ .find((row: Record<string, unknown> | undefined) => row
+ && typeof row.timestamp === "string" && instant(row.timestamp) === instant(timestamp)
+ && typeof row.app_name === "string" && row.app_name.toLowerCase() === app.toLowerCase()
+ && Number.isSafeInteger(row.frame_id) && Number(row.frame_id) > 0);
+ }
if (!frame) return null;
controller.signal.throwIfAborted();
- return { frameId: frame.frame_id, timestamp: frame.timestamp, app: frame.app_name,
- matchDistanceSeconds: 0, visualVerified: false, dataUrl: "" };
-
- } finally {
- clearTimeout(timeout);
- signal.removeEventListener("abort", abort);
- }
+ return { frameId: frame.frame_id, timestamp: frame.timestamp, app: frame.app_name, matchDistanceSeconds: 0, visualVerified: false, dataUrl: "" };
+ } finally { clearTimeout(timeout); signal.removeEventListener("abort", abort); }
}
diff --git a/apps/screenpipe-app-tauri/src-tauri/src/workflows_runtime.rs b/apps/screenpipe-app-tauri/src-tauri/src/workflows_runtime.rs
index 2a50cc0bb..186b5169b 100644
--- a/apps/screenpipe-app-tauri/src-tauri/src/workflows_runtime.rs
+++ b/apps/screenpipe-app-tauri/src-tauri/src/workflows_runtime.rs
@@ -464,43 +464,12 @@ async fn stage_screenshot(endpoint: &RecorderEndpoint, stage: &Value) -> Option<
else {
continue;
};
- let thumbnail_url = format!(
- "{}/frames/{frame_id}/thumbnail?width=640&quality=68&fallback=false",
- endpoint.base_url
- );
- let Ok(thumbnail) = apply_auth(
- endpoint,
- reqwest::Client::new()
- .get(thumbnail_url)
- .timeout(Duration::from_secs(10)),
- )
- .send()
- .await
- else {
- continue;
- };
- if !thumbnail.status().is_success() {
- continue;
- }
- let mime = thumbnail
- .headers()
- .get(reqwest::header::CONTENT_TYPE)
- .and_then(|value| value.to_str().ok())
- .filter(|value| value.starts_with("image/"))
- .unwrap_or("image/jpeg")
- .to_string();
- let Ok(bytes) = thumbnail.bytes().await else {
- continue;
- };
- if bytes.is_empty() || bytes.len() > 500_000 {
- continue;
- }
return Some(json!({
"frameId": frame_id,
"timestamp": frame_timestamp,
"app": app,
"matchDistanceSeconds": distance_seconds,
- "dataUrl": format!("data:{mime};base64,{}", BASE64.encode(bytes)),
+ "dataUrl": "",
}));
}
}
diff --git a/apps/screenpipe-workflows-web/scripts/eval-workflow-storage.cjs b/apps/screenpipe-workflows-web/scripts/eval-workflow-storage.cjs
new file mode 100644
index 000000000..6b57dfe29
--- /dev/null
+++ b/apps/screenpipe-workflows-web/scripts/eval-workflow-storage.cjs
@@ -0,0 +1,42 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+const { chromium } = require("playwright");
+const assert = require("node:assert/strict");
+
+// Uses the maintained fictional preview. Never opens or edits a live catalog.
+(async () => {
+ const browser = await chromium.launch({ headless: true, channel: "chrome" });
+ try {
+ const page = await browser.newPage({ viewport: { width: 1440, height: 1080 } });
+ page.setDefaultTimeout(20000);
+ const errors = [];
+ page.on("pageerror", error => errors.push(error.message));
+ const base = process.env.WORKFLOWS_PREVIEW_URL || "http://127.0.0.1:1431/preview";
+ const field = name => page.getByRole("textbox", { name, exact: true });
+ const button = name => page.getByRole("button", { name, exact: true });
+
+ await page.goto(base);
+ await button("Open map").first().click();
+ await field("Workflow title").fill("Review synthesis safely");
+ await field("Workflow description").click();
+ await page.getByRole("status", { name: "Save status" }).filter({ hasText: /^Saved$/ }).waitFor();
+ await page.reload();
+ await button("Open map").first().click();
+ assert.equal(await field("Workflow title").textContent(), "Review synthesis safely");
+ await button("Context").click();
+ await field("Role and responsibilities").waitFor();
+ await page.getByRole("button", { name: /^Home/ }).click();
+ await page.getByRole("heading", { name: "Your workflows", exact: true }).waitFor();
+
+ for (const view of ["overview", "time", "bottlenecks", "evidence", "privacy"]) {
+ const url = new URL(base);
+ url.searchParams.set("view", view);
+ await page.goto(url.toString());
+ await page.getByRole("heading", { name: "Your workflows", exact: true }).waitFor();
+ }
+ assert.deepEqual(errors, []);
+ console.log("PASS: Home, editor, saved edit after reload, Context, five obsolete routes, no page errors.");
+ } finally {
+ await browser.close();
+ }
+})().catch(error => { console.error(error); process.exitCode = 1; });
diff --git a/crates/screenpipe-core/src/workflows/mod.rs b/crates/screenpipe-core/src/workflows/mod.rs
index 550eda5e8..036f28668 100644
--- a/crates/screenpipe-core/src/workflows/mod.rs
+++ b/crates/screenpipe-core/src/workflows/mod.rs
@@ -1266,6 +1266,34 @@ pub fn measured_time_profile(
})
}
+/// Catalogs retain capture identity, never independent copies of recorder pixels.
+/// Recursing also covers retained workflow revisions and workspace drafts.
+/// Keep the empty field for older readers that expect a string.
+pub fn discard_screenshot_pixels(value: &mut Value) {
+ match value {
+ Value::Object(object) => {
+ if object
+ .get("frameId")
+ .and_then(Value::as_i64)
+ .is_some_and(|id| id > 0)
+ && object.get("timestamp").and_then(Value::as_str).is_some()
+ && object.contains_key("dataUrl")
+ {
+ object.insert("dataUrl".into(), json!(""));
+ }
+ for child in object.values_mut() {
+ discard_screenshot_pixels(child);
+ }
+ }
+ Value::Array(array) => {
+ for child in array {
+ discard_screenshot_pixels(child);
+ }
+ }
+ _ => {}
+ }
+}
+
/// Requested exact frames, in display order. Old clients may send a single ID.
pub fn screenshot_frame_ids(stage: &Value) -> Vec<i64> {
let mut seen = HashSet::new();
diff --git a/crates/screenpipe-core/tests/workflow_media_storage.rs b/crates/screenpipe-core/tests/workflow_media_storage.rs
new file mode 100644
index 000000000..836058f41
--- /dev/null
+++ b/crates/screenpipe-core/tests/workflow_media_storage.rs
@@ -0,0 +1,35 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+use screenpipe_core::workflows::discard_screenshot_pixels;
+use serde_json::json;
+
+#[test]
+fn legacy_catalogs_keep_capture_identity_without_pixels_in_retained_drafts() {
+ let capture = json!({"frameId":42,"timestamp":"2026-09-22T10:00:00Z","app":"Notes",
+ "visualVerified":true,"dataUrl":format!("data:image/jpeg;base64,{}", "x".repeat(200_000))});
+ let mut catalog = json!({"analysis":{"workflows":[{"id":"wf-notes","userCorrection":"Keep my edits",
+ "stages":[{"screenshot":capture,"screenshots":[capture]}]}]},
+ "agentWorkspace":{"drafts":{"review":{"payload":{"screenshots":[capture]}}}},
+ "unrelated":{"dataUrl":"retain arbitrary user content"}});
+ let before = serde_json::to_vec(&catalog).unwrap().len();
+ discard_screenshot_pixels(&mut catalog);
+ let after = serde_json::to_vec(&catalog).unwrap().len();
+ assert!(before > 600_000 && after < 1500);
+ let shot = &catalog["analysis"]["workflows"][0]["stages"][0]["screenshot"];
+ assert_eq!(shot["frameId"], 42);
+ assert_eq!(shot["timestamp"], "2026-09-22T10:00:00Z");
+ assert_eq!(shot["visualVerified"], true);
+ assert_eq!(shot["dataUrl"], "");
+ assert_eq!(
+ catalog["analysis"]["workflows"][0]["userCorrection"],
+ "Keep my edits"
+ );
+ assert_eq!(
+ catalog["unrelated"]["dataUrl"],
+ "retain arbitrary user content"
+ );
+ let once = catalog.clone();
+ discard_screenshot_pixels(&mut catalog);
+ assert_eq!(once, catalog);
+ println!("synthetic catalog bytes: {before} -> {after}");
+}
diff --git a/crates/screenpipe-engine/src/routes/workflow_catalog.rs b/crates/screenpipe-engine/src/routes/workflow_catalog.rs
index 65a310276..b69e1ab9c 100644
--- a/crates/screenpipe-engine/src/routes/workflow_catalog.rs
+++ b/crates/screenpipe-engine/src/routes/workflow_catalog.rs
@@ -236,8 +236,12 @@ pub(super) async fn persist(
"Workflow storage is unavailable.",
)
})?;
- let before = serde_json::to_vec(previous).unwrap();
- let after = serde_json::to_vec(next).unwrap();
+ let mut previous = previous.clone();
+ let mut next = next.clone();
+ discard_screenshot_pixels(&mut previous);
+ discard_screenshot_pixels(&mut next);
+ let before = serde_json::to_vec(&previous).unwrap();
+ let after = serde_json::to_vec(&next).unwrap();
if after.len() as u64 > super::workflows::MAX_CATALOG_BYTES {
return Err(error(
StatusCode::PAYLOAD_TOO_LARGE,
@@ -441,7 +445,7 @@ pub(crate) async fn commit(
.find(|s| s["name"] == stage["name"])
.map(screenshot_frame_ids)
.unwrap_or_default();
- attach_stage_screenshots(stage, frames, &evidence, &endpoint).await;
+ attach_stage_screenshots(stage, frames, &evidence);
}
}
}
@@ -648,12 +652,7 @@ pub(crate) async fn correct(
Ok(Json(json!({"success":true,"workflow":updated_workflow})))
}
-async fn attach_stage_screenshots(
- stage: &mut Value,
- frames: Vec<i64>,
- evidence: &EvidenceCatalog,
- endpoint: &RecorderEndpoint,
-) {
+fn attach_stage_screenshots(stage: &mut Value, frames: Vec<i64>, evidence: &EvidenceCatalog) {
let mut screenshots = Vec::new();
for id in frames {
if let Some((timestamp, app)) = evidence.frames.get(&id) {
@@ -667,27 +666,7 @@ async fn attach_stage_screenshots(
.is_some_and(|at| at == *timestamp)
});
if matches {
- let response = apply_auth(
- endpoint,
- reqwest::Client::new()
- .get(format!(
- "{}/frames/{id}/thumbnail?width=640&quality=68&fallback=false",
- endpoint.base_url
- ))
- .timeout(Duration::from_secs(10)),
- )
- .send()
- .await;
- if let Ok(response) = response {
- if response.status().is_success() {
- if let Ok(bytes) = response.bytes().await {
- if !bytes.is_empty() && bytes.len() <= 500_000 {
- use base64::Engine;
- screenshots.push(json!({"frameId":id,"timestamp":timestamp.to_rfc3339(),"app":app,"matchDistanceSeconds":0,"visualVerified":true,"dataUrl":format!("data:image/jpeg;base64,{}",base64::engine::general_purpose::STANDARD.encode(bytes))}));
- }
- }
- }
- }
+ screenshots.push(json!({"frameId":id,"timestamp":timestamp.to_rfc3339(),"app":app,"matchDistanceSeconds":0,"visualVerified":true,"dataUrl":""}));
}
}
}
@@ -698,34 +677,7 @@ async fn attach_stage_screenshots(
mod tests {
use super::*;
#[tokio::test]
- async fn multiple_exact_images_survive_publish_storage_and_reload() {
- use axum::{routing::get, Router};
- let app = Router::new().route(
- "/frames/:id/thumbnail",
- get(
- |axum::extract::Path(id): axum::extract::Path<i64>,
- axum::extract::Query(query): axum::extract::Query<
- std::collections::HashMap<String, String>,
- >| async move {
- assert_eq!(query.get("fallback").map(String::as_str), Some("false"));
- if id == 4 {
- (StatusCode::NOT_FOUND, Vec::new())
- } else {
- (StatusCode::OK, vec![0xff, 0xd8, 0xff, 0xd9])
- }
- },
- ),
- );
- let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
- let endpoint = RecorderEndpoint {
- source: "test",
- base_url: format!("http://{}", listener.local_addr().unwrap()),
- api_key: None,
- health: Value::Null,
- };
- let server = tokio::spawn(async move {
- axum::serve(listener, app).await.unwrap();
- });
+ async fn multiple_exact_references_survive_publish_storage_and_reload() {
let at = DateTime::parse_from_rfc3339("2026-09-22T10:00:00Z")
.unwrap()
.with_timezone(&Utc);
@@ -740,9 +692,9 @@ mod tests {
{"timestamp":(at + ChronoDuration::seconds(2)).to_rfc3339(),"app":"Notes"},
{"timestamp":(at + ChronoDuration::seconds(4)).to_rfc3339(),"app":"Notes"}
]});
- // Duplicate, unsupported, unavailable, and missing frame references cannot add images.
+ // Keep exact references even if media later expires; the recorder owns availability.
let frames = screenshot_frame_ids(&json!({"screenshotFrameIds":[2,1,2,3,4,999]}));
- attach_stage_screenshots(&mut stage, frames, &evidence, &endpoint).await;
+ attach_stage_screenshots(&mut stage, frames, &evidence);
assert_eq!(
stage["screenshots"]
.as_array()
@@ -750,13 +702,15 @@ mod tests {
.iter()
.map(|image| image["frameId"].as_i64().unwrap())
.collect::<Vec<_>>(),
- vec![2, 1]
+ vec![2, 1, 4]
);
assert!(stage["screenshots"]
.as_array()
.unwrap()
.iter()
- .all(|image| image["visualVerified"] == true && image["matchDistanceSeconds"] == 0));
+ .all(|image| image["visualVerified"] == true
+ && image["matchDistanceSeconds"] == 0
+ && image["dataUrl"] == ""));
let dir = tempfile::tempdir().unwrap();
let source = WorkflowCatalogSource(Some(dir.path().to_path_buf()));
let previous = read_catalog(&source).await.unwrap();
@@ -766,7 +720,6 @@ mod tests {
read_catalog(&source).await.unwrap()["analysis"],
next["analysis"]
);
- server.abort();
}
#[test]
diff --git a/crates/screenpipe-engine/src/routes/workflows.rs b/crates/screenpipe-engine/src/routes/workflows.rs
index 2df35911b..0c4fc688f 100644
--- a/crates/screenpipe-engine/src/routes/workflows.rs
+++ b/crates/screenpipe-engine/src/routes/workflows.rs
@@ -70,8 +70,9 @@ pub(super) async fn read_catalog(source: &WorkflowCatalogSource) -> Result<Value
{
continue;
}
- if let Ok(value) = serde_json::from_slice::<Value>(&bytes) {
+ if let Ok(mut value) = serde_json::from_slice::<Value>(&bytes) {
if value["schemaVersion"] == 5 && value["analysis"]["workflows"].is_array() {
+ screenpipe_core::workflows::discard_screenshot_pixels(&mut value);
return Ok(value);
}
}
diff --git a/docs/pr-assets/workflow-storage-reliability/README.md b/docs/pr-assets/workflow-storage-reliability/README.md
new file mode 100644
index 000000000..6eb14113e
--- /dev/null
+++ b/docs/pr-assets/workflow-storage-reliability/README.md
@@ -0,0 +1,56 @@
+# Workflow storage and reliability audit
+
+<!-- doc-covers: packages/workflows-ui/src/ apps/screenpipe-app-tauri/lib/workflows/ crates/screenpipe-core/src/workflows/ crates/screenpipe-engine/src/routes/workflow_catalog.rs -->
+<!-- doc-verified: e89530e2d -->
+
+Audited against `e89530e2d` on September 29, 2026. Scope: Workflows capture references, catalog persistence and recovery, scheduler status, screenshot rendering, SOP image review/export, and obsolete UI paths. This is a bounded audit of those paths, not a claim that every Workflows edge case is resolved.
+
+## Findings and changes
+
+| Finding | Change | Boundary checked |
+| --- | --- | --- |
+| Both catalog writers fetched and embedded a separate 640px JPEG. Catalogs and backups duplicated those pixels. | Store frame ID, timestamp and app. Strip legacy pixel fields on backend reads and subsequent saves, including backups and nested revisions. | Core migration test; backend save/read roundtrip; native workflow tests. |
+| Large previews displayed the small embedded copy. | Resolve the original recorder frame, with nearest-frame fallback disabled. Verify exact timestamp before fetching an existing frame ID. | Exact identity, reused ID, missing capture, HTTP failures and oversized streaming responses. |
+| Screenshot lifecycle could retain offscreen blobs or repeat irrelevant lookups. | Load near the viewport, cancel on leave/unmount, revoke blobs, deduplicate source lookups, and limit concurrent transfers to three. | Multiple independent references, one expired capture, viewport entry/exit and late response cleanup. |
+| SOP review/export depended on catalog pixels. | Review uses the same source loader. Only explicit HTML image export embeds selected pixels. Missing selected media fails visibly; text-only and stale-source exports do not fetch. | Review tests and explicit export tests. |
+| Read-only details had a second screenshot renderer. | Use the shared evidence component in both detail paths. | Shared evidence and workflow tests. |
+| Browser caching removed frame identities and lowered quality scores. | A shared serializer omits pixels while preserving references, user content and quality metadata. | Nested reference serialization test. |
+| A corrupt primary could overwrite the valid backup on the next frontend save. | Read and validate the recovery value before rotating the backup. Preserve it if replacement fails. | Corrupt primary, failed rename, queued guide writes and recovery tests. |
+| Every idle poll repeated role lookups and loaded a completed catalog again. | Reuse the fetched role status, separate status from result loading, and poll every 30 seconds idle / 3 seconds active. Retry completion retrieval until its result is available. | Scheduled discovery request assertions and completion tests. |
+| Old overview, time, evidence, bottleneck and privacy screens remained in the active app module. | Delete unused screens, their state/helpers, the old sign-in poller and 163 unused CSS rules. Existing legacy URLs continue to open Home. | Five legacy-route tests plus Home, detail and Context tests. |
+
+## Storage and performance evidence
+
+The synthetic migration test contains repeated screenshot payloads in a current value and retained drafts. Serialized size falls from 600,612 bytes to 543 bytes while preserving frame identity and unrelated content. This illustrates eliminated image duplication; it is not a production storage measurement.
+
+Catalog commits no longer request or encode screenshots. Image reads use the recorder's existing API and cache. No capture callback, database writer, recorder retention setting or background recording path changes. The loader limits each image response to 16 MiB, including responses without Content-Length, and uses a ten-second deadline. The UI's legacy multi-source search has a thirty-second overall deadline.
+
+## Visual evidence
+
+All images use fictional product notes in the actual shared WorkflowEditor and WorkflowStepEvidence components, with product theme styles. The before image uses the evidence component from base `e89530e2d` and a 640px JPEG, quality 68. The after image resolves a 2400px source. This is an isolated component preview, not an installed desktop recording.
+
+Desktop: 1440 × 1080 CSS pixels at 2× scale. Mobile: 390 × 844 at 2×. States: before, original loaded, loading, unavailable, failed/retry, recovered, and mobile. Temporary routes and capture fixtures are removed from the patch.
+
+## Remaining limits
+
+- Existing on-disk catalogs shrink on their next successful save. This patch does not silently rewrite user files or delete captures during startup.
+- Recorder retention can remove an original. Workflows then shows an unavailable message; it does not retain a secret second copy or substitute a nearby frame.
+- Existing schema-version-5 compatibility keeps `dataUrl` as an empty string for recorder references. Explicit exports can contain image data.
+- The backend retains its 32 MiB catalog limit. Oversized or unreadable legacy files are preserved and reported, not automatically repaired.
+- Frontend guide/profile/assistant writes remain serialized within their existing app context. This change does not introduce a new cross-process storage service.
+- Native workflow unit tests run through the build queue. Installed-app end-to-end behavior, Windows native behavior, real-data migration and battery/memory profiling are not established by these tests.
+
+## Local validation
+
+- App: `bun run test:vitest lib/workflows components/workflows`: 310 passed.
+- App: `bun run typecheck`: passed.
+- Shared web preview: `bun run typecheck`: passed with its installed peer dependencies available at the repository root.
+- Core: `cargo test -p screenpipe-core workflows:: --lib`: 39 passed.
+- Migration: `cargo test -p screenpipe-core --test workflow_media_storage -- --nocapture`: 1 passed.
+- Backend: `cargo test -p screenpipe-engine --lib routes::workflow`: 25 passed.
+- Native app: `bun run test:tauri workflows_runtime::`: 33 passed through the native build queue.
+- Browser: `WORKFLOWS_PREVIEW_URL=http://localhost:1461/preview bun scripts/eval-workflow-storage.cjs`: passed against the maintained fictional preview.
+- Coverage dashboards: `bun run coverage:all:check`: passed after regeneration. The pre-existing dashboard drift concerned audio test counts; the regeneration adds no audio behavior changes.
+- `git diff --check`: passed.
+
+The production app was not restarted or replaced. Signed-in GitHub browser verification is unavailable in this session because the browser tool reports `unsupported Codex auth method: apikey`. PR image URLs can still be checked through HTTP; that check is distinct from browser rendering.
diff --git a/docs/pr-assets/workflow-storage-reliability/after.png b/docs/pr-assets/workflow-storage-reliability/after.png
new file mode 100644
index 000000000..7b5560d1c
Binary files /dev/null and b/docs/pr-assets/workflow-storage-reliability/after.png differ
diff --git a/docs/pr-assets/workflow-storage-reliability/before.png b/docs/pr-assets/workflow-storage-reliability/before.png
new file mode 100644
index 000000000..6ec02758a
Binary files /dev/null and b/docs/pr-assets/workflow-storage-reliability/before.png differ
diff --git a/docs/pr-assets/workflow-storage-reliability/loading.png b/docs/pr-assets/workflow-storage-reliability/loading.png
new file mode 100644
index 000000000..cc329b577
Binary files /dev/null and b/docs/pr-assets/workflow-storage-reliability/loading.png differ
diff --git a/docs/pr-assets/workflow-storage-reliability/missing.png b/docs/pr-assets/workflow-storage-reliability/missing.png
new file mode 100644
index 000000000..454830dce
Binary files /dev/null and b/docs/pr-assets/workflow-storage-reliability/missing.png differ
diff --git a/docs/pr-assets/workflow-storage-reliability/mobile.png b/docs/pr-assets/workflow-storage-reliability/mobile.png
new file mode 100644
index 000000000..f211ff4dd
Binary files /dev/null and b/docs/pr-assets/workflow-storage-reliability/mobile.png differ
diff --git a/docs/pr-assets/workflow-storage-reliability/recovered.png b/docs/pr-assets/workflow-storage-reliability/recovered.png
new file mode 100644
index 000000000..66efa360b
Binary files /dev/null and b/docs/pr-assets/workflow-storage-reliability/recovered.png differ
diff --git a/docs/pr-assets/workflow-storage-reliability/retry.png b/docs/pr-assets/workflow-storage-reliability/retry.png
new file mode 100644
index 000000000..c353b07f6
Binary files /dev/null and b/docs/pr-assets/workflow-storage-reliability/retry.png differ
diff --git a/packages/workflows-ui/src/guide-images.ts b/packages/workflows-ui/src/guide-images.ts
new file mode 100644
index 000000000..749a2d651
--- /dev/null
+++ b/packages/workflows-ui/src/guide-images.ts
@@ -0,0 +1,40 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+import { guideHtml, guideScreenshot, guideSourceStage, guideStepIncludesImage, type WorkflowGuide } from "./guide";
+import type { WorkflowMap } from "./model";
+import type { WorkflowsPlatform } from "./platform";
+
+/** Only an explicit image export copies recorder pixels into the exported document. */
+export async function exportGuideHtml(guide: WorkflowGuide, workflow: WorkflowMap, images: boolean,
+ load?: WorkflowsPlatform["loadWorkflowScreenshot"]): Promise<string> {
+ if (!images || !load || guide.sourceRevision !== (workflow.revision ?? 0)) return guideHtml(guide, workflow, images);
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), 60_000);
+ const stages = workflow.stages.map(stage => ({ ...stage }));
+ try {
+ const selected = guide.steps.filter(guideStepIncludesImage).map(step => {
+ const index = guideSourceStage(guide, step, workflow);
+ return index == null ? null : { index, source: guideScreenshot(workflow, index, step.imageReview) };
+ }).filter((item): item is NonNullable<typeof item> => item !== null);
+ for (const { index, source } of selected) {
+ if (!source) continue;
+ const image = await load(source.timestamp, source.app, controller.signal, source.frameId);
+ if (!image) throw new Error("A selected screenshot is no longer available. Remove it or export without screenshots.");
+ try {
+ const blob = await (await fetch(image.dataUrl, { signal: controller.signal })).blob();
+ const dataUrl = await new Promise<string>((resolve, reject) => {
+ const reader = new FileReader();
+ reader.onload = () => resolve(String(reader.result));
+ reader.onerror = () => reject(reader.error);
+ reader.readAsDataURL(blob);
+ });
+ const capture = { ...source, dataUrl };
+ const previous = stages[index].screenshots ?? [source];
+ const matches = (image: typeof source) => image.frameId === capture.frameId && image.timestamp === capture.timestamp;
+ const screenshots = previous.some(matches) ? previous.map(image => matches(image) ? capture : image) : [...previous, capture];
+ stages[index] = { ...stages[index], screenshot: screenshots[0], screenshots };
+ } finally { if (image.dataUrl.startsWith("blob:")) URL.revokeObjectURL(image.dataUrl); }
+ }
+ return guideHtml(guide, { ...workflow, stages }, true);
+ } finally { clearTimeout(timeout); controller.abort(); }
+}
diff --git a/packages/workflows-ui/src/index.ts b/packages/workflows-ui/src/index.ts
index 8ac0f422b..35788ae14 100644
--- a/packages/workflows-ui/src/index.ts
+++ b/packages/workflows-ui/src/index.ts
@@ -29,5 +29,6 @@ export * from "./workflow-edits";
export * from "./questionnaire-voice";
+export { serializeWorkflowData } from "./screenshots";
export { videoEditPrompt } from "./video-edit-prompt";
export { applyVideoEdit, parseVideoEdit, parseVideoDraft, type VideoDraft, type VideoEdit } from "./video-tool";
diff --git a/packages/workflows-ui/src/platform.ts b/packages/workflows-ui/src/platform.ts
index 53855903b..80a4f9688 100644
--- a/packages/workflows-ui/src/platform.ts
+++ b/packages/workflows-ui/src/platform.ts
@@ -65,6 +65,7 @@ export type WorkflowsPlatform = {
timestamp: string,
app: string,
signal: AbortSignal,
+ frameId?: number,
) => Promise<import("./model").WorkflowScreenshot | null>;
openCapturedMoment?: (frameId: number, timestamp: string) => Promise<void>;
assistant?: WorkflowsAssistantPlatform;
diff --git a/packages/workflows-ui/src/screenshots.ts b/packages/workflows-ui/src/screenshots.ts
index e7c769a00..21a443e1c 100644
--- a/packages/workflows-ui/src/screenshots.ts
+++ b/packages/workflows-ui/src/screenshots.ts
@@ -10,5 +10,13 @@ export function stageScreenshots(stage: WorkflowStage): WorkflowScreenshot[] {
&& !seen.has(image.frameId) && !!seen.add(image.frameId));
}
export function verifiedStageScreenshots(stage: WorkflowStage): WorkflowScreenshot[] {
- return stageScreenshots(stage).filter(image => image.visualVerified && !!image.dataUrl);
+ return stageScreenshots(stage).filter(image => image.visualVerified);
+}
+
+/** Keep recorder identities in saved state; pixel copies belong only in explicit exports. */
+export function serializeWorkflowData(value: unknown): string {
+ return JSON.stringify(value, function (key, child) {
+ return key === "dataUrl" && Number.isSafeInteger(this?.frameId)
+ && this.frameId > 0 && typeof this.timestamp === "string" ? "" : child;
+ });
}
diff --git a/packages/workflows-ui/src/sop-screenshot.tsx b/packages/workflows-ui/src/sop-screenshot.tsx
index 8a954a9f9..57f49c6cc 100644
--- a/packages/workflows-ui/src/sop-screenshot.tsx
+++ b/packages/workflows-ui/src/sop-screenshot.tsx
@@ -3,9 +3,11 @@
"use client";
import { useEffect, useRef, useState } from "react";
import type { WorkflowsPlatform } from "./platform";
+import { useSourceScreenshot } from "./use-source-screenshot";
+import type { WorkflowScreenshot } from "./model";
import styles from "./workflow-guide.module.css";
-export function SopScreenshot({ src, frameId, load, alt, onLoad, onError }: {
+function LegacySopScreenshot({ src, frameId, load, alt, onLoad, onError }: {
src: string; frameId: number; alt: string; draggable?: boolean;
load?: NonNullable<WorkflowsPlatform["guides"]>["loadScreenshot"];
onLoad?: () => void; onError?: () => void;
@@ -42,3 +44,13 @@ export function SopScreenshot({ src, frameId, load, alt, onLoad, onError }: {
</div>;
}
+
+export function SopScreenshot(props: Parameters<typeof LegacySopScreenshot>[0] & { source?: WorkflowScreenshot; loadSource?: WorkflowsPlatform["loadWorkflowScreenshot"] }) {
+ return props.source && props.loadSource ? <ExactSopScreenshot {...props} source={props.source} /> : <LegacySopScreenshot {...props} />;
+}
+function ExactSopScreenshot({ source, loadSource, alt, onLoad, onError }: Parameters<typeof SopScreenshot>[0] & { source: WorkflowScreenshot }) {
+ const image = useSourceScreenshot({ evidence: [] }, false, loadSource, source);
+ return <figure ref={image.ref}>
+ {image.image ? <img src={image.image.dataUrl} alt={alt} draggable={false} onLoad={onLoad} onError={onError} /> : <p className={styles.muted} role="status">{image.status === "loading" ? "Loading source screenshot…" : "This screenshot is no longer available."}{image.canRetry && image.status !== "loading" && <button onClick={image.retry}>Retry screenshot</button>}</p>}
+ </figure>;
+}
diff --git a/packages/workflows-ui/src/use-source-screenshot.ts b/packages/workflows-ui/src/use-source-screenshot.ts
index 084378bcc..a192bd4a8 100644
--- a/packages/workflows-ui/src/use-source-screenshot.ts
+++ b/packages/workflows-ui/src/use-source-screenshot.ts
@@ -5,23 +5,23 @@ import { useEffect, useRef, useState } from "react";
import type { WorkflowEvidence, WorkflowScreenshot } from "./model";
import type { WorkflowsPlatform } from "./platform";
-export function useSourceScreenshot(stage: { evidence: Array<Pick<WorkflowEvidence, "timestamp" | "app" | "source">> }, attached: boolean, load: WorkflowsPlatform["loadWorkflowScreenshot"]) {
+export function useSourceScreenshot(stage: { evidence: Array<Pick<WorkflowEvidence, "timestamp" | "app" | "source">> }, attached: boolean, load: WorkflowsPlatform["loadWorkflowScreenshot"], capture?: WorkflowScreenshot) {
const ref = useRef<HTMLElement>(null);
const [visible, setVisible] = useState(false);
const [attempt, setAttempt] = useState(0);
- const sources = JSON.stringify(stage.evidence.filter(e => !["audio", "meeting"].includes(e.source ?? "")
- && e.app && Number.isFinite(Date.parse(e.timestamp))).map(e => [e.timestamp, e.app]));
+ const sources = capture ? JSON.stringify([[capture.timestamp, capture.app, capture.frameId]]) : JSON.stringify([...new Set(stage.evidence.filter(e => !["audio", "meeting"].includes(e.source ?? "")
+ && e.app && Number.isFinite(Date.parse(e.timestamp))).map(e => JSON.stringify([e.timestamp, e.app])))].map(source => JSON.parse(source)));
const key = `${sources}:${attempt}`;
const [state, setState] = useState<{ key: string; image?: WorkflowScreenshot; status: "loading" | "unavailable" | "error" | "ready" }>();
useEffect(() => {
- if (!ref.current || visible) return;
+ if (!ref.current) return;
if (typeof IntersectionObserver === "undefined") { setVisible(true); return; }
const observer = new IntersectionObserver(entries => {
- if (entries.some(entry => entry.isIntersecting)) { setVisible(true); observer.disconnect(); }
+ setVisible(entries.some(entry => entry.isIntersecting));
}, { rootMargin: "200px" });
observer.observe(ref.current);
return () => observer.disconnect();
- }, [visible]);
+ }, []);
useEffect(() => {
if (attached || !load || !visible || sources === "[]") return;
const controller = new AbortController();
@@ -31,10 +31,10 @@ export function useSourceScreenshot(stage: { evidence: Array<Pick<WorkflowEviden
setState({ key, status: "loading" });
void (async () => {
let failed = false;
- for (const [timestamp, app] of JSON.parse(sources) as [string, string][]) {
+ for (const [timestamp, app, frameId] of JSON.parse(sources) as [string, string, number?][]) {
if (controller.signal.aborted) break;
try {
- image = await load(timestamp, app, controller.signal);
+ image = frameId === undefined ? await load(timestamp, app, controller.signal) : await load(timestamp, app, controller.signal, frameId);
if (disposed) { if (image?.dataUrl.startsWith("blob:")) URL.revokeObjectURL(image.dataUrl); return; }
if (image) { setState({ key, image, status: "ready" }); return; }
} catch { failed = true; }
@@ -42,11 +42,11 @@ export function useSourceScreenshot(stage: { evidence: Array<Pick<WorkflowEviden
if (!disposed) setState({ key, status: failed || controller.signal.aborted ? "error" : "unavailable" });
})().finally(() => clearTimeout(timeout));
return () => {
- disposed = true; controller.abort(); clearTimeout(timeout);
+ disposed = true; controller.abort(); clearTimeout(timeout); setState(undefined);
if (image?.dataUrl.startsWith("blob:")) URL.revokeObjectURL(image.dataUrl);
};
}, [sources, key, attached, load, visible]);
- return { ref, image: !attached && state?.key === key ? state.image : undefined,
+ return { ref, image: visible && !attached && state?.key === key ? state.image : undefined,
status: !load || sources === "[]" ? "unavailable" : state?.key === key ? state.status : "loading",
canRetry: !!load && sources !== "[]",
retry: () => setAttempt(value => value + 1) };
diff --git a/packages/workflows-ui/src/workflow-guide.tsx b/packages/workflows-ui/src/workflow-guide.tsx
index 1a77f76a6..83615be0c 100644
--- a/packages/workflows-ui/src/workflow-guide.tsx
+++ b/packages/workflows-ui/src/workflow-guide.tsx
@@ -1,6 +1,7 @@
// screenpipe — AI that knows everything you've seen, said, or heard
// https://screenpipe.com
"use client";
+import { exportGuideHtml } from "./guide-images";
import { SourceSopScreenshot } from "./source-sop-screenshot";
import { useEffect, useRef, useState, type MouseEvent } from "react";
import {
@@ -22,14 +23,11 @@ import type { WorkflowMap } from "./model";
import type { WorkflowsPlatform } from "./platform";
import {
guideWithBlockIds,
- guideHtml,
- guideImage,
guideScreenshot,
guideStepIncludesImage,
guideSourceStage,
guideNeedsSourceReview,
guideSourceImages,
- isGuideImage,
type WorkflowGuide as Guide,
} from "./guide";
import { WorkflowRichText } from "./rich-text";
@@ -49,12 +47,14 @@ export function WorkflowGuide({
close,
backLabel = "Back to workflow",
sourceMissing = false,
+ loadScreenshot,
}: {
workflow: WorkflowMap;
platform: NonNullable<WorkflowsPlatform["guides"]>;
close: () => void;
backLabel?: string;
sourceMissing?: boolean;
+ loadScreenshot?: WorkflowsPlatform["loadWorkflowScreenshot"];
}) {
const ui = useGT();
const [promptRequest, setPromptRequest] = useState<{
@@ -446,10 +446,10 @@ export function WorkflowGuide({
const sourceStage = guideSourceStage(draft, step, workflow) ?? null;
const image =
!stale && guideStepIncludesImage(step)
- ? guideImage(workflow, sourceStage, step.imageReview)
+ ? guideScreenshot(workflow, sourceStage, step.imageReview)
: null;
const sources = !stale
- ? guideSourceImages(workflow, sourceStage).filter(source => isGuideImage(source.dataUrl))
+ ? guideSourceImages(workflow, sourceStage)
: [];
const id = `step/${step.blockId ?? `step-${i}`}`;
return [
@@ -544,7 +544,9 @@ export function WorkflowGuide({
<SopScreenshot
load={platform.loadScreenshot}
frameId={guideScreenshot(workflow, sourceStage, step.imageReview)!.frameId}
- src={image}
+ src={image.dataUrl}
+ source={image}
+ loadSource={loadScreenshot ?? platform.loadSourceScreenshot}
alt={ui("Source for {value1}", {
value1: step.title,
})}
@@ -573,6 +575,7 @@ export function WorkflowGuide({
replacing={!!image}
title={step.title}
load={platform.loadScreenshot}
+ loadSource={loadScreenshot ?? platform.loadSourceScreenshot}
include={(source) => {
update({
...draft,
@@ -697,7 +700,7 @@ export function WorkflowGuide({
try {
if (
await platform.export(
- guideHtml(draft, workflow, images),
+ await exportGuideHtml(draft, workflow, images, loadScreenshot ?? platform.loadSourceScreenshot),
draft.title,
)
)
@@ -726,8 +729,10 @@ function ScreenshotReview({
title,
include,
load,
+ loadSource,
}: {
load?: NonNullable<WorkflowsPlatform["guides"]>["loadScreenshot"];
+ loadSource?: WorkflowsPlatform["loadWorkflowScreenshot"];
sources: ReturnType<typeof guideSourceImages>;
selected?: Guide["steps"][number]["imageReview"];
replacing: boolean;
@@ -766,6 +771,8 @@ function ScreenshotReview({
frameId={source.frameId}
key={`${source.frameId}:${source.timestamp}`}
src={source.dataUrl}
+ source={source}
+ loadSource={loadSource}
alt={ui("Review source for {value1}", { value1: title })}
draggable={false}
onLoad={() => {
diff --git a/packages/workflows-ui/src/workflow-replay.tsx b/packages/workflows-ui/src/workflow-replay.tsx
index 71c2852ce..3c5b712d9 100644
--- a/packages/workflows-ui/src/workflow-replay.tsx
+++ b/packages/workflows-ui/src/workflow-replay.tsx
@@ -101,8 +101,8 @@ export function WorkflowReplay({ workflow, loadRecording, releaseRecording, open
return <section className={`${styles.replay} ph-no-capture ph-mask`} aria-label={ui("Workflow recording replay")}>
<div className={styles.replayMedia}>
{loading ? <p role="status">Loading local recording…</p> : media?.kind === "video" ? <RecordingVideo
- key={media.url} media={media} poster={matchingImage?.dataUrl} failed={videoFailed} />
- : media?.kind === "image" || matchingImage ? <img src={media?.url ?? matchingImage?.dataUrl} alt={ui("Captured moment for {value1}", { value1: moment.stage.name })} />
+ key={media.url} media={media} poster={matchingImage?.dataUrl || undefined} failed={videoFailed} />
+ : media?.kind === "image" || matchingImage?.dataUrl ? <img src={media?.url ?? matchingImage?.dataUrl} alt={ui("Captured moment for {value1}", { value1: moment.stage.name })} />
: <p>{loadRecording ? ui("No playable recording for this moment.") : ui("Open the desktop app to play this recording.")}</p>}
</div>
{error && <p role="alert">{error} <button type="button" onClick={() => setRetry((value) => value + 1)}>Retry</button></p>}
diff --git a/packages/workflows-ui/src/workflow-step-evidence.tsx b/packages/workflows-ui/src/workflow-step-evidence.tsx
index 2771ae0ed..9bb237712 100644
--- a/packages/workflows-ui/src/workflow-step-evidence.tsx
+++ b/packages/workflows-ui/src/workflow-step-evidence.tsx
@@ -18,6 +18,7 @@ export function WorkflowStepEvidence({ workflow, stage, platform }: {
workflow: WorkflowMap; stage: WorkflowStage; platform: WorkflowsPlatform;
}) {
const [reduced, setReduced] = useState<Set<number>>(() => new Set());
+ const [previewHeight, setPreviewHeight] = useState(0);
const [selected, setSelected] = useState<WorkflowScreenshot | null>(null);
const [playing, setPlaying] = useState(false);
const playerRef = useRef<HTMLDivElement>(null);
@@ -53,7 +54,7 @@ export function WorkflowStepEvidence({ workflow, stage, platform }: {
else if (media?.url && platform.releaseWorkflowRecording) void platform.releaseWorkflowRecording(media.url).catch(() => {});
}
};
- return <section ref={preview.ref} className={`${styles.evidence} ph-no-capture ph-mask`} aria-label={`References for ${stage.name}`}>
+ return <section ref={preview.ref} onLoad={() => setPreviewHeight(preview.ref.current?.getBoundingClientRect().height ?? 0)} style={!attached.length && !screenshots.length && previewHeight ? { minHeight: previewHeight } : undefined} className={`${styles.evidence} ph-no-capture ph-mask`} aria-label={`References for ${stage.name}`}>
{!playing && !screenshots.length && <div className={styles.previewStatus} role="status">
{preview.status === "loading" ? "Loading source screenshot…" : preview.status === "error" ? "Could not load the source screenshot." : "No screenshot available for this step."}
{preview.canRetry && preview.status !== "loading" && <button type="button" onClick={preview.retry}>Retry screenshot</button>}
@@ -61,17 +62,10 @@ export function WorkflowStepEvidence({ workflow, stage, platform }: {
{!playing && screenshots.map((capture, index) => {
const expanded = !reduced.has(capture.frameId);
const suffix = screenshots.length > 1 ? ` ${index + 1}` : "";
- return <figure key={capture.frameId} className={`${styles.figure} ${expanded ? styles.expanded : ""}`}>
- <button className={styles.imageButton} type="button" aria-label={`${expanded ? "Reduce" : "Enlarge"} screenshot${suffix} for ${stage.name}`} aria-expanded={expanded} onClick={() => setReduced(previous => {
- const next = new Set(previous); if (expanded) next.add(capture.frameId); else next.delete(capture.frameId); return next;
- })}>
- <img src={capture.dataUrl} alt={`Captured reference${suffix} for ${stage.name}`} loading="lazy" draggable={false} data-lm-disable="true" />
- <span className={styles.zoom}>{expanded ? <Minimize2 size={15} /> : <Maximize2 size={15} />}</span>
- </button>
- <figcaption><span>{!capture.visualVerified ? "Source screenshot · " : ""}{capture.app} · {when(capture.timestamp)}</span>
- {(canReplay || platform.openCapturedMoment) && <button className={styles.recording} title="Open recording" type="button" disabled={opening} onClick={() => void openRecording(capture)} aria-label={`${platform.openCapturedMoment ? "Open" : "View"} recording${suffix} for ${stage.name}`}>{opening ? <Loader2 size={15} aria-hidden="true" /> : <Play size={15} aria-hidden="true" />}</button>}
- </figcaption>
- </figure>;
+ return <EvidenceFigure key={`${capture.frameId}:${capture.timestamp}`} capture={capture} stage={stage} platform={platform} suffix={suffix} expanded={expanded} opening={opening}
+ toggle={() => setReduced(previous => { const next = new Set(previous); if (expanded) next.add(capture.frameId); else next.delete(capture.frameId); return next; })}
+ replay={canReplay || !!platform.openCapturedMoment ? () => void openRecording(capture) : undefined}
+ resolved={capture === preview.image} />;
})}
{playing && <div ref={playerRef} className={styles.player}>
<button type="button" className={styles.close} aria-label={`Close recording for ${stage.name}`} title="Close recording" onClick={() => setPlaying(false)}><X size={15} /></button>
@@ -83,3 +77,28 @@ export function WorkflowStepEvidence({ workflow, stage, platform }: {
</div>
</section>;
}
+
+function EvidenceFigure({ capture, stage, platform, suffix, expanded, opening, toggle, replay, resolved }: {
+ capture: WorkflowScreenshot; stage: WorkflowStage; platform: WorkflowsPlatform; suffix: string;
+ expanded: boolean; opening: boolean; toggle: () => void; replay?: () => void; resolved: boolean;
+}) {
+ const load = resolved ? undefined : platform.loadWorkflowScreenshot;
+ const preview = useSourceScreenshot(stage, !load, load, capture);
+ // Desktop images always resolve through the recorder, including legacy embedded images.
+ const url = load ? preview.image?.dataUrl : capture.dataUrl;
+ const [failed, setFailed] = useState(false);
+ const [ratio, setRatio] = useState("16 / 10");
+ useEffect(() => setFailed(false), [url]);
+ return <figure ref={preview.ref} className={`${styles.figure} ${expanded ? styles.expanded : ""}`}>
+ {url && !failed ? <button className={styles.imageButton} type="button" aria-label={`${expanded ? "Reduce" : "Enlarge"} screenshot${suffix} for ${stage.name}`} aria-expanded={expanded} onClick={toggle}>
+ <img src={url} alt={`Captured reference${suffix} for ${stage.name}`} loading="lazy" decoding="async" draggable={false} data-lm-disable="true" onLoad={event => { const image = event.currentTarget; if (image.naturalWidth && image.naturalHeight) setRatio(`${image.naturalWidth} / ${image.naturalHeight}`); }} onError={() => setFailed(true)} />
+ <span className={styles.zoom}>{expanded ? <Minimize2 size={15} /> : <Maximize2 size={15} />}</span>
+ </button> : <div className={styles.previewStatus} role="status" style={preview.status === "loading" && !failed ? { aspectRatio: ratio } : undefined}>
+ {failed || preview.status === "error" ? "Could not load the source screenshot." : preview.status === "loading" ? "Loading source screenshot…" : "This screenshot is no longer available."}
+ {(failed || preview.status === "error") && load && <button onClick={() => { setFailed(false); preview.retry(); }}>Retry screenshot</button>}
+ </div>}
+ <figcaption><span>{!capture.visualVerified ? "Source screenshot · " : ""}{capture.app} · {when(capture.timestamp)}</span>
+ {replay && <button className={styles.recording} title="Open recording" type="button" disabled={opening} onClick={replay} aria-label={`${platform.openCapturedMoment ? "Open" : "View"} recording${suffix} for ${stage.name}`}>{opening ? <Loader2 size={15} aria-hidden="true" /> : <Play size={15} aria-hidden="true" />}</button>}
+ </figcaption>
+ </figure>;
+}
diff --git a/packages/workflows-ui/src/workflows-app.module.css b/packages/workflows-ui/src/workflows-app.module.css
index a2b380b4a..aeeea325e 100644
--- a/packages/workflows-ui/src/workflows-app.module.css
+++ b/packages/workflows-ui/src/workflows-app.module.css
@@ -268,12 +268,7 @@
.pill_green { border-color: var(--line); background: var(--soft); color: var(--signal); }
.pill_warm { border-color: #ead592; background: var(--warm); color: #775b09; }
.liveDot { width: 5px; height: 5px; border-radius: 50%; background: currentColor; }
-
-.hero { display: grid; grid-template-columns: minmax(0,1fr) 285px; gap: 76px; align-items: end; padding: 22px 0 46px; }
-.hero h1 { margin: 20px 0 16px; font-size: clamp(38px, 4.4vw, 59px); font-weight: 680; line-height: .99; letter-spacing: -.058em; }
-.hero h1 em { color: #777a72; font-style: normal; font-weight: 520; }
-.hero > div > p { max-width: 680px; margin: 0; color: #656960; font-size: 14px; line-height: 1.65; }
-.analyzeButton, .primaryButton {
+.primaryButton {
min-height: 38px;
display: inline-flex;
align-items: center;
@@ -288,54 +283,23 @@
font-weight: 720;
cursor: pointer;
}
-
-.analyzeButton { margin-top: 22px; box-shadow: 0 8px 20px rgba(23,24,21,.12); }
-.analyzeButton:hover, .primaryButton:hover { background: #343630; }
-.analyzeButton:disabled, .primaryButton:disabled { cursor: default; opacity: .65; }
+.primaryButton:hover { background: #343630; }
+.primaryButton:disabled { cursor: default; opacity: .65; }
.spinner, .spinnerSmall { display: inline-block; border-radius: 50%; border: 2px solid #dfe2d6; border-top-color: #6d862e; animation: workflowSpin .8s linear infinite; }
.spinner { width: 26px; height: 26px; }
.spinnerSmall { width: 13px; height: 13px; border-color: rgba(255,255,255,.3); border-top-color: var(--lime); }
@keyframes workflowSpin { to { transform: rotate(360deg); } }
-
-.heroProof { display: flex; flex-direction: column; padding: 21px; border: 1px solid var(--line); border-radius: 10px; background: #fff; box-shadow: 0 12px 30px rgba(40,42,32,.06); }
-.heroProof > span { color: var(--muted); font-size: 9px; font-weight: 700; letter-spacing: .11em; text-transform: none; }
-.heroProof > strong { margin-top: 13px; font-size: 35px; letter-spacing: -.05em; }
-.heroProof > small { margin-top: 2px; color: var(--muted); font-size: 9px; }
-.heroProof > div { height: 5px; margin: 20px 0 10px; overflow: hidden; border-radius: 4px; background: #eceee6; }
-.heroProof i { display: block; height: 100%; min-width: 4px; background: var(--signal); border-right: 2px solid var(--paper); }
-.heroProof p { margin: 0; color: #5e6158; font-size: 9px; line-height: 1.4; }
-
-.statGrid { display: grid; grid-template-columns: repeat(4,minmax(0,1fr)); margin-bottom: 48px; border: 1px solid var(--line); border-radius: 10px; background: #fff; }
-.statGrid > div { min-width: 0; padding: 19px 20px; border-right: 1px solid #e7e8e2; }
-.statGrid > div:last-child { border: 0; }
-.statGrid span, .detailStats span, .headerMetric span, .detailTotal span, .bottleneckTime span { display: block; color: #8c8f86; font-size: 8px; font-weight: 700; letter-spacing: .07em; text-transform: none; }
-.statGrid strong { display: block; margin: 7px 0 4px; font-size: 22px; letter-spacing: -.035em; }
-.statGrid small { display: block; overflow: hidden; color: #8d9087; font-size: 8px; line-height: 1.4; text-overflow: ellipsis; white-space: nowrap; }
+.detailStats span, .detailTotal span, .bottleneckTime span { display: block; color: #8c8f86; font-size: 8px; font-weight: 700; letter-spacing: .07em; text-transform: none; }
.sectionHeading { display: flex; align-items: flex-end; justify-content: space-between; gap: 16px; margin: 0 0 15px; }
.sectionHeading > div > span, .panelTitle > div > span { display: block; margin-bottom: 6px; color: #7b825d; font-size: 8px; font-weight: 750; letter-spacing: .12em; text-transform: none; }
.sectionHeading h2 { margin: 0; font-size: 17px; }
-.textButton, .backButton { display: inline-flex; align-items: center; gap: 6px; padding: 7px; border: 0; background: transparent; color: #60635b; font-size: 10px; font-weight: 650; cursor: pointer; }
-.textButton:hover, .backButton:hover { color: #111; }
+.backButton { display: inline-flex; align-items: center; gap: 6px; padding: 7px; border: 0; background: transparent; color: #60635b; font-size: 10px; font-weight: 650; cursor: pointer; }
+.backButton:hover { color: #111; }
.backButton { margin-bottom: 22px; padding-left: 0; }
-
-.timeMap { overflow: hidden; border: 1px solid var(--line); border-radius: 10px; background: #fff; }
-.timeMap > button { width: 100%; min-height: 83px; display: grid; grid-template-columns: minmax(250px,1fr) minmax(220px,.9fr) 270px 22px; gap: 20px; align-items: center; padding: 15px 18px; border: 0; border-bottom: 1px solid #e7e8e2; background: transparent; color: inherit; text-align: left; cursor: pointer; }
-.timeMap > button:last-child { border-bottom: 0; }
-.timeMap > button:hover { background: #fafbf6; }
-.timeMapTitle { display: grid; grid-template-columns: 30px 1fr; gap: 9px; align-items: start; }
-.timeMapTitle > span { color: #9a9d94; font-size: 9px; }
-.timeMapTitle div { display: flex; flex-direction: column; gap: 5px; }
-.timeMapTitle strong { font-size: 11px; }
-.timeMapTitle small { color: #898c83; font-size: 8px; }
-.timeBar, .bigTimeBar { height: 8px; display: flex; overflow: hidden; border-radius: 999px; background: #eceee7; }
-.timeBar i, .bigTimeBar i { height: 100%; background: #272923; }
-.timeBar b, .bigTimeBar b { height: 100%; background: var(--chart-secondary); }
-.timeLegend { display: grid; grid-template-columns: 1fr 1fr; gap: 7px 12px; color: #7d8077; font-size: 8px; }
-.timeLegend span { display: flex; align-items: center; gap: 5px; }
-.timeLegend span i { width: 6px; height: 6px; border-radius: 2px; background: #272923; }
-.timeLegend span:nth-child(2) i { background: var(--chart-secondary); border: 1px solid var(--muted); }
-.timeLegend strong { grid-column: 1 / -1; color: #363832; font-size: 9px; }
+.bigTimeBar { height: 8px; display: flex; overflow: hidden; border-radius: 999px; background: #eceee7; }
+.bigTimeBar i { height: 100%; background: #272923; }
+.bigTimeBar b { height: 100%; background: var(--chart-secondary); }
.emptyState { min-height: 290px; display: flex; flex-direction: column; align-items: center; justify-content: center; padding: 38px; border: 1px dashed #ccd0c4; border-radius: 11px; background: rgba(255,255,255,.56); color: #66705b; text-align: center; }
.emptyMark { width: 49px; height: 49px; display: grid; place-items: center; border-radius: 8px; background: var(--ink); color: var(--paper); }
@@ -349,39 +313,9 @@
.errorNotice > div { flex: 1; }
.errorNotice strong { font-size: 10px; }
.errorNotice p { margin: 4px 0 0; font-size: 9px; line-height: 1.45; }
-.errorNotice button, .runtimeNotice button { min-height: 31px; display: inline-flex; align-items: center; justify-content: center; gap: 6px; padding: 0 10px; border: 1px solid currentColor; border-radius: 6px; background: transparent; color: inherit; font-size: 8px; font-weight: 700; cursor: pointer; }
-.runtimeNotice { display: flex; align-items: center; justify-content: space-between; gap: 18px; margin: -20px 0 20px; padding: 14px 16px; border: 1px solid #ded6b8; border-radius: 8px; background: #fffbec; color: #675a31; }
-.runtimeNotice > div { display: flex; align-items: flex-start; gap: 10px; }
-.runtimeNotice > div > svg { flex: 0 0 auto; margin-top: 1px; }
-.runtimeNotice strong { font-size: 10px; }
-.runtimeNotice p { margin: 4px 0 0; color: #817653; font-size: 9px; line-height: 1.45; }
-.runtimeNotice button { flex: 0 0 auto; background: #fff; }
-.runtimeNotice button:disabled { opacity: .55; cursor: default; }
-.profilePrompt, .timeValueNotice { display: grid; grid-template-columns: 26px minmax(0,1fr) auto; gap: 12px; align-items: center; margin: -20px 0 20px; padding: 14px 16px; border: 1px solid #d9ddd0; border-radius: 8px; background: #f7f8f3; color: #555c48; }
-.profilePrompt > svg, .timeValueNotice > svg { color: #68734f; }
-.profilePrompt strong, .timeValueNotice strong { color: #30342c; font-size: 10px; }
-.profilePrompt p, .timeValueNotice p { margin: 4px 0 0; color: #777c71; font-size: 9px; line-height: 1.45; }
-.profilePrompt button { display: inline-flex; align-items: center; gap: 6px; padding: 7px 9px; border: 1px solid #cbd0c1; border-radius: 6px; background: #fff; color: #34382f; font-size: 8px; font-weight: 700; cursor: pointer; }
-
-.qualityPanel { margin: -19px 0 20px; overflow: hidden; border: 1px solid #dce4c9; border-radius: 10px; background: #fbfdf5; }
-.qualityPanel summary { min-height: 64px; display: flex; align-items: center; justify-content: space-between; gap: 20px; padding: 13px 16px; cursor: pointer; list-style: none; }
-.qualityPanel summary::-webkit-details-marker, .workflowQuality summary::-webkit-details-marker { display: none; }
-.qualityLead { display: flex; align-items: center; gap: 11px; }
-.qualityLead > svg { color: #708b2d; }
-.qualityLead > div { display: flex; flex-direction: column; gap: 4px; }
-.qualityLead strong { font-size: 10px; }
-.qualityLead span, .qualityMetrics span { color: #777d6b; font-size: 8px; }
-.qualityMetrics { display: flex; align-items: center; gap: 15px; }
-.qualityPanel[open] .qualityMetrics svg, .workflowQuality[open] summary > svg { transform: rotate(180deg); }
-.qualityDetails { display: grid; grid-template-columns: repeat(3,minmax(0,1fr)); border-top: 1px solid #dfe7cf; background: #fff; }
-.qualityDetails > div { padding: 15px 16px; border-right: 1px solid #e7ebdf; }
-.qualityDetails > div:nth-child(3n) { border-right: 0; }
-.qualityDetails > div:nth-child(-n+3) { border-bottom: 1px solid #e7ebdf; }
-.qualityDetails span { display: block; color: #8a8f80; font-size: 7px; font-weight: 720; letter-spacing: .08em; text-transform: none; }
-.qualityDetails strong { display: block; margin-top: 6px; font-size: 11px; }
-.qualityDetails p, .qualityDetails li { color: #7e8278; font-size: 8px; line-height: 1.45; }
-.qualityDetails p { margin: 5px 0 0; }
-.qualityDetails ul { margin: 6px 0 0; padding-left: 14px; }
+.errorNotice button { min-height: 31px; display: inline-flex; align-items: center; justify-content: center; gap: 6px; padding: 0 10px; border: 1px solid currentColor; border-radius: 6px; background: transparent; color: inherit; font-size: 8px; font-weight: 700; cursor: pointer; }
+.workflowQuality summary::-webkit-details-marker { display: none; }
+.workflowQuality[open] summary > svg { transform: rotate(180deg); }
.depthNotice { margin: 0 0 18px; padding: 14px 18px; border: 1px solid var(--line); border-radius: 8px; background: var(--canvas, #f6f6f3); font-size: 12px; line-height: 1.6; }
.depthNotice p { margin: 6px 0 0; color: #6e7269; }
@@ -399,44 +333,6 @@
.pageHeader { display: flex; align-items: flex-end; justify-content: space-between; gap: 30px; margin: 25px 0 42px; }
.pageHeader h1 { margin: 0; font-size: clamp(34px,3.8vw,50px); letter-spacing: -.052em; }
.pageHeader p { max-width: 700px; margin: 9px 0 0; color: #6e7269; font-size: 12px; line-height: 1.6; }
-.headerMetric { flex: 0 0 auto; min-width: 185px; padding: 16px; border: 1px solid var(--line); border-radius: 9px; background: #fff; }
-.headerMetric strong { display: block; margin-top: 7px; font-size: 24px; }
-
-.timeSummary { display: grid; grid-template-columns: repeat(4,minmax(0,1fr)); margin: -21px 0 34px; overflow: hidden; border: 1px solid var(--line); border-radius: 10px; background: #fff; }
-.timeSummary > div { min-width: 0; padding: 18px 19px; border-right: 1px solid #e7e8e2; }
-.timeSummary > div:last-child { border-right: 0; }
-.timeSummary span { display: block; color: #898d83; font-size: 8px; font-weight: 720; letter-spacing: .07em; text-transform: none; }
-.timeSummary strong { display: block; margin: 7px 0 4px; font-size: 21px; letter-spacing: -.035em; }
-.timeValueNotice { grid-template-columns: 26px minmax(0,1fr); margin: -21px 0 34px; }
-.timeLensTabs { display: grid; grid-template-columns: repeat(2,minmax(0,1fr)); gap: 7px; margin-bottom: 13px; }
-.timeLensTabs button { min-height: 43px; display: flex; align-items: center; gap: 8px; padding: 0 12px; border: 1px solid var(--line); border-radius: 8px; background: #fff; color: #6d7167; font-size: 9px; font-weight: 670; cursor: pointer; }
-.timeLensTabs button:hover { background: #f4f5ef; color: var(--ink); }
-.timeLensTabs button > strong { margin-left: auto; min-width: 21px; height: 21px; display: grid; place-items: center; border-radius: 999px; background: #eff0eb; color: #777b70; font-size: 8px; }
-.timeLensTabs .timeLensActive { border-color: var(--ink); background: var(--ink); color: #fff; box-shadow: 0 5px 14px rgba(0,0,0,.08); }
-.timeLensTabs .timeLensActive > strong { background: var(--paper); color: var(--ink); }
-.timeLensTools { display: grid; grid-template-columns: minmax(180px,260px) minmax(0,1fr); align-items: center; gap: 14px; margin-bottom: 10px; padding: 10px 12px; border: 1px solid var(--line); border-radius: 8px; background: rgba(255,255,255,.68); }
-.timeLensTools label { min-height: 32px; display: flex; align-items: center; gap: 8px; padding: 0 10px; border: 1px solid #dfe1da; border-radius: 7px; background: #fff; color: #8a8e84; }
-.timeLensTools input { width: 100%; border: 0; outline: 0; background: transparent; color: var(--ink); font: inherit; font-size: 9px; }
-.timeLensTools > strong { justify-self: end; color: #666b61; font-size: 9px; white-space: nowrap; }
-.timeAllocationList { overflow: hidden; border: 1px solid var(--line); border-radius: 10px; background: #fff; }
-.timeAllocationItem { display: grid; grid-template-columns: 35px minmax(0,1fr); gap: 13px; padding: 20px 20px 16px; border-bottom: 1px solid #e6e8e0; }
-.timeAllocationItem:last-child { border-bottom: 0; }
-.timeAllocationRank { color: #999d92; font-size: 9px; }
-.timeAllocationBody { min-width: 0; }
-.timeAllocationHead { display: grid; grid-template-columns: minmax(0,1fr) 145px; gap: 25px; align-items: start; }
-.timeAllocationHead h2 { margin: 0 0 5px; font-size: 13px; }
-.timeAllocationHead p { max-width: 730px; margin: 0; color: #73786d; font-size: 9px; line-height: 1.5; }
-.timeAllocationHead > div:last-child { padding-left: 18px; border-left: 1px solid #e5e7df; text-align: right; }
-.timeAllocationHead strong { display: block; font-size: 19px; }
-.timeAllocationHead span { display: block; margin-top: 4px; color: #888c82; font-size: 8px; }
-.timeAllocationBar { height: 7px; margin: 14px 0 10px; overflow: hidden; border-radius: 999px; background: #eceee7; }
-.timeAllocationBar i { display: block; height: 100%; border-right: 2px solid var(--paper); background: var(--signal); }
-.timeShowMore { width: 100%; min-height: 42px; display: flex; align-items: center; justify-content: center; gap: 8px; margin-top: 9px; border: 1px solid var(--line); border-radius: 8px; background: #fff; color: #575d50; font-size: 9px; font-weight: 690; cursor: pointer; }
-.timeShowMore:hover { background: #f5f7f0; }
-.timeShowMore span { color: #92968c; font-weight: 560; }
-.timeLensEmpty { min-height: 230px; display: flex; flex-direction: column; align-items: center; justify-content: center; padding: 35px; border: 1px dashed #ccd0c4; border-radius: 10px; background: rgba(255,255,255,.6); color: #707b60; text-align: center; }
-.timeLensEmpty h2 { margin: 13px 0 6px; color: #363a32; font-size: 15px; }
-.timeLensEmpty p { max-width: 550px; margin: 0; color: #7b8076; font-size: 9px; line-height: 1.55; }
.workflowGrid { display: grid; align-items: start; grid-template-columns: repeat(2,minmax(0,1fr)); gap: 13px; }
.filterBar { min-height: 53px; display: flex; align-items: center; gap: 10px; margin: -22px 0 13px; padding: 9px 10px 9px 15px; border: 1px solid var(--line); border-radius: 9px; background: #fff; }
@@ -539,13 +435,6 @@
.stageChevron { color: #8a8e84; transition: transform .15s ease; }
.stageOpen .stageChevron { transform: rotate(180deg); }
.stageDisclosure { display: grid; grid-template-columns: minmax(260px,.95fr) minmax(0,1.05fr); gap: 0; border-top: 1px solid #e2e4dc; background: #fafbf7; }
-.stageScreenshot { min-width: 0; padding: 14px; border-right: 1px solid #e2e4dc; }
-.screenshotFrame { aspect-ratio: 16 / 9; overflow: hidden; border: 1px solid #d8dad3; border-radius: 6px; background: #e8eae3; }
-.screenshotFrame img { width: 100%; height: 100%; display: block; object-fit: cover; }
-.stageScreenshot > div:last-child:not(.screenshotUnavailable) { display: grid; grid-template-columns: 14px minmax(0,1fr) auto; gap: 6px; align-items: center; padding-top: 9px; color: #83877d; font-size: 7.5px; }
-.stageScreenshot a { display: inline-flex; align-items: center; gap: 4px; color: #50564a; font-weight: 680; text-decoration: none; }
-.stageScreenshot button { display: inline-flex; align-items: center; padding: 4px 6px; border: 1px solid #c9cdc2; border-radius: 4px; background: transparent; color: #50564a; font: inherit; font-weight: 680; cursor: pointer; }
-.stageScreenshot button:disabled { opacity: .5; cursor: wait; }
.screenshotUnavailable { min-height: 145px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 6px; padding: 20px; border: 1px dashed #d2d5cc; border-radius: 6px; color: #8a8e84; text-align: center; }
.screenshotUnavailable strong { color: #666b60; font-size: 9px; }
.screenshotUnavailable span { max-width: 290px; font-size: 8px; line-height: 1.45; }
@@ -681,28 +570,6 @@
.iconLink { width: 28px; height: 28px; display: grid; place-items: center; border: 1px solid var(--line); border-radius: 7px; background: #fff; color: #565a51; cursor: pointer; }
.iconLink:hover { background: #f2f3ed; }
-.evidenceList { overflow: hidden; border: 1px solid var(--line); border-radius: 10px; background: #fff; }
-.evidenceList > button { width: 100%; min-height: 92px; display: grid; grid-template-columns: 45px minmax(0,1fr) 22px; gap: 14px; align-items: center; padding: 15px 19px; border: 0; border-bottom: 1px solid #e7e8e2; background: transparent; color: inherit; text-align: left; cursor: pointer; }
-.evidenceList > button:last-child { border-bottom: 0; }
-.evidenceList > button:hover { background: #fafbf6; }
-.evidenceIndex { color: #999c93; font-size: 9px; }
-.evidenceList div { display: flex; flex-direction: column; }
-.evidenceList div > span { margin-bottom: 5px; color: #8a8e84; font-size: 8px; }
-.evidenceList strong { font-size: 10px; }
-.evidenceList p { margin: 5px 0 0; color: #71756c; font-size: 9px; line-height: 1.5; }
-
-.privacyGrid { display: grid; grid-template-columns: repeat(4,minmax(0,1fr)); gap: 13px; }
-.privacyGrid article { min-height: 235px; display: flex; flex-direction: column; align-items: flex-start; padding: 24px; border: 1px solid var(--line); border-radius: 10px; background: #fff; }
-.privacyGrid article > svg { color: #5f674b; }
-.privacyGrid h2 { margin: 24px 0 8px; font-size: 15px; }
-.privacyGrid p { margin: 0 0 20px; color: #73776e; font-size: 10px; line-height: 1.55; }
-.privacyGrid .pill { margin-top: auto; }
-.boundaryStatement { display: grid; grid-template-columns: 26px minmax(0,1fr) auto; gap: 12px; align-items: start; margin-bottom: 13px; padding: 17px 19px; border: 1px solid #cad5aa; border-radius: 9px; background: #f5f8eb; }
-.boundaryStatement > svg { margin-top: 1px; color: #5f7140; }
-.boundaryStatement strong { font-size: 11px; }
-.boundaryStatement p { margin: 4px 0 0; color: #6f7664; font-size: 9px; line-height: 1.5; }
-.boundaryStatement .pill { align-self: center; }
-
.profileSteps { display: grid; gap: 13px; }
.profileCard { padding: 24px; border: 1px solid var(--line); border-radius: 8px; background: #fff; }
.profileCardHead { display: grid; grid-template-columns: 30px minmax(0,1fr); gap: 12px; margin-bottom: 18px; }
@@ -745,22 +612,11 @@
@media (max-width: 1050px) {
.app { grid-template-columns: var(--navigation-width, 240px) minmax(0,1fr); }
- .hero { grid-template-columns: 1fr; gap: 26px; }
- .heroProof { max-width: 330px; }
- .timeMap > button { grid-template-columns: minmax(230px,1fr) minmax(180px,.9fr) 22px; }
- .timeLegend { display: none; }
- .qualityDetails { grid-template-columns: repeat(2,1fr); }
- .qualityDetails > div { border-right: 1px solid #e7ebdf; border-bottom: 1px solid #e7ebdf; }
- .qualityDetails > div:nth-child(2n) { border-right: 0; }
- .qualityDetails > div:nth-last-child(-n+2) { border-bottom: 0; }
.profileKpiDetails { grid-template-columns: 1fr 1fr; }
.profileKpiDetails label:first-child { grid-column: 1 / -1; }
}
@media (max-width: 820px) {
- .statGrid { grid-template-columns: repeat(2,1fr); }
- .statGrid > div:nth-child(2) { border-right: 0; }
- .statGrid > div:nth-child(-n+2) { border-bottom: 1px solid #e7e8e2; }
.workflowGrid, .detailColumns { grid-template-columns: 1fr; }
.detailHeader { grid-template-columns: 1fr; gap: 20px; }
.detailTotal { max-width: 260px; }
@@ -770,18 +626,8 @@
.detailStats > div:last-child { grid-column: 1 / -1; border-right: 0; border-bottom: 0; }
.bottleneckList article { grid-template-columns: 30px 1fr 115px; }
.bottleneckList .iconLink { display: none; }
- .privacyGrid { grid-template-columns: 1fr; }
- .privacyGrid article { min-height: 180px; }
- .boundaryStatement { grid-template-columns: 24px 1fr; }
- .boundaryStatement .pill { grid-column: 2; justify-self: start; }
.stageDisclosure { grid-template-columns: 1fr; }
- .stageScreenshot { border-right: 0; border-bottom: 1px solid #e2e4dc; }
.workflowQuality ul { grid-template-columns: 1fr; }
- .timeSummary { grid-template-columns: repeat(2,1fr); }
- .timeSummary > div:nth-child(2) { border-right: 0; }
- .timeSummary > div:nth-child(-n+2) { border-bottom: 1px solid #e7e8e2; }
- .timeLensTabs { grid-template-columns: repeat(2,1fr); }
- .timeLensTools { grid-template-columns: 1fr auto; }
.profileAdvancedGrid { grid-template-columns: 1fr; }
}
@@ -802,8 +648,6 @@
.scopeControl select { max-width: 105px; }
.main { padding: 28px 18px 55px; }
.pageHeader { align-items: flex-start; flex-direction: column; }
- .timeMap > button { grid-template-columns: 1fr 20px; }
- .timeMap .timeBar { grid-column: 1; }
.stageList { padding-left: 0; }
.stageList::before { display: none; }
.stageList article { grid-template-columns: 31px 1fr; }
@@ -814,22 +658,7 @@
.bottleneckTime { grid-column: 2; padding: 10px 0 0; border: 0; }
.filterBar { align-items: flex-start; flex-wrap: wrap; }
.filterBar > div { width: 100%; }
- .qualityPanel summary { align-items: flex-start; flex-direction: column; }
- .qualityMetrics { width: 100%; justify-content: space-between; }
- .qualityDetails { grid-template-columns: 1fr; }
- .qualityDetails > div { border-right: 0; border-bottom: 1px solid #e7ebdf; }
- .qualityDetails > div:last-child { border-bottom: 0; }
- .runtimeNotice { align-items: flex-start; flex-direction: column; }
- .profilePrompt { grid-template-columns: 24px minmax(0,1fr); }
- .profilePrompt button { grid-column: 2; justify-self: start; }
.profilePeriod { display: none; }
- .timeSummary { grid-template-columns: 1fr; }
- .timeSummary > div { border-right: 0; border-bottom: 1px solid #e7e8e2; }
- .timeSummary > div:last-child { border-bottom: 0; }
- .timeAllocationHead { grid-template-columns: 1fr; gap: 12px; }
- .timeLensTools { grid-template-columns: 1fr; }
- .timeLensTools > strong { justify-self: start; }
- .timeAllocationHead > div:last-child { padding: 0; border: 0; text-align: left; }
.profileCard { padding: 18px; }
.profileKpiRow, .profileKpiDetails { grid-template-columns: 1fr; }
.profileKpiRow > button { justify-self: end; }
@@ -945,7 +774,6 @@
.refreshControls { display: flex; align-items: center; gap: 12px; font-size: 12px; color: var(--muted); }
.workflowReviewState { margin: -12px 0 22px; color: var(--muted); font-size: 12px; }
.procedureDetails { padding: 16px 20px; }
-.stageScreenshot { grid-column: 1 / -1; border: 0; }
.procedureDetails blockquote { max-height: 160px; overflow-y: auto; }
@media (max-width: 640px) { .refreshControls { flex-wrap: wrap; justify-content: flex-end; } }
diff --git a/packages/workflows-ui/src/workflows-app.tsx b/packages/workflows-ui/src/workflows-app.tsx
index 534097f44..fd306094c 100644
--- a/packages/workflows-ui/src/workflows-app.tsx
+++ b/packages/workflows-ui/src/workflows-app.tsx
@@ -4,7 +4,7 @@
"use client";
import { isCatalogConnectionError, CATALOG_CONNECT_NOTICE_MS, catalogRetryDelay } from "./catalog-loading";
-import { verifiedStageScreenshots } from "./screenshots";
+import { serializeWorkflowData } from "./screenshots";
import { useNavigationWidth } from "./use-navigation-width";
import { WorkflowQuestions } from "./workflow-questions";
import { WorkflowStepEvidence } from "./workflow-step-evidence";
@@ -21,7 +21,6 @@ import { useWorkflowRunActivity, type WorkflowActivityState } from "./use-workfl
import { WorkflowRunProgress } from "./workflow-run-progress";
import { workflowTiming, formatTimingMinutes as formatMinutes } from "./timing";
import { TimingDisclosure } from "./timing-disclosure";
-import { CapturedMomentButton } from "./workflow-replay";
import type { AssistantContext, AssistantState } from "./assistant";
import {
@@ -33,23 +32,15 @@ import {
Building2,
BookOpen,
CalendarRange,
- Camera,
- ChartPie,
CheckCircle2,
ChevronDown,
ChevronRight,
Clock3,
Command as CommandIcon,
CornerDownLeft,
- Eye,
FileCheck2,
- FolderKanban,
- GitBranch,
Keyboard,
- LayoutDashboard,
ListTree,
- LogIn,
- LockKeyhole,
Plus,
PanelLeftClose,
PanelLeftOpen,
@@ -76,19 +67,15 @@ import {
filterWorkflows,
} from "./filters";
import {
- activityPeriodLabel,
mergeWorkflowCatalog,
sanitizeWorkflowAnalysis,
WORKFLOW_CATALOG_DAYS,
- type WorkflowActivityPeriod,
} from "./catalog";
import {
- controlExplanation,
controlLabel,
isActionableBottleneck,
} from "./controllability";
import {
- type AnalysisQuality,
type WorkProfile,
type WorkProfileKpi,
type WorkflowAnalysis,
@@ -99,8 +86,6 @@ import {
type WorkflowScope,
type WorkflowSkillDraft,
type WorkflowSkillProgress,
- type TimeAllocationItem,
- type TimeProfileDimension,
} from "./model";
import type { WorkflowAnalysisJob, WorkflowsAppProps, WorkflowsPlatform } from "./platform";
import { ContextComposer } from "./context-composer";
@@ -117,7 +102,6 @@ const primaryNavigation = [
["profile", UserRoundCog, "Context", ["G", "P"]],
] as const;
-type TimeLens = "categories" | "projects";
type PaletteCommand = {
id: string;
@@ -163,11 +147,6 @@ function formatCurrency(value: number, currency: string) {
}
}
-function profileCompletion(profile: WorkProfile | null) {
- if (!profile) return 0;
- return [profile.summary.trim(), profile.priorities.trim()].filter(Boolean).length;
-}
-
function handleWindowDrag(event: React.MouseEvent<HTMLElement>, startWindowDrag?: () => Promise<void> | void) {
if (event.button !== 0 || !startWindowDrag) return;
event.preventDefault();
@@ -181,12 +160,6 @@ function appViewFromLocation(): AppView {
return isPrimaryAppView(requested) ? requested : "workflows";
}
-function qualityLabel(grade: "strong" | "good" | "limited") {
- if (grade === "strong") return "Strong support";
- if (grade === "good") return "Good support";
- return "Limited support";
-}
-
function formatEvidenceTimestamp(value: string) {
const date = new Date(value);
if (!Number.isFinite(date.getTime())) return value;
@@ -209,56 +182,6 @@ function workflowDurationLabel(workflow: WorkflowMap) {
return hasMeasuredDuration(workflow) ? formatMinutes(workflow.totalMinutes) : "Not measured";
}
-function formatAnalyzedAt(value: string) {
- const date = new Date(value);
- if (!Number.isFinite(date.getTime())) return "Refresh time unavailable";
- return `Updated ${new Intl.DateTimeFormat(undefined, {
- month: "short",
- day: "numeric",
- hour: "numeric",
- minute: "2-digit",
- }).format(date)}`;
-}
-
-function screenshotMatchLabel(seconds: number) {
- const distance = Math.max(0, Math.round(seconds || 0));
- if (distance <= 10) return "same captured moment";
- if (distance < 60) return `${distance}s from observation`;
- return `${Math.round(distance / 60)}m from observation`;
-}
-
-function withoutScreenshotCopies(analysis: WorkflowAnalysis): WorkflowAnalysis {
- return {
- ...analysis,
- quality: {
- ...analysis.quality,
- grade: "limited",
- screenshotCount: 0,
- screenshotCoverage: 0,
- warnings: [
- ...analysis.quality.warnings.filter((warning) => !warning.toLowerCase().includes("screenshot")),
- "Local screenshots rematch when you refresh the work map",
- ],
- },
- analysis: {
- workflows: analysis.analysis.workflows.map((workflow) => ({
- ...workflow,
- quality: {
- ...workflow.quality,
- grade: workflow.quality.grade === "strong" ? "good" : workflow.quality.grade,
- screenshotCount: 0,
- stageScreenshotCoverage: 0,
- reasons: [
- ...workflow.quality.reasons.filter((reason) => !reason.toLowerCase().includes("screenshot")),
- "Local screenshots rematch when you refresh the work map",
- ],
- },
- stages: workflow.stages.map((stage) => ({ ...stage, screenshot: null, screenshots: [] })),
- })),
- },
- };
-}
-
function BrandMark() {
return <span className={styles.brandMark} aria-hidden="true"><span /><span /><span /></span>;
}
@@ -541,155 +464,6 @@ function ErrorNotice({ message, retry }: { message: string; retry: () => void })
return <div className={styles.errorNotice}><AlertTriangle size={16} /><div><strong>Couldn’t finish the work map</strong><p>{message}</p></div><button onClick={retry}><RefreshCw size={12} />Try again</button></div>;
}
-function RuntimeNotice({ runtime, refresh, openAccount }: { runtime: WorkflowRuntime | null; refresh: () => void; openAccount?: () => Promise<void> }) {
- const ui = useGT();
- const [openingAccount, setOpeningAccount] = useState(false);
- const [awaitingAccount, setAwaitingAccount] = useState(false);
- const [accountError, setAccountError] = useState("");
- useEffect(() => {
- if (!awaitingAccount) return;
- const timer = window.setInterval(refresh, 2000);
- return () => window.clearInterval(timer);
- }, [awaitingAccount, refresh]);
- if (!runtime || runtime.processingAvailable) return null;
- const needsAccount = runtime.recording && !runtime.cloudAuthAvailable;
- const act = async () => {
- if (!needsAccount || awaitingAccount || !openAccount) {
- refresh();
- return;
- }
- setOpeningAccount(true);
- setAccountError("");
- try {
- await openAccount();
- setAwaitingAccount(true);
- } catch (error) {
- setAccountError(error instanceof Error ? error.message : "Could not open account setup. Try again.");
- } finally {
- setOpeningAccount(false);
- }
- };
- return <section className={styles.runtimeNotice}>
- <div><LogIn size={17} /><div><strong>{awaitingAccount ? ui("Finish in your browser") : needsAccount ? ui("Connect your account to build maps") : ui("Work history is not ready yet")}</strong><p>{accountError || (awaitingAccount ? ui("Return here after signing in. This screen checks automatically.") : needsAccount ? ui("Your recordings stay on this Mac. An account enables processing only when you choose to build or refresh a map.") : ui("Finish the capture setup, then check again. Existing Screenpipe history is reused when available."))}</p></div></div>
- <button onClick={() => void act()} disabled={openingAccount}>{needsAccount && !awaitingAccount ? <LogIn size={12} /> : <RefreshCw size={12} />}{openingAccount ? ui("Opening…") : awaitingAccount ? ui("Check again") : needsAccount ? ui("Sign in or create account") : ui("Check again")}</button>
- </section>;
-}
-
-function AnalysisQualityPanel({ quality }: { quality: AnalysisQuality }) {
- return (
- <details className={styles.qualityPanel}>
- <summary>
- <div className={styles.qualityLead}>
- <CheckCircle2 size={17} />
- <div><strong>{qualityLabel(quality.grade)}</strong><span>{quality.usableDays} usable days · {quality.verifiedEvidenceCount} verified observations · {quality.screenshotCoverage}% screenshot coverage</span></div>
- </div>
- <div className={styles.qualityMetrics}><span>{quality.totalFrames.toLocaleString()} frames</span><span>{formatMinutes(quality.capturedMinutes)} reviewed</span><ChevronDown size={15} /></div>
- </summary>
- <div className={styles.qualityDetails}>
- <div><span>Coverage window</span><strong>{quality.usableDays} of {quality.requestedDays} days</strong><p>Only days with usable captured activity are included.</p></div>
- <div><span>App attribution</span><strong>{quality.appAttributionCoverage}%</strong><p>How often the capture could identify the app behind a frame.</p></div>
- <div><span>Structured context</span><strong>{quality.parsedContextCount.toLocaleString()}</strong><p>Screen observations with additional structure available to the map.</p></div>
- <div><span>Verified observations</span><strong>{quality.verifiedEvidenceCount.toLocaleString()}</strong><p>Map evidence matched back to an exact captured observation.</p></div>
- <div><span>Stage screenshots</span><strong>{quality.screenshotCount} · {quality.screenshotCoverage}%</strong><p>Screenshots linked to the exact captured moments.</p></div>
- <div><span>Quality notes</span>{quality.warnings.length ? <ul>{quality.warnings.map((warning) => <li key={warning}>{screenDataNote(warning)}</li>)}</ul> : <p>No material coverage warnings for this period.</p>}</div>
- </div>
- </details>
- );
-}
-
-function OverviewView({
- analysis,
- analyzing,
- error,
- analyze,
- openWorkflow,
- navigate,
- knownWorkflowCount,
- activityPeriod,
- runtime,
- workProfile,
- refreshRuntime,
- openAccount,
-}: {
- analysis: WorkflowAnalysis | null;
- analyzing: boolean;
- error: string;
- analyze: () => void;
- openWorkflow: (index: number) => void;
- navigate: (view: AppView) => void;
- knownWorkflowCount: number;
- activityPeriod: WorkflowActivityPeriod;
- runtime: WorkflowRuntime | null;
- workProfile: WorkProfile | null;
- refreshRuntime: () => void;
- openAccount?: () => Promise<void>;
-}) {
- const ui = useGT();
- const workflows = analysis?.analysis.workflows ?? [];
- const measuredWorkflowCount = workflows.filter(hasMeasuredDuration).length;
- const unmeasuredWorkflowCount = workflows.length - measuredWorkflowCount;
- const friction = workflows.flatMap((workflow) => workflow.bottlenecks);
- const actionableCount = friction.filter(isActionableBottleneck).length;
- const constraintCount = friction.length - actionableCount;
-
- return (
- <>
- <section className={styles.hero}>
- <div>
- <Pill><Workflow size={12} />{knownWorkflowCount ? ui("{value1} known workflows", { value1: knownWorkflowCount }) : ui("Ready to map your work")}</Pill>
- <h1>See how your work<br /><em>Actually flows.</em></h1>
- <p>Every step, handoff, wait, and bottleneck across your day.</p>
- <button className={styles.analyzeButton} onClick={analyze} disabled={analyzing || runtime?.processingAvailable === false}>{analyzing ? <><span className={styles.spinnerSmall} />Refreshing catalog…</> : <><RefreshCw size={14} />{knownWorkflowCount ? ui("Refresh workflow catalog") : ui("Analyze the last {value1} days", { value1: WORKFLOW_CATALOG_DAYS })}</>}</button>
- </div>
- <div className={styles.heroProof}>
- <span>{analysis ? ui("Catalog scan · last {value1} days", { value1: analysis.days }) : ui("{value1}-day catalog", { value1: WORKFLOW_CATALOG_DAYS })}</span>
- <strong>{formatMinutes(analysis?.observedActiveMinutes ?? 0)}</strong>
- <small>Captured active time reviewed</small>
- <div><i style={{ width: `${Math.min(100, workflows.length * 18)}%` }} /></div>
- {analysis && <p>{analysis.bundleCount} days with usable history · {formatAnalyzedAt(analysis.analyzedAt)}</p>}
- </div>
- </section>
- <RuntimeNotice runtime={runtime} refresh={refreshRuntime} openAccount={openAccount} />
- {error && <ErrorNotice message={error} retry={analyze} />}
- {workProfile && profileCompletion(workProfile) < 2 && <section className={styles.profilePrompt}>
- <Target size={17} />
- <div><strong>Make the maps relevant to your goals</strong><p>Add your role and current outcomes. Measures and the value of time stay optional.</p></div>
- <button type="button" onClick={() => navigate("profile")}>Add context <ArrowRight size={12} /></button>
- </section>}
- {analysis?.quality && <AnalysisQualityPanel quality={analysis.quality} />}
- {!knownWorkflowCount ? <EmptyWorkMap analyzing={analyzing} analyze={analyze} /> : !workflows.length ? (
- <section className={styles.emptyState}>
- <Clock3 size={23} />
- <h2>No known workflows were active in this period</h2>
- <p>Your catalog still contains {ui("{count, plural, one {# workflow} other {# workflows}}", { count: knownWorkflowCount })}. Choose “All known” above to see them.</p>
- </section>
- ) : (
- <>
- <section className={styles.statGrid} aria-label={ui("Work map summary")}>
- <div><span>Measured durations</span><strong>{measuredWorkflowCount}</strong><small>From exact meeting windows</small></div>
- <div><span>Timing not inferred</span><strong>{unmeasuredWorkflowCount}</strong><small>Needs continuous evidence</small></div>
- <div><span>Friction you can affect</span><strong>{actionableCount}</strong><small>{constraintCount} other constraint{constraintCount === 1 ? "" : "s"}</small></div>
- <div><span>Workflows shown</span><strong>{workflows.length}</strong><small>{activityPeriodLabel(activityPeriod).toLocaleLowerCase()}</small></div>
- </section>
- <div className={styles.sectionHeading}><div><span>Repeated patterns</span><h2>Workflows supported by captured evidence</h2></div><button className={styles.textButton} onClick={() => navigate("workflows")}>View all workflows <ArrowRight size={14} /></button></div>
- <section className={styles.timeMap}>
- {workflows.map((workflow, index) => {
- return (
- <button key={workflow.title} onClick={() => openWorkflow(index)}>
- <div className={styles.timeMapTitle}><span>0{index + 1}</span><div><strong>{workflow.title}</strong><small>{workflow.frequency}</small></div></div>
- <div className={styles.timeBar}><i style={{ width: hasMeasuredDuration(workflow) ? "100%" : "0%" }} /><b style={{ width: "0%" }} /></div>
- <div className={styles.timeLegend}><span>{workflow.quality.distinctDays} captured day{workflow.quality.distinctDays === 1 ? "" : "s"}</span><strong>{hasMeasuredDuration(workflow) ? ui("{value1} observed meeting", { value1: workflowDurationLabel(workflow) }) : ui("Duration not inferred")}</strong></div>
- <ChevronRight size={16} />
- </button>
- );
- })}
- </section>
- </>
- )}
- </>
- );
-}
-
function WorkflowsView({ reviewIds, workflows, knownWorkflowCount, query, setQuery, openWorkflow, analyze, analyzing, error, stop, updatedAt, checkedThrough, changes, job, subscribe, activityState, analysisUnavailableReason }: { reviewIds?: ReadonlySet<string>; activityState: WorkflowActivityState; analysisUnavailableReason?: string; workflows: WorkflowMap[]; knownWorkflowCount: number; query: string; setQuery: (query: string) => void; openWorkflow: (index: number) => void; analyze: () => void; analyzing: boolean; error: string; stop?: () => void; updatedAt?: string; checkedThrough?: string; changes?: { created: number; updated: number }; job?: WorkflowAnalysisJob | null; subscribe?: WorkflowsPlatform["subscribeAnalysisActivity"] }) {
const ui = useGT();
const visible = useMemo(() => filterWorkflows(workflows, { ...defaultWorkflowFilters, query }), [query, workflows]);
@@ -890,13 +664,6 @@ function WorkflowCorrection({ workflow, save }: { workflow: WorkflowMap; save: (
}
// Saved coverage notes can contain legacy capture names. Keep source quotations intact.
-function screenDataNote(text: string): string {
- return text
- .replace(/\b(?:OCR|a11y)(?:[- ]derived)?(?: (?:screen )?(?:text|excerpts|data))?\b/gi, "screen data")
- .replace(/\baccessibility[- ](?:derived|extracted) (?:screen )?text\b/gi, "screen data")
- .replace(/(^|[.!?]\s+)screen data\b/g, "$1Screen data");
-}
-
function WorkflowDetail({ canSaveAnswers, composerAccessory, active, onAnswersSaved, workflow, navigate, platform, workProfile, saveCorrection, saveEdits, onShareWorkflow, workflowAgentActions }: { canSaveAnswers: boolean; composerAccessory?: WorkflowsAppProps["composerAccessory"]; active: boolean; onAnswersSaved: (workflow: WorkflowMap) => void; workflow: WorkflowMap | null; navigate: (view: AppView) => void; platform: WorkflowsPlatform; workProfile: WorkProfile | null; saveCorrection?: (note: string) => Promise<void>; saveEdits?: (draft: WorkflowEdit) => Promise<WorkflowMap>; onShareWorkflow?: WorkflowsAppProps["onShareWorkflow"]; workflowAgentActions?: WorkflowsAppProps["workflowAgentActions"] }) {
const ui = useGT();
const [expandedStages, setExpandedStages] = useState<Set<number>>(() => new Set());
@@ -962,7 +729,7 @@ function WorkflowDetail({ canSaveAnswers, composerAccessory, active, onAnswersSa
.catch((error) => setSkillError(error instanceof Error ? error.message : String(error || "Could not save the skill.")))
.finally(() => setSkillSaving(false));
}, [platform, skillDraft]);
- if (workflow && guideOpen && platform.guides) return <WorkflowGuide key={workflow.id || workflow.title} workflow={workflow} platform={platform.guides} close={() => setGuideOpen(false)} />;
+ if (workflow && guideOpen && platform.guides) return <WorkflowGuide key={workflow.id || workflow.title} workflow={workflow} platform={platform.guides} loadScreenshot={platform.loadWorkflowScreenshot} close={() => setGuideOpen(false)} />;
if (!workflow) return <section className={styles.emptyState}><ListTree size={23} /><h2>No workflow selected</h2><button className={styles.primaryButton} onClick={() => navigate("workflows")}>View workflows</button></section>;
const allStagesOpen = expandedStages.size === workflow.stages.length;
@@ -1012,12 +779,7 @@ function WorkflowDetail({ canSaveAnswers, composerAccessory, active, onAnswersSa
{detail.quote && <details><summary>{detail.userEdited || stage.userEdited ? "Original reference" : "Source excerpt"} · {detail.app}</summary><blockquote>{detail.quote}</blockquote><small>{formatEvidenceTimestamp(detail.timestamp)} · {detail.userEdited || stage.userEdited ? "Edited instructions are not verified by this reference" : "Text match, not execution verification"}</small></details>}
</li>)}</ol> : <p>Step not yet verified.</p>}
</section>
- {verifiedStageScreenshots(stage).map(screenshot => <div key={screenshot.frameId} className={styles.stageScreenshot}>
- <>
- <div className={styles.screenshotFrame}><img src={screenshot.dataUrl} alt={ui("Captured screen evidence for {value1}", { value1: stage.name })} draggable={false} data-lm-disable="true" /></div>
- <div><Camera size={12} /><span>{formatEvidenceTimestamp(screenshot.timestamp)} · {screenshot.app} · {screenshotMatchLabel(screenshot.matchDistanceSeconds)}</span><CapturedMomentButton frameId={screenshot.frameId} timestamp={screenshot.timestamp} open={platform.openCapturedMoment} /></div>
- </>
- </div>)}
+ <WorkflowStepEvidence workflow={workflow} stage={stage} platform={platform} />
</div>}
</article>;
})}
@@ -1052,92 +814,6 @@ function WorkflowDetail({ canSaveAnswers, composerAccessory, active, onAnswersSa
);
}
-const timeLensOptions = [
- ["categories", ChartPie, "Categories"],
- ["projects", FolderKanban, "Projects"],
-] as const;
-
-function TimeAllocationList({ items, lens, query }: { items: TimeAllocationItem[]; lens: TimeLens; query: string }) {
- const ui = useGT();
- if (!items.length) {
- return <section className={styles.timeLensEmpty}>
- <FileCheck2 size={21} />
- <h2>{query ? ui("No matches") : lens === "projects" ? ui("No measured project time yet") : ui("No supported categories yet")}</h2>
- <p>{query ? ui("Try another name or clear the filter.") : lens === "projects" ? ui("Project time stays hidden until it can be tied to measured activity.") : ui("Refresh to group clearly identifiable work. Unclear activity stays unattributed.")}</p>
- </section>;
- }
-
- return <section className={styles.timeAllocationList}>
- {items.map((item, index) => <article key={`${lens}-${item.label}`} className={styles.timeAllocationItem}>
- <div className={styles.timeAllocationRank}>{String(index + 1).padStart(2, "0")}</div>
- <div className={styles.timeAllocationBody}>
- <div className={styles.timeAllocationHead}><div><h2>{item.label}</h2>{item.description && <p>{item.description}</p>}</div><div><strong>{formatMinutes(item.minutes)}</strong><span>{item.percentage}% of active time</span></div></div>
- <div className={styles.timeAllocationBar} aria-label={ui("{value1}% of captured time", { value1: item.percentage })}><i style={{ width: `${Math.max(1, Math.min(100, item.percentage))}%` }} /></div>
- </div>
- </article>)}
- </section>;
-}
-
-function TimeView({ analysis, analyze, analyzing, workProfile, lens, setLens }: { analysis: WorkflowAnalysis | null; analyze: () => void; analyzing: boolean; workProfile: WorkProfile | null; lens: TimeLens; setLens: (lens: TimeLens) => void }) {
- const ui = useGT();
- const [query, setQuery] = useState("");
- const [visibleCount, setVisibleCount] = useState(12);
- const profile = analysis?.timeProfile;
- const dimension = profile?.[lens];
- const matchingItems = useMemo(() => {
- const normalized = query.trim().toLowerCase();
- if (!dimension) return [];
- if (!normalized) return dimension.items;
- return dimension.items.filter((item) =>
- [item.label, item.description, ...item.apps].some((value) => value.toLowerCase().includes(normalized)),
- );
- }, [dimension, query]);
- useEffect(() => {
- setQuery("");
- setVisibleCount(12);
- }, [lens]);
- if (!profile) {
- return <>
- <div className={styles.pageHeader}><div><h1>Recorded active time</h1></div></div>
- {analyzing ? <ProcessingView /> : <section className={styles.emptyState}><ChartPie size={23} /><h2>Map your active time</h2><p>Group measured work into categories across the last {WORKFLOW_CATALOG_DAYS} days.</p><button className={styles.primaryButton} onClick={analyze}><RefreshCw size={14} />Refresh time</button></section>}
- </>;
- }
- if (!dimension) return null;
- const usableDays = analysis?.quality.usableDays ?? 0;
- const visibleItems = matchingItems.slice(0, visibleCount);
- const hiddenCount = matchingItems.length - visibleItems.length;
- const lensName = lens === "categories" ? "categories" : "projects";
- const resultLabel = matchingItems.length === 1
- ? ({ categories: "category", projects: "project" } as const)[lens]
- : ({ categories: "categories", projects: "projects" } as const)[lens];
-
- return <>
- <div className={styles.pageHeader}>
- <div><h1>Recorded active time</h1></div>
- <button className={styles.primaryButton} onClick={analyze} disabled={analyzing}>{analyzing ? <><span className={styles.spinnerSmall} />Refreshing…</> : <><RefreshCw size={14} />Refresh profile</>}</button>
- </div>
- <section className={styles.timeSummary} aria-label={ui("Time profile summary")}>
- <div><span>Captured active time</span><strong>{formatMinutes(profile.totalMinutes)}</strong></div>
- <div><span>History reviewed</span><strong>{usableDays} days</strong></div>
- <div><span>{lens === "categories" ? ui("Category") : ui("Project")} coverage</span><strong>{dimension.coveragePercent}%</strong></div>
- <div><span>Unattributed</span><strong>{formatMinutes(dimension.unattributedMinutes)}</strong></div>
- </section>
- {workProfile?.hourlyValue && workProfile.hourlyValue.amount > 0 && <section className={styles.timeValueNotice}>
- <BadgeDollarSign size={17} />
- <div><strong>{formatCurrency((profile.totalMinutes / 60) * workProfile.hourlyValue.amount, workProfile.hourlyValue.currency)} estimated time value</strong><p>Based on your hourly value.</p></div>
- </section>}
- <div className={styles.timeLensTabs} role="tablist" aria-label={ui("Time profile lens")}>
- {timeLensOptions.map(([target, Icon, label]) => <button key={target} role="tab" aria-selected={lens === target} className={lens === target ? styles.timeLensActive : ""} onClick={() => setLens(target)}><Icon size={15} /><span>{label}</span><strong>{profile[target].items.length}</strong></button>)}
- </div>
- <div className={styles.timeLensTools}>
- <label><Search size={13} /><input aria-label={ui("Filter {value1}", { value1: lensName })} value={query} onChange={(event) => { setQuery(event.target.value); setVisibleCount(12); }} placeholder={ui("Filter {value1}…", { value1: lensName })} /></label>
- <strong>{matchingItems.length} {resultLabel}</strong>
- </div>
- <TimeAllocationList items={visibleItems} lens={lens} query={query} />
- {hiddenCount > 0 && <button className={styles.timeShowMore} onClick={() => setVisibleCount((count) => count + 24)}>Show {Math.min(hiddenCount, 24)} more <span>{hiddenCount} remaining</span></button>}
- </>;
-}
-
type RankedBottleneck = WorkflowBottleneck & { workflowTitle: string; repetitions: number };
function BottleneckList({ items, openWorkflow, numbered = true }: { items: RankedBottleneck[]; openWorkflow?: (title: string) => void; numbered?: boolean }) {
@@ -1152,21 +828,6 @@ function BottleneckList({ items, openWorkflow, numbered = true }: { items: Ranke
))}</div>;
}
-function BottlenecksView({ workflows, openWorkflow }: { workflows: WorkflowMap[]; openWorkflow: (index: number) => void }) {
- const items = workflows.flatMap((workflow) => workflow.bottlenecks.map((item) => ({ ...item, workflowTitle: workflow.title, repetitions: workflow.repetitions })));
- const actionable = items.filter(isActionableBottleneck).sort((a, b) => b.estimatedMinutesPerRun - a.estimatedMinutesPerRun);
- const constraints = items.filter((item) => !isActionableBottleneck(item)).sort((a, b) => b.estimatedMinutesPerRun - a.estimatedMinutesPerRun);
- const largestDelay = actionable.reduce((largest, item) => Math.max(largest, item.estimatedMinutesPerRun), 0);
- const openByTitle = (title: string) => openWorkflow(workflows.findIndex((workflow) => workflow.title === title));
- return <><div className={styles.pageHeader}><div><h1>Friction and constraints</h1><p>Focus on what you can affect. Plan around the rest.</p></div>{!!actionable.length && <div className={styles.headerMetric}><span>Largest addressable delay</span><strong>{formatMinutes(largestDelay)}</strong></div>}</div>{actionable.length ? <><div className={styles.sectionHeading}><div><span>Within reach</span><h2>Friction you can affect</h2></div></div><BottleneckList items={actionable} openWorkflow={openByTitle} /></> : <section className={styles.emptyState}><CheckCircle2 size={23} /><h2>No actionable friction identified</h2><p>Only external or required constraints were found.</p></section>}{!!constraints.length && <><div className={styles.sectionHeading}><div><span>Plan around</span><h2>External and required constraints</h2></div><Pill>{constraints.length}</Pill></div><BottleneckList items={constraints} openWorkflow={openByTitle} numbered={false} /></>}</>;
-}
-
-function EvidenceView({ workflows, openWorkflow, runtime }: { workflows: WorkflowMap[]; openWorkflow: (index: number) => void; runtime: WorkflowRuntime | null }) {
- const items = workflows.flatMap((workflow, workflowIndex) => workflow.evidence.map((evidence) => ({ ...evidence, workflowTitle: workflow.title, workflowIndex })));
- const evidenceBoundary = runtime?.processingLocation === "cloud" || runtime?.processingLocation === "confidential-cloud" ? "Workspace-controlled evidence" : "Raw recording stays local";
- return <><div className={styles.pageHeader}><div><h1>Evidence behind the maps</h1><p>Exact captured moments for checking each map.</p></div><Pill><LockKeyhole size={12} />{evidenceBoundary}</Pill></div>{items.length ? <section className={styles.evidenceList}>{items.map((item, index) => <button key={`${item.timestamp}-${index}`} onClick={() => openWorkflow(item.workflowIndex)}><span className={styles.evidenceIndex}>{String(index + 1).padStart(2, "0")}</span><div><span>{formatEvidenceTimestamp(item.timestamp)} · {item.app}</span><strong>{item.workflowTitle}</strong><p>{item.detail}</p></div><ChevronRight size={16} /></button>)}</section> : <section className={styles.emptyState}><FileCheck2 size={23} /><h2>No evidence yet</h2><p>Build your first work map to see its captured moments.</p></section>}</>;
-}
-
const EMPTY_PROFILE_KPI: WorkProfileKpi = {
name: "",
definition: "",
@@ -1263,25 +924,6 @@ function ProfileView({
</div>;
}
-function PrivacyView({ runtime }: { runtime: WorkflowRuntime | null }) {
- const ui = useGT();
- const boundary = runtime?.dataBoundary;
- const workspaceView = Boolean(runtime?.workspace);
- const archiveOn = boundary?.archive.status === "end-to-end-encrypted";
- const minimumDays = boundary?.retention.recommendedMinimumDays ?? 30;
- const maximumDays = boundary?.retention.recommendedMaximumDays ?? 90;
- return <>
- <div className={styles.pageHeader}><div><h1>{workspaceView ? ui("What this workspace can see") : ui("Your work stays yours")}</h1><p>{workspaceView ? ui("Approved reports and aggregate patterns only. Raw employee history stays private.") : ui("Raw recordings and screenshots stay on this device.")}</p></div></div>
- {workspaceView && <section className={styles.boundaryStatement}><ShieldCheck size={18} /><div><strong>{boundary?.managerRawAccess ? ui("Workspace raw access is enabled") : ui("Managers cannot open raw employee history")}</strong><p>Employees control what they share.</p></div><Pill tone="green">Employee controlled</Pill></section>}
- <section className={styles.privacyGrid}>
- <article><LockKeyhole size={21} /><h2>Raw history stays local</h2><p>Screen, audio, and screenshots stay on the employee's device.</p><Pill tone="green">Device only</Pill></article>
- <article><Clock3 size={21} /><h2>{minimumDays}–{maximumDays} day local window</h2><p>The employee controls retention.</p><Pill>Employee retention</Pill></article>
- <article><ShieldCheck size={21} /><h2>{archiveOn ? ui("Encrypted private archive") : ui("Cloud archive is off")}</h2><p>{archiveOn ? ui("End-to-end encrypted with employee recovery.") : ui("No archive is connected.")}</p><Pill>{archiveOn ? ui("Employee recovery") : ui("Not connected")}</Pill></article>
- <article><Eye size={21} /><h2>{workspaceView ? ui("Approved outputs only") : ui("Sharing starts private")}</h2><p>{workspaceView ? ui("Only approved summaries and aggregate patterns are visible.") : ui("Nothing is shared unless you choose it.")}</p><Pill>{workspaceView ? ui("Aggregate only") : ui("Nothing shared")}</Pill></article>
- </section>
- </>;
-}
-
export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestHandled, platform, initialAnalysis = null, storageKey = "screenpipe-workflows:last-analysis-v2", initialScopeId, embedded = false, active = true, fullscreen = false, navigationBrand, composerAccessory, recordingStatus, statusNotice, toolbarAccessory, analysisUnavailableReason, onAnalysisUnavailable, navigationFooter, onShareWorkflow, workflowAgentActions }: WorkflowsAppProps) {
const uiLanguage = useLocale();
const ui = useGT();
@@ -1301,11 +943,9 @@ export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestH
const [selectedWorkflow, setSelectedWorkflow] = useState(0);
const [reviewIds, setReviewIds] = useState<ReadonlySet<string>>(new Set());
const [reviewError, setReviewError] = useState("");
- const activityPeriod: WorkflowActivityPeriod = 0;
const [query, setQuery] = useState("");
const [view, setView] = useState<AppView>("workflows");
const [libraryVisit, setLibraryVisit] = useState(0);
- const [timeLens, setTimeLens] = useState<TimeLens>("categories");
const [commandPaletteOpen, setCommandPaletteOpen] = useState(false);
const shortcutPrefix = useRef<{ key: string; at: number } | null>(null);
const scopes = runtime?.availableScopes ?? (analysis?.scope ? [analysis.scope] : []);
@@ -1460,6 +1100,7 @@ export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestH
let prepared = false;
let timer: ReturnType<typeof setTimeout>;
const poll = async () => {
+ let delay = 30_000;
try {
if (!prepared) {
await platform.ensureAnalysisTask?.();
@@ -1469,9 +1110,10 @@ export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestH
const job = await platform.getLatestAnalysisJob!();
if (disposed) return;
// Missing status is not a new run or proof that the active update ended.
- if (!job) { timer = setTimeout(poll, 3000); return; }
+ if (!job) { timer = setTimeout(poll, 30_000); return; }
if (job?.status !== "complete") setAnalysisJob(job);
if (job && (job.status === "queued" || job.status === "processing")) {
+ delay = 3000;
setAnalyzing(true);
setAnalysisError("");
} else {
@@ -1479,15 +1121,17 @@ export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestH
if (job.status === "complete") {
const completed = await platform.getAnalysisJob!(job.id);
if (!disposed) setAnalysisJob(completed);
- if (!disposed && completed.result) { setAnalysis(current => retainNewerWorkflowEdits(current, sanitizeWorkflowAnalysis(completed.result!))); setCatalogReady(true); setAnalysisError(""); }
+ if (!disposed && completed.result) { setAnalysis(current => retainNewerWorkflowEdits(current, sanitizeWorkflowAnalysis(completed.result!))); setCatalogReady(true); setAnalysisError(""); observedJob.current = job.id; }
else if (!disposed && completed.message) setAnalysisError(completed.message);
- } else setAnalysisError(job.message || "Could not update workflows.");
- observedJob.current = job.id;
+ } else {
+ setAnalysisError(job.message || "Could not update workflows.");
+ observedJob.current = job.id;
+ }
}
if (!disposed) setAnalyzing(false);
}
} catch (error) { if (!disposed) { setAnalysisError(error instanceof Error ? error.message : "Could not check the workflow task."); } }
- if (!disposed) timer = setTimeout(poll, 3000);
+ if (!disposed) timer = setTimeout(poll, delay);
};
void poll();
return () => { disposed = true; clearTimeout(timer); };
@@ -1520,7 +1164,7 @@ export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestH
await platform.saveCapturedWork(mergedAnalysis, { scope: requestedScope, workProfile });
} else if (storageKey) {
try {
- window.localStorage.setItem(storageKey, JSON.stringify(withoutScreenshotCopies(mergedAnalysis)));
+ window.localStorage.setItem(storageKey, serializeWorkflowData(mergedAnalysis));
} catch {
throw new Error("The work map was built, but could not be saved.");
}
@@ -1608,7 +1252,7 @@ export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestH
...scopeCommands,
...workflowCommands,
];
- }, [activeScope?.id, activityPeriod, analyze, analyzing, embedded, query, focusWorkflowSearch, navigate, openWorkflow, platform.assistant, runtime?.dataBoundary?.workspaceVisibility, scopes, selectScope, workflows, shortcuts.left.aria, shortcuts.right.aria, uiLanguage]);
+ }, [activeScope?.id, analyze, analyzing, embedded, query, focusWorkflowSearch, navigate, openWorkflow, platform.assistant, runtime?.dataBoundary?.workspaceVisibility, scopes, selectScope, workflows, shortcuts.left.aria, shortcuts.right.aria, uiLanguage]);
useEffect(() => {
if (!active) return;
@@ -1652,8 +1296,6 @@ export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestH
let content: React.ReactNode;
switch (view) {
- case "overview": content = <OverviewView analysis={analysis ? { ...analysis, analysis: { workflows } } : null} analyzing={analyzing} error={analysisError} analyze={() => void analyze()} openWorkflow={openWorkflow} navigate={navigate} knownWorkflowCount={knownWorkflows.length} activityPeriod={activityPeriod} runtime={runtime} workProfile={workProfile} refreshRuntime={refreshRuntime} openAccount={platform.openAccount} />; break;
- case "time": content = <TimeView analysis={analysis} analyze={() => void analyze()} analyzing={analyzing} workProfile={workProfile} lens={timeLens} setLens={setTimeLens} />; break;
case "workflows": content = <WorkflowsView reviewIds={reviewIds} activityState={runActivity} analysisUnavailableReason={onAnalysisUnavailable ? undefined : analysisUnavailableReason} workflows={workflows} knownWorkflowCount={knownWorkflows.length} query={query} setQuery={setQuery} openWorkflow={openWorkflow} analyze={() => void analyze()} analyzing={analyzing} error={analysisError || reviewError} stop={platform.cancelAnalysisJob ? () => { void platform.cancelAnalysisJob!().catch(error => setAnalysisError(String(error))); } : undefined} updatedAt={analysis?.analyzedAt} checkedThrough={analysis?.checkedThrough} changes={analysis?.changes} job={analysisJob} subscribe={platform.subscribeAnalysisActivity} />; break;
case "workflow": content = <WorkflowDetail canSaveAnswers={catalogReady && (!activeScope || activeScope.kind === "personal")} composerAccessory={composerAccessory} active={active} onAnswersSaved={saved => setAnalysis(current => current ? { ...current, analysis: { ...current.analysis, workflows: current.analysis.workflows.map(w => (w.id ?? w.title) === (saved.id ?? saved.title) && (saved.revision ?? 0) >= (w.revision ?? 0) ? saved : w) } } : current)} key={activeWorkflow?.id || activeWorkflow?.title} onShareWorkflow={onShareWorkflow} workflowAgentActions={workflowAgentActions} workflow={activeWorkflow} navigate={navigate} platform={platform} workProfile={workProfile} saveEdits={catalogReady && platform.saveWorkflowEdits && (!activeScope || activeScope.kind === "personal") ? async (draft) => {
let saved: WorkflowMap;
@@ -1675,14 +1317,11 @@ export function WorkflowsApp({ readyWorkflowIds, reviewRequest, onReviewRequestH
await platform.saveCapturedWork!(updated, { scope: activeScope ?? undefined });
setAnalysis(updated);
} : undefined} />; break;
- case "bottlenecks": content = <BottlenecksView workflows={workflows} openWorkflow={openWorkflow} />; break;
case "profile": content = null; break;
case "library": content = <WorkflowLibrary key={libraryVisit} platform={platform} workflows={knownWorkflows} />; break;
- case "evidence": content = <EvidenceView workflows={workflows} openWorkflow={openWorkflow} runtime={runtime} />; break;
- case "privacy": content = <PrivacyView runtime={runtime} />; break;
}
- const catalogView = view !== "profile" && view !== "privacy" && view !== "library";
+ const catalogView = view !== "profile" && view !== "library";
if (catalogView && !knownWorkflows.length && (catalogLoading || catalogLoadError)) {
content = catalogLoading ? <CatalogPlaceholder detail={view === "workflow"} reconnecting={catalogReconnecting} retry={refreshRuntime} /> : <>
<div className={`${styles.pageHeader} ${styles.catalogHeader}`}><h1>Your workflows</h1></div>