Address macroscope + cursor follow-up review findings

- ClaudeAdapter: dedupe workflow agents/phases by index (last write wins) before applying entry caps, so repeated slot updates cannot exhaust the cap and freeze later agents stale; restrict sessionUrl to http(s) so a hostile tool result cannot smuggle a javascript: href - workflowUi: guard sessionUrl scheme again at both anchor render sites (defense in depth for payloads persisted before the adapter filter) - Ingestion: JSON-encode the (threadId, taskId) tuple in stable workflow activity ids to remove delimiter-ambiguity collisions - workflow-logic: order same-timestamp activities by provider sequence then lifecycle rank so task.completed can never apply before its task.started - WorkflowPanel/Card: scope phase and agent row keys by taskId so switching runs remounts rows instead of leaking expanded transcript state and cursors across runs - workflowUi: phase progress counter counts settled (done + error) agents instead of reporting 0/1 for an errored terminal phase - client-runtime: readJournal query polls every 4s while mounted so the Logs tab picks up new results during a live run - mobile: keep workflow task.completed rows (only per-tick progress is suppressed) — with no workflow card on mobile it is the only signal a workflow finished or failed

Theo Browne committed 4 months ago

Commit 0eaeb941 parent 1610d399 files · +122 −30Browse files

Unified · Split

9 files

apps/mobile/src/lib/threadActivity.ts +4 −2
apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts +10 −5
apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts +4 −2
apps/server/src/provider/Layers/ClaudeAdapter.ts +30 −9
apps/web/src/components/workflow/WorkflowPanel.tsx +9 −4
apps/web/src/components/workflow/WorkflowRunCard.tsx +10 −4
apps/web/src/components/workflow/workflowUi.tsx +20 −1
apps/web/src/workflow-logic.ts +31 −3
packages/client-runtime/src/state/workflow.ts +4 −0

apps/mobile/src/lib/threadActivity.ts+4−2

     if (activity.kind === "task.started") continue;
     // Workflow snapshot/meta activities back the desktop workflow card; on
     // mobile they would render as ever-mutating raw rows, so skip them —
