@stigmer/react 3.1.16 → 3.2.0

package/src/internal/store/__tests__/workflow-execution-event-store.test.ts

@@ -1,14 +1,20 @@
 import { describe, it, expect, vi } from "vitest";
 import { create } from "@bufbuild/protobuf";
+import type { JsonObject } from "@bufbuild/protobuf";
 import {
   WorkflowExecutionEventSchema,
   WorkflowEventType,
   TaskStartedPayloadSchema,
   TaskCompletedPayloadSchema,
+  TaskFailedPayloadSchema,
+  AgentCallStartedPayloadSchema,
+  AgentCallProgressPayloadSchema,
   ApprovalRequestedPayloadSchema,
   ApprovalResolvedPayloadSchema,
 } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
 import type { WorkflowExecutionEvent } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
+import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
+import { ExecutionPhase as AgentExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { WorkflowExecutionEventStore } from "../workflow-execution-event-store";
 
 // ---------------------------------------------------------------------------
@@ -18,7 +24,11 @@ import { WorkflowExecutionEventStore } from "../workflow-execution-event-store";
 function makeTaskStartedEvent(
   seq: number,
   taskName: string,
-  opts: { taskKind?: number; attemptNumber?: number } = {},
+  opts: {
+    taskKind?: number;
+    attemptNumber?: number;
+    inputSummary?: JsonObject;
+  } = {},
 ): WorkflowExecutionEvent {
   return create(WorkflowExecutionEventSchema, {
     eventId: `evt-${seq}`,
@@ -31,6 +41,7 @@ function makeTaskStartedEvent(
       value: create(TaskStartedPayloadSchema, {
         taskKind: opts.taskKind ?? 1,
         attemptNumber: opts.attemptNumber ?? 1,
+        inputSummary: opts.inputSummary,
       }),
     },
   });
@@ -39,7 +50,12 @@ function makeTaskStartedEvent(
 function makeTaskCompletedEvent(
   seq: number,
   taskName: string,
-  opts: { durationMs?: bigint; costMicros?: bigint; tokensUsed?: bigint } = {},
+  opts: {
+    durationMs?: bigint;
+    costMicros?: bigint;
+    tokensUsed?: bigint;
+    outputSummary?: JsonObject;
+  } = {},
 ): WorkflowExecutionEvent {
   return create(WorkflowExecutionEventSchema, {
     eventId: `evt-${seq}`,
@@ -54,6 +70,7 @@ function makeTaskCompletedEvent(
         durationMs: opts.durationMs ?? BigInt(100),
         costMicros: opts.costMicros ?? BigInt(500),
         tokensUsed: opts.tokensUsed ?? BigInt(200),
+        outputSummary: opts.outputSummary,
       }),
     },
   });
@@ -98,6 +115,84 @@ function makeApprovalResolvedEvent(
   });
 }
 
