@stigmer/react 3.1.17 → 3.2.0

package/src/workflow/__tests__/derive-task-detail.test.ts

@@ -1,1265 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { fromJson } from "@bufbuild/protobuf";
-import { ValueSchema } from "@bufbuild/protobuf/wkt";
-import type { WorkflowExecutionEvent } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
-import type { WorkflowTask } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
-import type { DerivedTaskState } from "../../internal/store/workflow-execution-event-store";
-import { deriveTaskDetail } from "../execution-inspector/derive-task-detail";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEvent(
-  taskName: string,
-  seq: number,
-  occurredAt: string,
-  payload: { case: string; value: unknown },
-): WorkflowExecutionEvent {
-  return {
-    eventId: `evt-${seq}`,
-    eventType: 0,
-    sequenceNumber: BigInt(seq),
-    occurredAt,
-    taskName,
-    payload,
-    $typeName:
-      "ai.stigmer.agentic.workflowexecution.v1.WorkflowExecutionEvent",
-    $unknown: undefined,
-  } as unknown as WorkflowExecutionEvent;
-}
-
-function makeSnapshot(overrides: Partial<WorkflowTask>): WorkflowTask {
-  return {
-    taskId: "task-1",
-    taskName: "my-task",
-    taskType: 0,
-    status: 0,
-    startedAt: "",
-    completedAt: "",
-    error: "",
-    artifactIds: [],
-    costMicros: BigInt(0),
-    inputTokens: BigInt(0),
-    outputTokens: BigInt(0),
-    $typeName: "ai.stigmer.agentic.workflowexecution.v1.WorkflowTask",
-    $unknown: undefined,
-    ...overrides,
-  } as unknown as WorkflowTask;
-}
-
-function makeDerived(overrides: Partial<DerivedTaskState>): DerivedTaskState {
-  return {
-    taskName: "my-task",
-    taskKind: 0 as any,
-    status: "pending",
-    durationMs: 0,
-    costMicros: BigInt(0),
-    tokensUsed: BigInt(0),
-    attemptNumber: 1,
-    error: "",
-    childExecutionId: "",
-    agentSlug: "",
-    currentToolName: "",
-    messagesCount: 0,
-    toolCallsCount: 0,
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("deriveTaskDetail", () => {
-  // 1. Returns null when no data
-  it("returns null when no events, no snapshot, and no derived state", () => {
-    const result = deriveTaskDetail("missing-task", [], undefined, undefined);
-    expect(result).toBeNull();
-  });
-
-  it("returns null when events exist but none match the task name", () => {
-    const events = [
-      makeEvent("other-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-    ];
-    const result = deriveTaskDetail("missing-task", events, undefined, undefined);
-    expect(result).toBeNull();
-  });
-
-  // 2. Completed task with snapshot
-  it("returns a completed task detail from snapshot with startedAt/completedAt", () => {
-    const snapshot = makeSnapshot({
-      startedAt: "2026-01-01T00:00:00Z",
-      completedAt: "2026-01-01T00:00:05Z",
-    });
-    const derived = makeDerived({
-      status: "completed",
-      durationMs: 5000,
-    });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.taskName).toBe("my-task");
-    expect(result!.status).toBe("completed");
-    expect(result!.summary.startedAt).toBe("2026-01-01T00:00:00Z");
-    expect(result!.summary.completedAt).toBe("2026-01-01T00:00:05Z");
-    expect(result!.summary.durationMs).toBe(5000);
-  });
-
-  // 3. Completed task with cost and tokens from snapshot
-  it("populates cost and tokens from snapshot", () => {
-    const snapshot = makeSnapshot({
-      costMicros: BigInt(15000),
-      inputTokens: BigInt(500),
-      outputTokens: BigInt(300),
-    });
-    const derived = makeDerived({ status: "completed" });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.summary.costMicros).toBe(BigInt(15000));
-    expect(result!.summary.inputTokens).toBe(BigInt(500));
-    expect(result!.summary.outputTokens).toBe(BigInt(300));
-    expect(result!.summary.totalTokens).toBe(BigInt(800));
-  });
-
-  // 4. Input from snapshot
-  it("derives input from snapshot when snapshot.input is a JsonObject", () => {
-    const snapshot = makeSnapshot({
-      input: { prompt: "hello" } as any,
-      artifactIds: ["art-1", "art-2"],
-    });
-    const derived = makeDerived({ status: "completed" });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.input).not.toBeNull();
-    expect(result!.input!.source).toBe("snapshot");
-    expect(result!.input!.data).toEqual({ prompt: "hello" });
-    expect(result!.input!.artifactIds).toEqual(["art-1", "art-2"]);
-  });
-
-  // 5. Output from snapshot
-  it("derives output from snapshot when snapshot.output is a JsonObject", () => {
-    const snapshot = makeSnapshot({
-      output: { result: "world" } as any,
-    });
-    const derived = makeDerived({ status: "completed" });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.output).not.toBeNull();
-    expect(result!.output!.source).toBe("snapshot");
-    expect(result!.output!.data).toEqual({ result: "world" });
-  });
-
-  // 6. Input from event summary fallback
-  it("derives input from taskStarted inputSummary when snapshot has no input", () => {
-    const snapshot = makeSnapshot({});
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: {
-          taskKind: 1,
-          attemptNumber: 1,
-          inputSummary: { truncated: "input data" },
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.input).not.toBeNull();
-    expect(result!.input!.source).toBe("event-summary");
-    expect(result!.input!.data).toEqual({ truncated: "input data" });
-  });
-
-  // 7. Output from event summary fallback
-  it("derives output from taskCompleted outputSummary when snapshot has no output", () => {
-    const snapshot = makeSnapshot({});
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskCompleted",
-        value: {
-          taskKind: 1,
-          durationMs: BigInt(1000),
-          costMicros: BigInt(0),
-          tokensUsed: BigInt(0),
-          outputSummary: { answer: "42" },
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.output).not.toBeNull();
-    expect(result!.output!.source).toBe("event-summary");
-    expect(result!.output!.data).toEqual({ answer: "42" });
-  });
-
-  // 8. No input/output available
-  it("returns null for input and output when neither snapshot nor events have data", () => {
-    const snapshot = makeSnapshot({});
-    const derived = makeDerived({ status: "running" });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.input).toBeNull();
-    expect(result!.output).toBeNull();
-  });
-
-  // 9. Failed task with error
-  it("populates error detail from the latest taskFailed event", () => {
-    const derived = makeDerived({ status: "failed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:01Z", {
-        case: "taskFailed",
-        value: {
-          taskKind: 1,
-          attemptNumber: 1,
-          maxAttempts: 3,
-          willRetry: false,
-          error: "connection timeout",
-          durationMs: BigInt(1000),
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.error).not.toBeNull();
-    expect(result!.error!.message).toBe("connection timeout");
-    expect(result!.error!.attemptNumber).toBe(1);
-    expect(result!.error!.maxAttempts).toBe(3);
-    expect(result!.error!.willRetry).toBe(false);
-    expect(result!.error!.durationMs).toBe(1000);
-  });
-
-  it("uses the latest failure when multiple taskFailed events exist", () => {
-    const derived = makeDerived({ status: "failed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskFailed",
-        value: {
-          taskKind: 1,
-          attemptNumber: 1,
-          maxAttempts: 3,
-          willRetry: true,
-          error: "first error",
-          durationMs: BigInt(500),
-        },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:05Z", {
-        case: "taskFailed",
-        value: {
-          taskKind: 1,
-          attemptNumber: 2,
-          maxAttempts: 3,
-          willRetry: false,
-          error: "second error",
-          durationMs: BigInt(700),
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result!.error!.message).toBe("second error");
-    expect(result!.error!.attemptNumber).toBe(2);
-  });
-
-  // 10. Retried task
-  it("builds retry history from multiple starts, failures, and retryings", () => {
-    const derived = makeDerived({
-      status: "completed",
-      attemptNumber: 3,
-    });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:01Z", {
-        case: "taskFailed",
-        value: {
-          taskKind: 1,
-          attemptNumber: 1,
-          maxAttempts: 3,
-          willRetry: true,
-          error: "attempt 1 failed",
-          durationMs: BigInt(1000),
-        },
-      }),
-      makeEvent("my-task", 3, "2026-01-01T00:00:02Z", {
-        case: "taskRetrying",
-        value: { failedAttempt: 1, nextAttempt: 2, delayMs: BigInt(500) },
-      }),
-      makeEvent("my-task", 4, "2026-01-01T00:00:03Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 2 },
-      }),
-      makeEvent("my-task", 5, "2026-01-01T00:00:04Z", {
-        case: "taskFailed",
-        value: {
-          taskKind: 1,
-          attemptNumber: 2,
-          maxAttempts: 3,
-          willRetry: true,
-          error: "attempt 2 failed",
-          durationMs: BigInt(800),
-        },
-      }),
-      makeEvent("my-task", 6, "2026-01-01T00:00:05Z", {
-        case: "taskRetrying",
-        value: { failedAttempt: 2, nextAttempt: 3, delayMs: BigInt(1000) },
-      }),
-      makeEvent("my-task", 7, "2026-01-01T00:00:06Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 3 },
-      }),
-      makeEvent("my-task", 8, "2026-01-01T00:00:08Z", {
-        case: "taskCompleted",
-        value: {
-          taskKind: 1,
-          durationMs: BigInt(2000),
-          costMicros: BigInt(100),
-          tokensUsed: BigInt(50),
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.retries).not.toBeNull();
-    expect(result!.retries!.currentAttempt).toBe(3);
-    expect(result!.retries!.attempts).toHaveLength(3);
-
-    const [a1, a2, a3] = result!.retries!.attempts;
-
-    expect(a1.attemptNumber).toBe(1);
-    expect(a1.status).toBe("failed");
-    expect(a1.error).toBe("attempt 1 failed");
-    expect(a1.durationMs).toBe(1000);
-    expect(a1.delayBeforeMs).toBe(500);
-
-    expect(a2.attemptNumber).toBe(2);
-    expect(a2.status).toBe("failed");
-    expect(a2.error).toBe("attempt 2 failed");
-    expect(a2.durationMs).toBe(800);
-    expect(a2.delayBeforeMs).toBe(1000);
-
-    expect(a3.attemptNumber).toBe(3);
-    expect(a3.status).toBe("completed");
-    expect(a3.error).toBe("");
-    expect(a3.durationMs).toBe(2000);
-  });
-
-  it("returns null retries when only a single start and no failures", () => {
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-    ];
-    const derived = makeDerived({ status: "running" });
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.retries).toBeNull();
-  });
-
-  // 11. Agent call task — full lifecycle
-  it("builds agentCall from agentCallStarted + agentCallProgress + agentCallCompleted", () => {
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "agentCallStarted",
-        value: {
-          childExecutionId: "exec-child-1",
-          agentSlug: "my-agent",
-          messageSummary: "summarized",
-        },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:01Z", {
-        case: "agentCallProgress",
-        value: {
-          childExecutionId: "exec-child-1",
-          agentPhase: 2,
-          currentToolName: "web-search",
-          tokensConsumed: BigInt(1000),
-          messagesCount: 5,
-          toolCallsCount: 3,
-        },
-      }),
-      makeEvent("my-task", 3, "2026-01-01T00:00:05Z", {
-        case: "agentCallCompleted",
-        value: {
-          durationMs: BigInt(5000),
-          tokensConsumed: BigInt(2000),
-          costMicros: BigInt(500),
-          error: "",
-          agentPhase: 3,
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.agentCall).not.toBeNull();
-    expect(result!.agentCall!.childExecutionId).toBe("exec-child-1");
-    expect(result!.agentCall!.agentSlug).toBe("my-agent");
-    expect(result!.agentCall!.agentPhase).toBe("3");
-    expect(result!.agentCall!.messagesCount).toBe(5);
-    expect(result!.agentCall!.toolCallsCount).toBe(3);
-    expect(result!.agentCall!.tokensConsumed).toBe(BigInt(2000));
-    expect(result!.agentCall!.costMicros).toBe(BigInt(500));
-    expect(result!.agentCall!.error).toBe("");
-    expect(result!.agentCall!.currentToolName).toBe("web-search");
-  });
-
-  // 12. Agent call without completion
-  it("builds partial agentCall from agentCallStarted + agentCallProgress only", () => {
-    const derived = makeDerived({ status: "running" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "agentCallStarted",
-        value: {
-          childExecutionId: "exec-child-2",
-          agentSlug: "partial-agent",
-          messageSummary: "",
-        },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:01Z", {
-        case: "agentCallProgress",
-        value: {
-          childExecutionId: "exec-child-2",
-          agentPhase: 1,
-          currentToolName: "file-read",
-          tokensConsumed: BigInt(750),
-          messagesCount: 2,
-          toolCallsCount: 1,
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.agentCall).not.toBeNull();
-    expect(result!.agentCall!.childExecutionId).toBe("exec-child-2");
-    expect(result!.agentCall!.agentSlug).toBe("partial-agent");
-    expect(result!.agentCall!.agentPhase).toBe("1");
-    expect(result!.agentCall!.tokensConsumed).toBe(BigInt(750));
-    expect(result!.agentCall!.costMicros).toBe(BigInt(0));
-    expect(result!.agentCall!.error).toBe("");
-    expect(result!.agentCall!.currentToolName).toBe("file-read");
-  });
-
-  it("uses childExecutionId from agentCallProgress when agentCallStarted has empty ID", () => {
-    const derived = makeDerived({ status: "running" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "agentCallStarted",
-        value: {
-          childExecutionId: "",
-          agentSlug: "my-agent",
-          messageSummary: "",
-        },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:01Z", {
-        case: "agentCallProgress",
-        value: {
-          childExecutionId: "aex_late_arrival",
-          agentPhase: 1,
-          currentToolName: "web-search",
-          tokensConsumed: BigInt(500),
-          messagesCount: 3,
-          toolCallsCount: 1,
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-    expect(result!.agentCall).not.toBeNull();
-    expect(result!.agentCall!.childExecutionId).toBe("aex_late_arrival");
-    expect(result!.agentCall!.agentSlug).toBe("my-agent");
-    expect(result!.agentCall!.currentToolName).toBe("web-search");
-  });
-
-  it("returns null agentCall when no agentCallStarted event exists", () => {
-    const derived = makeDerived({ status: "running" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-    expect(result!.agentCall).toBeNull();
-  });
-
-  // 12b. Snapshot metadata fallback — when agent_call events are missing
-  // (e.g., transient emission failure) but the task snapshot metadata
-  // contains agent_execution_id, buildAgentCall() falls back to it.
-  it("builds agentCall from snapshot metadata when no agent events exist (fallback path)", () => {
-    const snapshot = makeSnapshot({
-      taskName: "my-task",
-      metadata: { agent_execution_id: "aex_01abc123", token_attribution: "total_only", tool_call_count: 7 } as any,
-    });
-    const derived = makeDerived({
-      status: "completed",
-      taskKind: 13 as any, // WorkflowTaskKind.agent_call
-    });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 13, attemptNumber: 1 },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:01:00Z", {
-        case: "taskCompleted",
-        value: {
-          taskKind: 13,
-          durationMs: BigInt(60000),
-          costMicros: BigInt(5000),
-          tokensUsed: BigInt(10000),
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result!.agentCall).not.toBeNull();
-    expect(result!.agentCall!.childExecutionId).toBe("aex_01abc123");
-    expect(result!.agentCall!.toolCallsCount).toBe(7);
-  });
-
-  it("returns null agentCall for non-agent tasks even when snapshot has metadata", () => {
-    const snapshot = makeSnapshot({
-      taskName: "my-task",
-      metadata: { some_key: "some_value" } as any,
-    });
-    const derived = makeDerived({
-      status: "completed",
-      taskKind: 3 as any, // http_call
-    });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 3, attemptNumber: 1 },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:01:00Z", {
-        case: "taskCompleted",
-        value: {
-          taskKind: 3,
-          durationMs: BigInt(500),
-          costMicros: BigInt(0),
-          tokensUsed: BigInt(0),
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-    expect(result!.agentCall).toBeNull();
-  });
-
-  // 13. Approval requested
-  it("populates approval from approvalRequested event", () => {
-    const derived = makeDerived({ status: "waiting_approval" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Deploy to production?",
-          approvers: ["admin@co.com", "lead@co.com"],
-          timeoutSeconds: 3600,
-          outcomes: [
-            { name: "approve", label: "Approve" },
-            { name: "reject", label: "Reject" },
-          ],
-          formSchema: { type: "object" },
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.approval).not.toBeNull();
-    expect(result!.approval!.prompt).toBe("Deploy to production?");
-    expect(result!.approval!.approvers).toEqual(["admin@co.com", "lead@co.com"]);
-    expect(result!.approval!.outcomes).toEqual([
-      { name: "approve", label: "Approve" },
-      { name: "reject", label: "Reject" },
-    ]);
-    expect(result!.approval!.formSchema).toEqual({ type: "object" });
-    expect(result!.approval!.timeoutSeconds).toBe(3600);
-    expect(result!.approval!.decision).toBeNull();
-  });
-
-  // 13b. Review payload fields (issue #234)
-  it("unwraps an inline review payload with ui_hint from the approvalRequested event", () => {
-    const derived = makeDerived({ status: "waiting_approval" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Review the draft",
-          approvers: [],
-          timeoutSeconds: 0,
-          outcomes: [],
-          formSchema: null,
-          // Real events carry a google.protobuf.Value message.
-          payload: fromJson(ValueSchema, { title: "Q3 plan", items: [1, 2] }),
-          uiHint: "plan-review",
-          payloadArtifactId: "",
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result!.approval!.payload).toEqual({ title: "Q3 plan", items: [1, 2] });
-    expect(result!.approval!.uiHint).toBe("plan-review");
-    expect(result!.approval!.payloadArtifactId).toBeNull();
-  });
-
-  it("carries the artifact reference instead of inline data for promoted payloads", () => {
-    const derived = makeDerived({ status: "waiting_approval" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Review the proposal",
-          approvers: [],
-          timeoutSeconds: 0,
-          outcomes: [],
-          formSchema: null,
-          payload: undefined,
-          uiHint: "infra-proposal",
-          payloadArtifactId: "art_review123",
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result!.approval!.payload).toBeNull();
-    expect(result!.approval!.uiHint).toBe("infra-proposal");
-    expect(result!.approval!.payloadArtifactId).toBe("art_review123");
-  });
-
-  it("defaults review payload fields when the gate carries none (pre-#234 events)", () => {
-    const derived = makeDerived({ status: "waiting_approval" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Continue?",
-          approvers: [],
-          timeoutSeconds: 0,
-          outcomes: [],
-          formSchema: null,
-          uiHint: "",
-          payloadArtifactId: "",
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result!.approval!.payload).toBeNull();
-    expect(result!.approval!.uiHint).toBe("");
-    expect(result!.approval!.payloadArtifactId).toBeNull();
-  });
-
-  // 14. Approval resolved — event-only (the brief "finalizing" window before
-  // the task-output snapshot reflects the decision)
-  it("populates approval decision from the event when the task output is not yet available", () => {
-    const derived = makeDerived({ status: "running" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Deploy?",
-          approvers: ["admin"],
-          timeoutSeconds: 60,
-          outcomes: [{ name: "approve", label: "Approve" }],
-          formSchema: null,
-        },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:30Z", {
-        case: "approvalResolved",
-        value: {
-          action: 1,
-          resolvedBy: "admin",
-          comment: "from event",
-          waitDurationMs: BigInt(30000),
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result!.approval).not.toBeNull();
-    expect(result!.approval!.decision).not.toBeNull();
-    // No task output snapshot yet: outcome is empty (consumers show a
-    // "finalizing" affordance), reviewer/comment come from the event.
-    expect(result!.approval!.decision!.outcome).toBe("");
-    expect(result!.approval!.decision!.reviewer).toBe("admin");
-    expect(result!.approval!.decision!.comment).toBe("from event");
-    expect(result!.approval!.decision!.waitDurationMs).toBe(30000);
-    expect(result!.approval!.decision!.formData).toBeNull();
-    expect(result!.approval!.decision!.autoResolved).toBe(false);
-  });
-
-  // 14b. Approval resolved — sourced from the canonical task-output record
-  it("sources the approval decision from the task-output snapshot", () => {
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Deploy?",
-          approvers: ["admin"],
-          timeoutSeconds: 60,
-          outcomes: [{ name: "approve", label: "Approve Plan" }],
-          formSchema: null,
-        },
-      }),
-    ];
-    const snapshot = makeSnapshot({
-      output: {
-        outcome: "approve",
-        reviewer: "alice",
-        responded_at: "2026-01-01T00:00:45Z",
-        comment: "ship it",
-        form_data: { feedback: "great plan" },
-      } as unknown as WorkflowTask["output"],
-    });
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result!.approval!.decision).not.toBeNull();
-    expect(result!.approval!.decision!.outcome).toBe("approve");
-    expect(result!.approval!.decision!.reviewer).toBe("alice");
-    expect(result!.approval!.decision!.respondedAt).toBe("2026-01-01T00:00:45Z");
-    expect(result!.approval!.decision!.comment).toBe("ship it");
-    expect(result!.approval!.decision!.formData).toEqual({ feedback: "great plan" });
-  });
-
-  // 14c. Snapshot wins over event for overlapping fields
-  it("prefers the task-output snapshot over the event for overlapping fields", () => {
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Deploy?",
-          approvers: [],
-          timeoutSeconds: 0,
-          outcomes: [],
-          formSchema: null,
-        },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:30Z", {
-        case: "approvalResolved",
-        value: {
-          action: 1,
-          resolvedBy: "bot",
-          comment: "from event",
-          waitDurationMs: BigInt(12000),
-        },
-      }),
-    ];
-    const snapshot = makeSnapshot({
-      output: {
-        outcome: "approve",
-        reviewer: "alice",
-        comment: "from snapshot",
-      } as unknown as WorkflowTask["output"],
-    });
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result!.approval!.decision!.outcome).toBe("approve");
-    expect(result!.approval!.decision!.reviewer).toBe("alice"); // snapshot wins
-    expect(result!.approval!.decision!.comment).toBe("from snapshot"); // snapshot wins
-    expect(result!.approval!.decision!.waitDurationMs).toBe(12000); // event fills the gap
-  });
-
-  // 14d. Auto-resolved + ignores internal routing keys
-  it("reads auto_resolved and ignores internal keys in the task output", () => {
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Deploy?",
-          approvers: [],
-          timeoutSeconds: 0,
-          outcomes: [],
-          formSchema: null,
-        },
-      }),
-    ];
-    const snapshot = makeSnapshot({
-      output: {
-        outcome: "approve",
-        auto_resolved: true,
-        __flow_directive__: "gatherMore",
-      } as unknown as WorkflowTask["output"],
-    });
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result!.approval!.decision!.outcome).toBe("approve");
-    expect(result!.approval!.decision!.autoResolved).toBe(true);
-  });
-
-  it("returns null approval when no approvalRequested event exists", () => {
-    const derived = makeDerived({ status: "running" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-    expect(result!.approval).toBeNull();
-  });
-
-  // 15. Skipped task
-  it("handles skipped task with taskSkipped event", () => {
-    const derived = makeDerived({ status: "skipped" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskSkipped",
-        value: { taskKind: 2, reason: "condition not met" },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.status).toBe("skipped");
-    expect(result!.error).toBeNull();
-  });
-
-  // 16. Waiting approval status
-  it("reflects waiting_approval status from derived state", () => {
-    const derived = makeDerived({ status: "waiting_approval" });
-
-    const result = deriveTaskDetail("my-task", [], undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.status).toBe("waiting_approval");
-  });
-
-  // 17. Event log filtering
-  it("filters eventLog to only contain events for the given task", () => {
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-      makeEvent("other-task", 2, "2026-01-01T00:00:01Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-      makeEvent("my-task", 3, "2026-01-01T00:00:02Z", {
-        case: "taskCompleted",
-        value: {
-          taskKind: 1,
-          durationMs: BigInt(2000),
-          costMicros: BigInt(0),
-          tokensUsed: BigInt(0),
-        },
-      }),
-    ];
-    const derived = makeDerived({ status: "completed" });
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.eventLog).toHaveLength(2);
-    expect(result!.eventLog.every((e) => e.taskName === "my-task")).toBe(true);
-  });
-
-  // 18. Summary prefers snapshot for tokens (split)
-  it("uses snapshot inputTokens + outputTokens when both are available", () => {
-    const snapshot = makeSnapshot({
-      inputTokens: BigInt(200),
-      outputTokens: BigInt(300),
-    });
-    const derived = makeDerived({
-      status: "completed",
-      tokensUsed: BigInt(999),
-    });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.summary.inputTokens).toBe(BigInt(200));
-    expect(result!.summary.outputTokens).toBe(BigInt(300));
-    expect(result!.summary.totalTokens).toBe(BigInt(500));
-  });
-
-  // 19. Summary falls back to derived tokens
-  it("uses derived.tokensUsed as totalTokens when snapshot has zero tokens", () => {
-    const snapshot = makeSnapshot({
-      inputTokens: BigInt(0),
-      outputTokens: BigInt(0),
-    });
-    const derived = makeDerived({
-      status: "completed",
-      tokensUsed: BigInt(1234),
-    });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.summary.inputTokens).toBe(BigInt(0));
-    expect(result!.summary.outputTokens).toBe(BigInt(0));
-    expect(result!.summary.totalTokens).toBe(BigInt(1234));
-  });
-
-  // ---------------------------------------------------------------------------
-  // Additional edge-case coverage
-  // ---------------------------------------------------------------------------
-
-  it("derives taskKind from derived state over events", () => {
-    const derived = makeDerived({ taskKind: 5 as any });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 3, attemptNumber: 1 },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.taskKind).toBe(5);
-  });
-
-  it("falls back to event taskKind when derived state is undefined", () => {
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 7, attemptNumber: 1 },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, undefined);
-
-    expect(result).not.toBeNull();
-    expect(result!.taskKind).toBe(7);
-  });
-
-  it("defaults taskKind to unspecified (0) when no source provides it", () => {
-    const snapshot = makeSnapshot({});
-    const result = deriveTaskDetail("my-task", [], snapshot, undefined);
-
-    expect(result).not.toBeNull();
-    expect(result!.taskKind).toBe(0);
-  });
-
-  it("defaults status to pending when derivedState is undefined", () => {
-    const snapshot = makeSnapshot({});
-    const result = deriveTaskDetail("my-task", [], snapshot, undefined);
-
-    expect(result!.status).toBe("pending");
-  });
-
-  it("takes startedAt from events when snapshot has no startedAt", () => {
-    const snapshot = makeSnapshot({ startedAt: "" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T12:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-    ];
-    const derived = makeDerived({ status: "running" });
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result!.summary.startedAt).toBe("2026-01-01T12:00:00Z");
-  });
-
-  it("prefers snapshot costMicros over derived costMicros", () => {
-    const snapshot = makeSnapshot({ costMicros: BigInt(999) });
-    const derived = makeDerived({
-      status: "completed",
-      costMicros: BigInt(111),
-    });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-
-    expect(result!.summary.costMicros).toBe(BigInt(999));
-  });
-
-  it("falls back to derived costMicros when snapshot has none", () => {
-    const derived = makeDerived({
-      status: "completed",
-      costMicros: BigInt(222),
-    });
-
-    const result = deriveTaskDetail("my-task", [], undefined, derived);
-
-    expect(result!.summary.costMicros).toBe(BigInt(222));
-  });
-
-  it("takes attemptNumber from derived over events", () => {
-    const derived = makeDerived({ attemptNumber: 4 });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:01Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 2 },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-
-    expect(result!.summary.attemptNumber).toBe(4);
-  });
-
-  it("falls back to event start count for attemptNumber when derived is undefined", () => {
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:01Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 2 },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, undefined);
-
-    expect(result!.summary.attemptNumber).toBe(2);
-  });
-
-  it("snapshot input with empty object is treated as no input", () => {
-    const snapshot = makeSnapshot({
-      input: {} as any,
-    });
-    const derived = makeDerived({ status: "completed" });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-    expect(result!.input).toBeNull();
-  });
-
-  it("snapshot output with empty object is treated as no output", () => {
-    const snapshot = makeSnapshot({
-      output: {} as any,
-    });
-    const derived = makeDerived({ status: "completed" });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, derived);
-    expect(result!.output).toBeNull();
-  });
-
-  it("handles approval with no formSchema", () => {
-    const derived = makeDerived({ status: "waiting_approval" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "approvalRequested",
-        value: {
-          prompt: "Continue?",
-          approvers: [],
-          timeoutSeconds: 0,
-          outcomes: [],
-          formSchema: undefined,
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-    expect(result!.approval).not.toBeNull();
-    expect(result!.approval!.formSchema).toBeNull();
-    expect(result!.approval!.outcomes).toEqual([]);
-    expect(result!.approval!.decision).toBeNull();
-  });
-
-  it("only returns a non-null result when snapshot alone is provided", () => {
-    const snapshot = makeSnapshot({ startedAt: "2026-01-01T00:00:00Z" });
-
-    const result = deriveTaskDetail("my-task", [], snapshot, undefined);
-
-    expect(result).not.toBeNull();
-    expect(result!.taskName).toBe("my-task");
-    expect(result!.status).toBe("pending");
-    expect(result!.summary.startedAt).toBe("2026-01-01T00:00:00Z");
-  });
-
-  it("only returns a non-null result when derived state alone is provided", () => {
-    const derived = makeDerived({ status: "running", durationMs: 1500 });
-
-    const result = deriveTaskDetail("my-task", [], undefined, derived);
-
-    expect(result).not.toBeNull();
-    expect(result!.taskName).toBe("my-task");
-    expect(result!.status).toBe("running");
-    expect(result!.summary.durationMs).toBe(1500);
-  });
-
-  it("only returns a non-null result when matching events alone are provided", () => {
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, undefined);
-
-    expect(result).not.toBeNull();
-    expect(result!.taskName).toBe("my-task");
-    expect(result!.status).toBe("pending");
-  });
-
-  it("returns error as null when no taskFailed events exist", () => {
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: { taskKind: 1, attemptNumber: 1 },
-      }),
-    ];
-    const derived = makeDerived({ status: "running" });
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-    expect(result!.error).toBeNull();
-  });
-
-  it("agent call phase falls back to progress phase when completed has no phase", () => {
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "agentCallStarted",
-        value: {
-          childExecutionId: "exec-1",
-          agentSlug: "agent-x",
-          messageSummary: "",
-        },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:01Z", {
-        case: "agentCallProgress",
-        value: {
-          childExecutionId: "",
-          agentPhase: 4,
-          currentToolName: "grep",
-          tokensConsumed: BigInt(100),
-          messagesCount: 1,
-          toolCallsCount: 1,
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-    expect(result!.agentCall!.agentPhase).toBe("4");
-  });
-
-  it("agent call with error from completion", () => {
-    const derived = makeDerived({ status: "failed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "agentCallStarted",
-        value: {
-          childExecutionId: "exec-err",
-          agentSlug: "agent-y",
-          messageSummary: "",
-        },
-      }),
-      makeEvent("my-task", 2, "2026-01-01T00:00:05Z", {
-        case: "agentCallCompleted",
-        value: {
-          durationMs: BigInt(5000),
-          tokensConsumed: BigInt(0),
-          costMicros: BigInt(0),
-          error: "agent crashed",
-          agentPhase: 0,
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, undefined, derived);
-    expect(result!.agentCall!.error).toBe("agent crashed");
-  });
-
-  it("input prefers snapshot data over event summary when both exist", () => {
-    const snapshot = makeSnapshot({
-      input: { full: "data" } as any,
-      artifactIds: ["a1"],
-    });
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskStarted",
-        value: {
-          taskKind: 1,
-          attemptNumber: 1,
-          inputSummary: { truncated: "summary" },
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result!.input!.source).toBe("snapshot");
-    expect(result!.input!.data).toEqual({ full: "data" });
-    expect(result!.input!.summary).toEqual({ truncated: "summary" });
-    expect(result!.input!.artifactIds).toEqual(["a1"]);
-  });
-
-  it("output prefers snapshot data over event summary when both exist", () => {
-    const snapshot = makeSnapshot({
-      output: { full: "result" } as any,
-    });
-    const derived = makeDerived({ status: "completed" });
-    const events = [
-      makeEvent("my-task", 1, "2026-01-01T00:00:00Z", {
-        case: "taskCompleted",
-        value: {
-          taskKind: 1,
-          durationMs: BigInt(100),
-          costMicros: BigInt(0),
-          tokensUsed: BigInt(0),
-          outputSummary: { summary: "brief" },
-        },
-      }),
-    ];
-
-    const result = deriveTaskDetail("my-task", events, snapshot, derived);
-
-    expect(result!.output!.source).toBe("snapshot");
-    expect(result!.output!.data).toEqual({ full: "result" });
-    expect(result!.output!.summary).toEqual({ summary: "brief" });
-  });
-});