-    // along with the per-tick task rows the workflow owns.
+    // along with the per-tick progress rows the workflow owns. task.completed
+    // stays: with no workflow card here it is mobile's only signal that a
+    // workflow finished, failed, or was stopped.
     if (activity.kind === "task.workflow-updated") continue;
     if (activity.kind === "task.workflow-meta") continue;
     if (
-      (activity.kind === "task.progress" || activity.kind === "task.completed") &&
+      activity.kind === "task.progress" &&
       workflowTaskIds.size > 0 &&
       activityBelongsToWorkflow(activity, workflowTaskIds)
     ) {

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts+10−5

     const thread = await waitForThread(harness.readModel, (entry) =>
       entry.activities.some(
-        (activity: ProviderRuntimeTestActivity) => activity.id === "workflow:thread-1:task-wf-1",
+        (activity: ProviderRuntimeTestActivity) =>
+          activity.id === `workflow:${JSON.stringify(["thread-1", "task-wf-1"])}`,
       ),
     );
     expect(perTick?.kind).toBe("task.progress");
     const snapshot = thread.activities.find(
-      (activity: ProviderRuntimeTestActivity) => activity.id === "workflow:thread-1:task-wf-1",
+      (activity: ProviderRuntimeTestActivity) =>
+        activity.id === `workflow:${JSON.stringify(["thread-1", "task-wf-1"])}`,
     );
     expect(snapshot?.kind).toBe("task.workflow-updated");
     const payload =
     const thread = await waitForThread(harness.readModel, (entry) =>
       entry.activities.some(
-        (activity: ProviderRuntimeTestActivity) => activity.id === "workflow-meta:thread-1:task-wf-meta",
+        (activity: ProviderRuntimeTestActivity) =>
+          activity.id === `workflow-meta:${JSON.stringify(["thread-1", "task-wf-meta"])}`,
       ),
     );
     const meta = thread.activities.find(
-      (activity: ProviderRuntimeTestActivity) => activity.id === "workflow-meta:thread-1:task-wf-meta",
+      (activity: ProviderRuntimeTestActivity) =>
+        activity.id === `workflow-meta:${JSON.stringify(["thread-1", "task-wf-meta"])}`,
     );
     expect(meta?.kind).toBe("task.workflow-meta");
     const payload =
     const drainedThread = drained.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
     const snapshots = drainedThread?.activities.filter(
-      (activity: ProviderRuntimeTestActivity) => activity.id === "workflow:thread-1:task-wf-2",
+      (activity: ProviderRuntimeTestActivity) =>
+        activity.id === `workflow:${JSON.stringify(["thread-1", "task-wf-2"])}`,
     );
     expect(snapshots).toHaveLength(1);
     const payload =

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts+4−2

  * Stable per-task activity ids: workflow snapshot/meta activities are
  * upserted (one projection row per run), not appended per progress tick.
  */
+// JSON-encode the (threadId, taskId) tuple: both are free-form strings, so a
+// bare `:`-joined key would let distinct pairs collide on the upsert id.
 function workflowActivityId(threadId: ThreadId, taskId: string): EventId {
-  return EventId.make(`workflow:${threadId}:${taskId}`);
+  return EventId.make(`workflow:${JSON.stringify([threadId, taskId])}`);
 }
 function workflowMetaActivityId(threadId: ThreadId, taskId: string): EventId {
-  return EventId.make(`workflow-meta:${threadId}:${taskId}`);
+  return EventId.make(`workflow-meta:${JSON.stringify([threadId, taskId])}`);
 }
 function truncateDetail(value: string, limit = 180): string {

apps/server/src/provider/Layers/ClaudeAdapter.ts+30−9

   if (!Array.isArray(value) || value.length === 0) {
     return undefined;
   }
-  const agents: Array<WorkflowAgentProgressEntry> = [];
+  // Last write wins per index: the snapshot may re-emit an agent/phase slot
-  const phases: Array<WorkflowPhaseProgressEntry> = [];
+  // (retries, later progress), and the cap must count unique slots, not raw
+  // entries, or repeats would freeze later agents in a stale state.
+  const agentsByIndex = new Map<number, WorkflowAgentProgressEntry>();
+  const phasesByIndex = new Map<number, WorkflowPhaseProgressEntry>();
   const logs: Array<WorkflowLogProgressEntry> = [];
   for (const raw of value) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
     switch (entry.type) {
       case "workflow_agent": {
         const agent = normalizeWorkflowAgentEntry(entry);
-        if (agent && agents.length < MAX_WORKFLOW_AGENT_ENTRIES) {
+        if (
-          agents.push(agent);
+          agent &&
+          (agentsByIndex.has(agent.index) || agentsByIndex.size < MAX_WORKFLOW_AGENT_ENTRIES)
+        ) {
+          agentsByIndex.set(agent.index, agent);
         }
         break;
       }
         if (
           index !== undefined &&
           title !== undefined &&
-          phases.length < MAX_WORKFLOW_PHASE_ENTRIES
+          (phasesByIndex.has(index) || phasesByIndex.size < MAX_WORKFLOW_PHASE_ENTRIES)
         ) {
-          phases.push({
+          phasesByIndex.set(index, {
             type: "workflow_phase",
             index,
             title,
   // Narration is append-only upstream; keep the newest lines when clipping.
   const clippedLogs =
     logs.length > MAX_WORKFLOW_LOG_ENTRIES ? logs.slice(-MAX_WORKFLOW_LOG_ENTRIES) : logs;
-  const entries = [...phases, ...agents, ...clippedLogs];
+  const entries = [...phasesByIndex.values(), ...agentsByIndex.values(), ...clippedLogs];
   return entries.length > 0 ? entries : undefined;
 }
   return normalizeWorkflowProgress(raw);
 }
+function workflowHttpUrl(value: unknown): string | undefined {
+  const text = workflowString(value);
+  if (text === undefined) {
+    return undefined;
+  }
+  // Clients render this into an anchor href — restrict to web URLs so a
+  // hostile tool result cannot smuggle a javascript:/file: scheme through.
+  try {
+    const parsed = new URL(text);
+    return parsed.protocol === "https:" || parsed.protocol === "http:" ? text : undefined;
+  } catch {
+    return undefined;
+  }
+}
 function normalizeWorkflowRunHandles(
   toolUseResult: Record<string, unknown>,
 ): WorkflowRunHandles | undefined {
     ...(workflowString(toolUseResult.transcriptDir) !== undefined
       ? { transcriptDir: workflowString(toolUseResult.transcriptDir) }
       : {}),
-    ...(workflowString(toolUseResult.sessionUrl) !== undefined
+    ...(workflowHttpUrl(toolUseResult.sessionUrl) !== undefined
-      ? { sessionUrl: workflowString(toolUseResult.sessionUrl) }
+      ? { sessionUrl: workflowHttpUrl(toolUseResult.sessionUrl) }
       : {}),
     ...(workflowString(toolUseResult.warning) !== undefined
       ? { warning: workflowString(toolUseResult.warning) }

apps/web/src/components/workflow/WorkflowPanel.tsx+9−4

   workflowRunTitle,
 } from "~/workflow-logic";
 import { Button } from "../ui/button";
-import { AgentRowContent, PhaseHeader, WorkflowStatusChip } from "./workflowUi";
+import {
+  AgentRowContent,
+  PhaseHeader,
+  WorkflowStatusChip,
+  safeWorkflowSessionUrl,
+} from "./workflowUi";
 import { useCopyToClipboard } from "../../hooks/useCopyToClipboard";
 type WorkflowTabId = "run" | "script" | "logs";
   remote: boolean;
 }): ReactElement {
   if (remote) {
-    const sessionUrl = run.handles?.sessionUrl;
+    const sessionUrl = safeWorkflowSessionUrl(run.handles?.sessionUrl);
     if (sessionUrl === undefined) {
       return <MutedBody text="Running in the cloud" />;
     }
   return (
     <div className="space-y-px">
       {run.phases.map((phase) => (
-        <div key={phase.index}>
+        <div key={`${run.taskId}:${phase.index}`}>
           <PhaseHeader phase={phase} />
           {phase.agents.map((agent) => (
             <ExpandableAgentRow
-              key={agent.index}
+              key={`${run.taskId}:${agent.index}`}
               agent={agent}
               environmentId={environmentId}
               transcriptDir={transcriptDir}

apps/web/src/components/workflow/WorkflowRunCard.tsx+10−4

   workflowRunTitle,
 } from "~/workflow-logic";
 import { Button } from "../ui/button";
-import { AgentRowContent, PhaseHeader, WorkflowStatusChip, agentRollupLabel } from "./workflowUi";
+import {
+  AgentRowContent,
+  PhaseHeader,
+  WorkflowStatusChip,
+  agentRollupLabel,
+  safeWorkflowSessionUrl,
+} from "./workflowUi";
 const MAX_CARD_AGENT_ROWS = 8;
               return null;
             }
             return (
-              <div key={phase.index}>
+              <div key={`${run.taskId}:${phase.index}`}>
                 <PhaseHeader phase={phase} />
                 {rows.map((agent) => (
-                  <div key={agent.index} className="px-0.5 py-0.5">
+                  <div key={`${run.taskId}:${agent.index}`} className="px-0.5 py-0.5">
                     <AgentRowContent agent={agent} />
                   </div>
                 ))}
 }
 function RemoteRunBody({ run }: { run: WorkflowRun }): ReactElement {
-  const sessionUrl = run.handles?.sessionUrl;
+  const sessionUrl = safeWorkflowSessionUrl(run.handles?.sessionUrl);
   if (sessionUrl === undefined) {
     return (
       <p className="mt-1.5 px-0.5 text-[12px] text-muted-foreground/70 leading-5">

apps/web/src/components/workflow/workflowUi.tsx+20−1

@@ -157,8 +157,27 @@ export function AgentRowContent({ · 156 unmodified lines
157	// Phase header + rollup helpers	157	// Phase header + rollup helpers
158	// ---------------------------------------------------------------------------	158	// ---------------------------------------------------------------------------
159		159
		160	/**
		161	* Only web URLs may reach an anchor href. The server already filters the
		162	* scheme at ingestion; this guards payloads persisted before that filter
		163	* (and any other producer) as defense in depth.
		164	*/
		165	export function safeWorkflowSessionUrl(sessionUrl: string \| undefined): string \| undefined {
		166	if (sessionUrl === undefined) {
		167	return undefined;
		168	}
		169	try {
		170	const parsed = new URL(sessionUrl);
		171	return parsed.protocol === "https:" \|\| parsed.protocol === "http:" ? sessionUrl : undefined;
		172	} catch {
		173	return undefined;
		174	}
		175	}
		176
		177	/** Settled agents (done or error) — the x/y header is a progress counter,
		178	* and an errored agent has no work remaining. */
160	export function phaseDoneCount(phase: WorkflowRunPhase): number {	179	export function phaseDoneCount(phase: WorkflowRunPhase): number {
161	return phase.agents.filter((agent) => agent.status === "done").length;	180	return phase.agents.filter((agent) => agent.status === "done" \|\| agent.status === "error").length;
162	}	181	}
163		182
164	export function PhaseHeader({ phase }: { phase: WorkflowRunPhase }): ReactElement {	183	export function PhaseHeader({ phase }: { phase: WorkflowRunPhase }): ReactElement {

apps/web/src/workflow-logic.ts+31−3

@@ -300,13 +300,41 @@ export function collectWorkflowTaskIds( · 299 unmodified lines
300	return taskIds;	300	return taskIds;
301	}	301	}
302		302
		303	/**
		304	* Millisecond timestamps collide, so equal-time activities are ordered by
		305	* provider sequence when present, then by lifecycle rank — a task.completed
		306	* must never be applied before the task.started that creates its run.
		307	*/
		308	const WORKFLOW_ACTIVITY_RANK: Record<string, number> = {
		309	"task.started": 0,
		310	"task.workflow-meta": 1,
		311	"task.workflow-updated": 1,
		312	"task.completed": 2,
		313	};
		314
		315	function compareWorkflowActivityOrder(
		316	a: OrchestrationThreadActivity,
		317	b: OrchestrationThreadActivity,
		318	): number {
		319	if (a.sequence !== undefined && b.sequence !== undefined && a.sequence !== b.sequence) {
		320	return a.sequence - b.sequence;
		321	}
		322	const byTime = a.createdAt.localeCompare(b.createdAt);
		323	if (byTime !== 0) {
		324	return byTime;
		325	}
		326	const byRank = (WORKFLOW_ACTIVITY_RANK[a.kind] ?? 1) - (WORKFLOW_ACTIVITY_RANK[b.kind] ?? 1);
		327	if (byRank !== 0) {
		328	return byRank;
		329	}
		330	return a.id.localeCompare(b.id);
		331	}
		332
303	export function deriveWorkflowRuns(	333	export function deriveWorkflowRuns(
304	activities: ReadonlyArray<OrchestrationThreadActivity>,	334	activities: ReadonlyArray<OrchestrationThreadActivity>,
305	options?: { readonly sessionActive?: boolean \| undefined },	335	options?: { readonly sessionActive?: boolean \| undefined },
306	): WorkflowRun[] {	336	): WorkflowRun[] {
307	const ordered = [...activities].toSorted(	337	const ordered = [...activities].toSorted(compareWorkflowActivityOrder);
308	(a, b) => a.createdAt.localeCompare(b.createdAt) \|\| a.id.localeCompare(b.id),
309	);
310	const runs = new Map<string, MutableWorkflowRun>();	338	const runs = new Map<string, MutableWorkflowRun>();
311		339
312	const ensureRun = (taskId: string, activity: OrchestrationThreadActivity): MutableWorkflowRun => {	340	const ensureRun = (taskId: string, activity: OrchestrationThreadActivity): MutableWorkflowRun => {

packages/client-runtime/src/state/workflow.ts+4−0

       label: "environment-data:workflow:read-journal",
       tag: WS_METHODS.workflowReadJournal,
       staleTimeMs: 5_000,
+      // The journal grows while a run is live and the query only mounts
+      // while the Logs tab is open — poll so new results appear without a
+      // manual refresh.
+      refreshIntervalMs: 4_000,
     }),
     readAgentTranscript: createEnvironmentRpcCommand(runtime, {
       label: "environment-data:workflow:read-agent-transcript",