+function makeTaskFailedEvent(
+  seq: number,
+  taskName: string,
+  opts: { willRetry?: boolean; attemptNumber?: number; error?: string } = {},
+): WorkflowExecutionEvent {
+  return create(WorkflowExecutionEventSchema, {
+    eventId: `evt-${seq}`,
+    sequenceNumber: BigInt(seq),
+    occurredAt: "2026-05-22T00:00:00Z",
+    taskName,
+    eventType: WorkflowEventType.task_failed,
+    payload: {
+      case: "taskFailed",
+      value: create(TaskFailedPayloadSchema, {
+        taskKind: WorkflowTaskKind.agent_call,
+        willRetry: opts.willRetry ?? false,
+        attemptNumber: opts.attemptNumber ?? 1,
+        error: opts.error ?? "boom",
+        durationMs: BigInt(100),
+      }),
+    },
+  });
+}
+
+function makeAgentCallStartedEvent(
+  seq: number,
+  taskName: string,
+  opts: { childExecutionId?: string; agentSlug?: string } = {},
+): WorkflowExecutionEvent {
+  return create(WorkflowExecutionEventSchema, {
+    eventId: `evt-${seq}`,
+    sequenceNumber: BigInt(seq),
+    occurredAt: "2026-05-22T00:00:00Z",
+    taskName,
+    eventType: WorkflowEventType.agent_call_started,
+    payload: {
+      case: "agentCallStarted",
+      value: create(AgentCallStartedPayloadSchema, {
+        childExecutionId: opts.childExecutionId ?? "aex_child_1",
+        agentSlug: opts.agentSlug ?? "helper",
+        messageSummary: "do the thing",
+      }),
+    },
+  });
+}
+
+/**
+ * The REAL event shape the call-agent orchestrator emits on its 15s poll —
+ * `agentPhase` is the child AgentExecution's phase. The store derives the
+ * parent task's `waiting_approval` state from it (child gates are surfaced
+ * snapshot-only; no approval_requested event exists for agent_call tasks).
+ */
+function makeAgentCallProgressEvent(
+  seq: number,
+  taskName: string,
+  agentPhase: AgentExecutionPhase,
+  opts: { childExecutionId?: string; currentToolName?: string } = {},
+): WorkflowExecutionEvent {
+  return create(WorkflowExecutionEventSchema, {
+    eventId: `evt-${seq}`,
+    sequenceNumber: BigInt(seq),
+    occurredAt: "2026-05-22T00:00:00Z",
+    taskName,
+    eventType: WorkflowEventType.agent_call_progress,
+    payload: {
+      case: "agentCallProgress",
+      value: create(AgentCallProgressPayloadSchema, {
+        childExecutionId: opts.childExecutionId ?? "aex_child_1",
+        agentPhase,
+        currentToolName: opts.currentToolName ?? "",
+        tokensConsumed: BigInt(0),
+        messagesCount: 0,
+        toolCallsCount: 0,
+      }),
+    },
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -231,11 +326,208 @@ describe("WorkflowExecutionEventStore", () => {
     });
 
     it("approvalRequested without prior taskStarted is no-op (prev is undefined)", () => {
+      const states = new WorkflowExecutionEventStore();
+      states.appendEvents([makeApprovalRequestedEvent(1, "unknownTask")]);
+
+      expect(states.getTaskStates().has("unknownTask")).toBe(false);
+    });
+  });
+
+  // T06: the gate's request/resolution payloads are captured on the derived
+  // state — the thread card's in-place review surface reads them, so the
+  // capture must be reference-stable (structural sharing) and survive the
+  // task's settlement, while a restart resets it (a new attempt re-emits).
+  describe("deriveTaskStates — human_input gate capture (T06)", () => {
+    it("captures the approval_requested payload, reference-stable across unrelated appends", () => {
       const store = new WorkflowExecutionEventStore();
-      store.appendEvents([makeApprovalRequestedEvent(1, "unknownTask")]);
+      store.appendEvents([
+        makeTaskStartedEvent(1, "reviewGate", { taskKind: 16 }),
+        makeApprovalRequestedEvent(2, "reviewGate", "Ship it?"),
+      ]);
+      const first = store.getTaskStates().get("reviewGate")!.approvalRequest;
+      expect(first?.prompt).toBe("Ship it?");
+
+      // An unrelated task's event invalidates the cache and re-derives the
+      // whole map — the captured payload must keep its identity, or every
+      // memoized gating card would re-render per stream append.
+      store.appendEvents([makeTaskStartedEvent(3, "other-task", { taskKind: 1 })]);
+      expect(store.getTaskStates().get("reviewGate")!.approvalRequest).toBe(first);
+    });
 
-      const states = store.getTaskStates();
-      expect(states.has("unknownTask")).toBe(false);
+    it("captures the approval_resolved payload and keeps both records through settlement", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "reviewGate", { taskKind: 16 }),
+        makeApprovalRequestedEvent(2, "reviewGate"),
+        makeApprovalResolvedEvent(3, "reviewGate", { resolvedBy: "alice" }),
+        makeTaskCompletedEvent(4, "reviewGate"),
+      ]);
+
+      const task = store.getTaskStates().get("reviewGate")!;
+      expect(task.status).toBe("completed");
+      expect(task.approvalRequest?.prompt).toBe("Please review");
+      expect(task.approvalResolution?.resolvedBy).toBe("alice");
+    });
+
+    it("a restart resets the gate record — a new attempt re-emits its own request", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "reviewGate", { taskKind: 16 }),
+        makeApprovalRequestedEvent(2, "reviewGate"),
+        makeApprovalResolvedEvent(3, "reviewGate"),
+        makeTaskStartedEvent(4, "reviewGate", { taskKind: 16, attemptNumber: 2 }),
+      ]);
+
+      const task = store.getTaskStates().get("reviewGate")!;
+      expect(task.approvalRequest).toBeNull();
+      expect(task.approvalResolution).toBeNull();
+    });
+
+    it("a fresh request clears a stale resolution (re-gated task never reports the old decision)", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "reviewGate", { taskKind: 16 }),
+        makeApprovalRequestedEvent(2, "reviewGate", "First review"),
+        makeApprovalResolvedEvent(3, "reviewGate"),
+        makeApprovalRequestedEvent(4, "reviewGate", "Second review"),
+      ]);
+
+      const task = store.getTaskStates().get("reviewGate")!;
+      expect(task.status).toBe("waiting_approval");
+      expect(task.approvalRequest?.prompt).toBe("Second review");
+      expect(task.approvalResolution).toBeNull();
+    });
+  });
+
+  // Child gates are surfaced snapshot-only (no approval_requested event for
+  // agent_call tasks) — the parent task's waiting_approval state is DERIVED
+  // from the child phase carried on agent_call_progress events. These tests
+  // pin every transition of that derivation (D-T02-14).
+  describe("deriveTaskStates — child-gate derivation from agent_call_progress", () => {
+    const AGENT_CALL = { taskKind: WorkflowTaskKind.agent_call };
+
+    /** A running agent_call task bound to its child — the common arrange. */
+    function runningAgentCall(store: WorkflowExecutionEventStore, task = "call-helper") {
+      store.appendEvents([
+        makeTaskStartedEvent(1, task, AGENT_CALL),
+        makeAgentCallStartedEvent(2, task),
+      ]);
+    }
+
+    it("child phase WAITING_FOR_APPROVAL gates a running task", () => {
+      const store = new WorkflowExecutionEventStore();
+      runningAgentCall(store);
+      store.appendEvents([
+        makeAgentCallProgressEvent(3, "call-helper", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+      ]);
+
+      const task = store.getTaskStates().get("call-helper")!;
+      expect(task.status).toBe("waiting_approval");
+      // The status flip must not drop the merged progress fields.
+      expect(task.childExecutionId).toBe("aex_child_1");
+      expect(task.agentSlug).toBe("helper");
+    });
+
+    it("child phase IN_PROGRESS un-gates a waiting task (child resumed)", () => {
+      const store = new WorkflowExecutionEventStore();
+      runningAgentCall(store);
+      store.appendEvents([
+        makeAgentCallProgressEvent(3, "call-helper", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+        makeAgentCallProgressEvent(4, "call-helper", AgentExecutionPhase.EXECUTION_IN_PROGRESS),
+      ]);
+
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("running");
+    });
+
+    it("phase UNSPECIFIED never un-gates a waiting task (the orchestrator's null-progress emits carry phase 0)", () => {
+      const store = new WorkflowExecutionEventStore();
+      runningAgentCall(store);
+      store.appendEvents([
+        makeAgentCallProgressEvent(3, "call-helper", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+        makeAgentCallProgressEvent(4, "call-helper", AgentExecutionPhase.EXECUTION_PHASE_UNSPECIFIED),
+      ]);
+
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("waiting_approval");
+    });
+
+    it("non-waiting phases leave a running task running (PENDING and UNSPECIFIED are not gates)", () => {
+      const store = new WorkflowExecutionEventStore();
+      runningAgentCall(store);
+      store.appendEvents([
+        makeAgentCallProgressEvent(3, "call-helper", AgentExecutionPhase.EXECUTION_PHASE_UNSPECIFIED),
+        makeAgentCallProgressEvent(4, "call-helper", AgentExecutionPhase.EXECUTION_PENDING),
+        makeAgentCallProgressEvent(5, "call-helper", AgentExecutionPhase.EXECUTION_IN_PROGRESS),
+      ]);
+
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("running");
+    });
+
+    it("taskCompleted settles a gated task (the task's own events stay authoritative)", () => {
+      const store = new WorkflowExecutionEventStore();
+      runningAgentCall(store);
+      store.appendEvents([
+        makeAgentCallProgressEvent(3, "call-helper", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+        makeTaskCompletedEvent(4, "call-helper"),
+      ]);
+
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("completed");
+    });
+
+    it("a stale WAITING progress event cannot re-gate a settled task", () => {
+      const store = new WorkflowExecutionEventStore();
+      runningAgentCall(store);
+      store.appendEvents([
+        makeTaskCompletedEvent(3, "call-helper"),
+        makeAgentCallProgressEvent(4, "call-helper", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+      ]);
+
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("completed");
+    });
+
+    it("a WAITING progress event cannot clobber a retrying task", () => {
+      const store = new WorkflowExecutionEventStore();
+      runningAgentCall(store);
+      store.appendEvents([
+        makeTaskFailedEvent(3, "call-helper", { willRetry: true }),
+        makeAgentCallProgressEvent(4, "call-helper", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+      ]);
+
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("retrying");
+    });
+
+    it("terminal child phase on progress un-gates; task settlement follows from task events", () => {
+      const store = new WorkflowExecutionEventStore();
+      runningAgentCall(store);
+      store.appendEvents([
+        makeAgentCallProgressEvent(3, "call-helper", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+        makeAgentCallProgressEvent(4, "call-helper", AgentExecutionPhase.EXECUTION_COMPLETED),
+      ]);
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("running");
+
+      store.appendEvents([makeTaskCompletedEvent(5, "call-helper")]);
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("completed");
+    });
+
+    it("replaying a terminal history ends settled, not gated (history replay is safe)", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "call-helper", AGENT_CALL),
+        makeAgentCallStartedEvent(2, "call-helper"),
+        makeAgentCallProgressEvent(3, "call-helper", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+        makeAgentCallProgressEvent(4, "call-helper", AgentExecutionPhase.EXECUTION_IN_PROGRESS),
+        makeTaskCompletedEvent(5, "call-helper"),
+      ]);
+
+      expect(store.getTaskStates().get("call-helper")!.status).toBe("completed");
+    });
+
+    it("a progress event without a prior taskStarted is a no-op (prev is undefined)", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeAgentCallProgressEvent(1, "ghost", AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL),
+      ]);
+
+      expect(store.getTaskStates().has("ghost")).toBe(false);
     });
   });
 
@@ -277,4 +569,82 @@ describe("WorkflowExecutionEventStore", () => {
       expect(listener).toHaveBeenCalledTimes(1);
     });
   });
+
+  // T04: the truncated I/O summaries are the live preview source for the
+  // thread cards — the store must capture them, reset them correctly on
+  // retries, and keep them REFERENCE-STABLE across re-derivations (the
+  // projection's structural sharing compares them by identity).
+  describe("I/O summary capture (T04)", () => {
+    it("captures input_summary from task_started and output_summary from task_completed", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "seed", {
+          inputSummary: { variables: { order_id: "o-1" } },
+        }),
+        makeTaskCompletedEvent(2, "seed", {
+          outputSummary: { result: 42 },
+        }),
+      ]);
+
+      const state = store.getTaskStates().get("seed")!;
+      expect(state.inputSummary).toEqual({ variables: { order_id: "o-1" } });
+      expect(state.outputSummary).toEqual({ result: 42 });
+    });
+
+    it("defaults both summaries to null when the payloads omit them", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "seed"),
+        makeTaskCompletedEvent(2, "seed"),
+      ]);
+
+      const state = store.getTaskStates().get("seed")!;
+      expect(state.inputSummary).toBeNull();
+      expect(state.outputSummary).toBeNull();
+    });
+
+    it("a restart invalidates the prior attempt's output but keeps the input", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "flaky", { inputSummary: { url: "a" } }),
+        makeTaskCompletedEvent(2, "flaky", { outputSummary: { ok: true } }),
+        // The engine re-runs the task (e.g. a workflow-level replay).
+        makeTaskStartedEvent(3, "flaky", { attemptNumber: 2 }),
+      ]);
+
+      const state = store.getTaskStates().get("flaky")!;
+      expect(state.outputSummary).toBeNull();
+      expect(state.inputSummary).toEqual({ url: "a" });
+    });
+
+    it("a failure clears the output summary but keeps the input", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "doomed", { inputSummary: { url: "a" } }),
+        makeTaskFailedEvent(2, "doomed"),
+      ]);
+
+      const state = store.getTaskStates().get("doomed")!;
+      expect(state.inputSummary).toEqual({ url: "a" });
+      expect(state.outputSummary).toBeNull();
+    });
+
+    it("keeps summary references stable across re-derivations (structural-sharing contract)", () => {
+      const store = new WorkflowExecutionEventStore();
+      store.appendEvents([
+        makeTaskStartedEvent(1, "seed", { inputSummary: { a: 1 } }),
+        makeTaskCompletedEvent(2, "seed", { outputSummary: { b: 2 } }),
+      ]);
+      const before = store.getTaskStates().get("seed")!;
+
+      // A later event for ANOTHER task invalidates the cache and forces a
+      // full re-derivation; "seed" summaries must keep object identity
+      // (they are read off the same immutable stored events).
+      store.appendEvents([makeTaskStartedEvent(3, "other")]);
+      const after = store.getTaskStates().get("seed")!;
+
+      expect(after.inputSummary).toBe(before.inputSummary);
+      expect(after.outputSummary).toBe(before.outputSummary);
+    });
+  });
 });

package/src/internal/store/index.ts

@@ -21,9 +21,6 @@ export {
   type DerivedCostSummary,
 } from "./workflow-execution-event-store.js";
 
-export { SelectionStore } from "./selection-store.js";
-export type { SelectedThreadItem } from "./selection-store.js";
-
 export { WorkspaceFileSelectionStore } from "./workspace-file-selection-store.js";
 export type { SelectedWorkspaceFile } from "./workspace-file-selection-store.js";
 

package/src/internal/store/workflow-execution-event-store.ts

@@ -1,6 +1,14 @@
-import type { WorkflowExecutionEvent } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
+import type {
+  WorkflowExecutionEvent,
+  ApprovalRequestedPayload,
+  ApprovalResolvedPayload,
+} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
 import { WorkflowEventType } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
 import type { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
+import type { JsonObject } from "@bufbuild/protobuf";
+// The CHILD AgentExecution's phase enum (carried on agent_call_progress
+// payloads) — distinct from the workflow's own ExecutionPhase.
+import { ExecutionPhase as AgentExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
 // ---------------------------------------------------------------------------
 // Stream state (mirrors ConversationStore's StreamState shape)
@@ -51,6 +59,38 @@ export interface DerivedTaskState {
   readonly currentToolName: string;
   readonly messagesCount: number;
   readonly toolCallsCount: number;
+  /**
+   * Truncated resolved-input summary from `task_started` (T04). `null`
+   * until the event arrives. Reference-stable across re-derivations: the
+   * value is read off the SAME immutable stored event each walk, so
+   * downstream identity compares (structural sharing) hold.
+   */
+  readonly inputSummary: JsonObject | null;
+  /**
+   * Truncated output summary from `task_completed` (T04). `null` while
+   * running and reset on a restart. The FULL output lives on the status
+   * snapshot (`status.tasks[].output`) — this is the live-stream preview
+   * source only (the event deliberately truncates to prevent bloat).
+   */
+  readonly outputSummary: JsonObject | null;
+  /**
+   * The `approval_requested` payload for a human_input gate (T06) — the
+   * review material (prompt, outcomes, form schema, payload/artifact ref,
+   * ui hint) the gating card's in-thread review surface renders. `null`
+   * until the event arrives; reset on a restart (a new attempt re-emits
+   * its own request). Reference-stable like the summaries: the value IS
+   * the stored immutable event's payload message, so downstream identity
+   * compares (structural sharing) hold across re-derivations.
+   */
+  readonly approvalRequest: ApprovalRequestedPayload | null;
+  /**
+   * The `approval_resolved` payload once the gate is decided (T06) —
+   * reviewer, comment, wait duration. Persists through the task's
+   * remaining lifecycle (completed/failed) so the card's resolved-decision
+   * summary survives settlement; reset on a restart. Reference-stable, as
+   * above.
+   */
+  readonly approvalResolution: ApprovalResolvedPayload | null;
 }
 
 export interface DerivedCostSummary {
@@ -248,6 +288,11 @@ function deriveTaskStates(
           currentToolName: prev?.currentToolName ?? "",
           messagesCount: prev?.messagesCount ?? 0,
           toolCallsCount: prev?.toolCallsCount ?? 0,
+          inputSummary: p.value.inputSummary ?? prev?.inputSummary ?? null,
+          // A (re)start invalidates any prior attempt's output and gate.
+          outputSummary: null,
+          approvalRequest: null,
+          approvalResolution: null,
         });
         break;
 
@@ -266,6 +311,12 @@ function deriveTaskStates(
           currentToolName: "",
           messagesCount: prev?.messagesCount ?? 0,
           toolCallsCount: prev?.toolCallsCount ?? 0,
+          inputSummary: prev?.inputSummary ?? null,
+          outputSummary: p.value.outputSummary ?? null,
+          // The gate record survives settlement — the card's resolved
+          // decision summary reads it after the task completes.
+          approvalRequest: prev?.approvalRequest ?? null,
+          approvalResolution: prev?.approvalResolution ?? null,
         });
         break;
 
@@ -284,6 +335,10 @@ function deriveTaskStates(
           currentToolName: "",
           messagesCount: prev?.messagesCount ?? 0,
           toolCallsCount: prev?.toolCallsCount ?? 0,
+          inputSummary: prev?.inputSummary ?? null,
+          outputSummary: null,
+          approvalRequest: prev?.approvalRequest ?? null,
+          approvalResolution: prev?.approvalResolution ?? null,
         });
         break;
 
@@ -302,6 +357,10 @@ function deriveTaskStates(
           currentToolName: "",
           messagesCount: 0,
           toolCallsCount: 0,
+          inputSummary: null,
+          outputSummary: null,
+          approvalRequest: null,
+          approvalResolution: null,
         });
         break;
 
@@ -325,6 +384,7 @@ function deriveTaskStates(
         if (prev) {
           map.set(taskName, {
             ...prev,
+            status: deriveChildGateStatus(prev.status, p.value.agentPhase),
             childExecutionId: p.value.childExecutionId || prev.childExecutionId,
             currentToolName: p.value.currentToolName || prev.currentToolName,
             messagesCount: p.value.messagesCount || prev.messagesCount,
@@ -349,13 +409,26 @@ function deriveTaskStates(
 
       case "approvalRequested":
         if (prev) {
-          map.set(taskName, { ...prev, status: "waiting_approval" });
+          map.set(taskName, {
+            ...prev,
+            status: "waiting_approval",
+            // The stored event's payload message itself — reference-stable
+            // across re-derivations, so the gating card's memo compares hold.
+            approvalRequest: p.value,
+            approvalResolution: null,
+          });
         }
         break;
 
       case "approvalResolved":
-        if (prev && prev.status === "waiting_approval") {
-          map.set(taskName, { ...prev, status: "running" });
+        if (prev) {
+          map.set(taskName, {
+            ...prev,
+            // Only a waiting gate resumes; the resolution record is kept
+            // either way (an out-of-order event must not lose the decision).
+            status: prev.status === "waiting_approval" ? "running" : prev.status,
+            approvalResolution: p.value,
+          });
         }
         break;
     }
@@ -364,6 +437,52 @@ function deriveTaskStates(
   return map;
 }
 
+/**
+ * Derives the parent task's status from a child agent's phase on an
+ * `agent_call_progress` event — the ONLY live signal that an AGENT_CALL
+ * task is blocked on a child HITL gate.
+ *
+ * Why progress events drive gating: a child's tool/file gate is surfaced
+ * snapshot-only (`child_approval_required` signal → `status.pending_approvals`
+ * on the parent — no workflow event is emitted; source-confirmed in
+ * `test/conformance/src/suites-execution/workflowexecution-child-approval.conformance.test.ts`).
+ * The `approval_requested` event exists only for human_input tasks. Without
+ * this derivation the stream never shows an agent_call task as
+ * `waiting_approval`, and every waiting_approval consumer (thread/graph
+ * amber state, announcements, `useApprovalBoundary`'s snapshot refetch +
+ * gate auto-select) is blind to child gates. Deriving from the phase the
+ * progress payload already carries closes that gap with zero new events —
+ * and matches the documented task semantics
+ * (`apis/ai/stigmer/agentic/workflowexecution/docs/hitl-approvals.md`).
+ *
+ * Transition rules (deliberately narrow):
+ * - Only `running` can ENTER `waiting_approval` (child phase = WAITING).
+ * - Only `waiting_approval` can EXIT via a progress event, and only on a
+ *   KNOWN non-waiting phase. `UNSPECIFIED` is an explicit no-op: the
+ *   orchestrator's initial/fast-completion emits carry phase 0 (null
+ *   progress) and must never un-gate a blocked task.
+ * - Every other status (retrying, settled, pending) passes through — a
+ *   stale WAITING progress event can never resurrect or re-gate a task the
+ *   authoritative task_* events have already moved on.
+ */
+function deriveChildGateStatus(
+  status: DerivedTaskState["status"],
+  childPhase: AgentExecutionPhase,
+): DerivedTaskState["status"] {
+  if (status === "running") {
+    return childPhase === AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL
+      ? "waiting_approval"
+      : "running";
+  }
+  if (status === "waiting_approval") {
+    return childPhase === AgentExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL ||
+      childPhase === AgentExecutionPhase.EXECUTION_PHASE_UNSPECIFIED
+      ? "waiting_approval"
+      : "running";
+  }
+  return status;
+}
+
 function deriveCostSummary(
   events: readonly WorkflowExecutionEvent[],
 ): DerivedCostSummary {

package/src/internal/store/workspace-file-selection-store.ts

@@ -1,6 +1,4 @@
-// Which workspace file is open in the viewer. Sibling to SelectionStore (which
-// owns thread-item inspect selection) — the two are orthogonal domains with
-// different lifecycles, so they stay separate stores rather than one fused FSM.
+// Which workspace file is open in the viewer.
 
 /**
  * A file selected for viewing.
@@ -23,8 +21,7 @@ type Listener = () => void;
 /**
  * Framework-agnostic store for the currently-open workspace file.
  *
- * Implements the `useSyncExternalStore` contract identical to
- * {@link import("./selection-store.js").SelectionStore}: the context carries the
+ * Implements the `useSyncExternalStore` contract: the context carries the
  * store instance (stable ref), and `getSelection` returns the stored object
  * reference — a new object is allocated only inside `select` — so `getSnapshot`
  * never triggers a re-render loop.