@stigmer/cli 3.35.0 → 3.37.0

package/src/resources/stream/render-plaintext.test.ts

@@ -1,127 +0,0 @@
-// Tests for the plaintext renderer: AI text to data, terse status lines to
-// status, approvals auto-skipped, untracked event kinds silent.
-
-import { describe, expect, it } from "vitest";
-import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import type { StreamEvent, ToolCallInfo } from "./events.js";
-import { PlaintextRenderer } from "./render-plaintext.js";
-
-function toolInfo(overrides: Partial<ToolCallInfo> = {}): ToolCallInfo {
-  return { id: "t1", name: "read", status: "completed", result: "", error: "", durationMs: 0, ...overrides };
-}
-
-function render(events: StreamEvent[]): { data: string; status: string } {
-  let data = "";
-  let status = "";
-  const r = new PlaintextRenderer({ data: { write: (s) => void (data += s) }, status: { write: (s) => void (status += s) } });
-  for (const e of events) r.render(e);
-  return { data, status };
-}
-
-describe("PlaintextRenderer", () => {
-  it("streams AI text to data and finalizes on stream end", () => {
-    const { data } = render([
-      { kind: "aiStreamDelta", content: "Hello", subAgentId: "" },
-      { kind: "aiStreamDelta", content: " world", subAgentId: "" },
-      { kind: "aiStreamEnd", content: "Hello world", subAgentId: "", toolCalls: [] },
-    ]);
-    expect(data).toBe("Hello world\n");
-  });
-
-  it("writes tool success and failure lines to status", () => {
-    const { status } = render([
-      { kind: "toolRunning", toolCallId: "t1", subAgentId: "", toolCall: toolInfo({ status: "running" }) },
-      { kind: "toolCompleted", toolCallId: "t1", subAgentId: "", toolCall: toolInfo() },
-      { kind: "toolCompleted", toolCallId: "t2", subAgentId: "", toolCall: toolInfo({ name: "shell", error: "exploded" }) },
-    ]);
-    expect(status).toContain("⠋ read");
-    expect(status).toContain("✓ read");
-    expect(status).toContain("✗ shell: exploded");
-  });
-
-  it("titles shell status lines with the model-authored intent when present (stigmer#276)", () => {
-    const { status } = render([
-      {
-        kind: "toolRunning",
-        toolCallId: "t1",
-        subAgentId: "",
-        toolCall: toolInfo({
-          name: "execute",
-          status: "running",
-          args: { command: "npx vitest run src/parser", description: "Run unit tests for the parser" },
-        }),
-      },
-      {
-        kind: "toolCompleted",
-        toolCallId: "t1",
-        subAgentId: "",
-        toolCall: toolInfo({
-          name: "execute",
-          args: { command: "npx vitest run src/parser", description: "Run unit tests for the parser" },
-        }),
-      },
-    ]);
-    expect(status).toContain("⠋ Run unit tests for the parser");
-    expect(status).toContain("✓ Run unit tests for the parser");
-    expect(status).not.toContain("execute");
-  });
-
-  it("keeps the raw tool name when there is no intent, and never titles non-shell tools from description", () => {
-    const { status } = render([
-      {
-        kind: "toolCompleted",
-        toolCallId: "t1",
-        subAgentId: "",
-        toolCall: toolInfo({ name: "execute", args: { command: "ls" } }),
-      },
-      {
-        kind: "toolCompleted",
-        toolCallId: "t2",
-        subAgentId: "",
-        toolCall: toolInfo({
-          name: "task",
-          args: { description: "general-purpose research", prompt: "Find the docs" },
-        }),
-      },
-    ]);
-    // A task tool's description is the sub-agent subject, never a row title.
-    expect(status).toContain("✓ execute");
-    expect(status).toContain("✓ task");
-    expect(status).not.toContain("general-purpose research");
-  });
-
-  it("renders an interrupted tool with the neutral glyph, not a checkmark (issue #207)", () => {
-    const { status } = render([
-      { kind: "toolInterrupted", toolCallId: "t1", subAgentId: "", toolCall: toolInfo({ name: "shell", status: "interrupted" }) },
-    ]);
-    expect(status).toContain("⊘ shell (interrupted)");
-    expect(status).not.toContain("✓");
-  });
-
-  it("notes the auto-skip for approvals and resolves to SKIP", () => {
-    const r = new PlaintextRenderer({ data: { write: () => {} }, status: { write: () => {} } });
-    const action = r.resolveApproval({
-      kind: "approvalNeeded", toolCallId: "t1", toolName: "delete", argsPreview: "", message: "", fromSubAgent: false, subAgentName: "",
-    });
-    expect(action).toBe(ApprovalAction.SKIP);
-
-    const { status } = render([
-      { kind: "approvalNeeded", toolCallId: "t1", toolName: "delete", argsPreview: "", message: "", fromSubAgent: false, subAgentName: "" },
-    ]);
-    expect(status).toContain("Approval needed: delete (auto-skipped in non-TTY mode)");
-  });
-
-  it("renders sub-agent and context-compaction lines, stays silent on phase/done", () => {
-    const { data, status } = render([
-      { kind: "subAgentStarted", id: "s1", name: "researcher", description: "Explore code", input: "" },
-      { kind: "subAgentCompleted", id: "s1", status: "SUB_AGENT_COMPLETED", toolCount: 2, output: "" },
-      { kind: "contextCompacted", source: "graph_start", tokensBefore: 12000, tokensAfter: 6000, compressionRatio: 0.5, durationMs: 10, messagesBefore: 8, messagesAfter: 3 },
-      { kind: "phaseChange", phase: "in_progress", previous: "pending" },
-      { kind: "done", phase: "completed", error: "" },
-    ]);
-    expect(status).toContain("↳ Sub-agent: Explore code");
-    expect(status).toContain("✓ Sub-agent completed: s1");
-    expect(status).toContain("Context compacted (12K → 6K tokens)");
-    expect(data).toBe("");
-  });
-});

package/src/resources/stream/snapshot.test.ts

@@ -1,111 +0,0 @@
-// Tests for the historical-replay projection (snapshotToEvents). Stored
-// executions must yield the same event vocabulary as the live differ, with
-// `done` emitted only for the final execution.
-
-import { create } from "@bufbuild/protobuf";
-import { describe, expect, it } from "vitest";
-import {
-  AgentExecutionSchema,
-  AgentExecutionStatusSchema,
-  type AgentExecution,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
-import { AgentExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
-import {
-  AgentMessageSchema,
-  ToolCallSchema,
-  type AgentMessage,
-  type ToolCall,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
-import {
-  ExecutionPhase,
-  MessageType,
-  ToolCallStatus,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import type { StreamEvent } from "./events.js";
-import { snapshotToEvents } from "./snapshot.js";
-
-function exec(opts: {
-  message?: string;
-  phase?: ExecutionPhase;
-  messages?: AgentMessage[];
-  error?: string;
-}): AgentExecution {
-  return create(AgentExecutionSchema, {
-    spec: create(AgentExecutionSpecSchema, { message: opts.message ?? "" }),
-    status: create(AgentExecutionStatusSchema, {
-      phase: opts.phase ?? ExecutionPhase.EXECUTION_COMPLETED,
-      messages: opts.messages ?? [],
-      error: opts.error ?? "",
-    }),
-  });
-}
-
-function aiMsg(content: string): AgentMessage {
-  return create(AgentMessageSchema, { type: MessageType.MESSAGE_AI, content });
-}
-
-function systemMsg(content: string): AgentMessage {
-  return create(AgentMessageSchema, { type: MessageType.MESSAGE_SYSTEM, content });
-}
-
-function toolMsg(tc: ToolCall): AgentMessage {
-  return create(AgentMessageSchema, { type: MessageType.MESSAGE_TOOL, toolCalls: [tc], timestamp: "t1" });
-}
-
-function tool(id: string, status: ToolCallStatus): ToolCall {
-  return create(ToolCallSchema, { id, name: "read", status, startedAt: "t0" });
-}
-
-const kinds = (events: StreamEvent[]): string[] => events.map((e) => e.kind);
-
-describe("snapshotToEvents", () => {
-  it("emits the human prompt, AI text, and a terminal done for the last execution", () => {
-    const events = snapshotToEvents([exec({ message: "do it", messages: [aiMsg("done")] })]);
-    expect(kinds(events)).toEqual(["humanMessage", "aiMessage", "done"]);
-    expect(events[0]).toMatchObject({ kind: "humanMessage", content: "do it" });
-    expect(events[2]).toMatchObject({ kind: "done", phase: "completed" });
-  });
-
-  it("suppresses the 'execute' placeholder prompt", () => {
-    const events = snapshotToEvents([exec({ message: "execute", messages: [aiMsg("hi")] })]);
-    expect(kinds(events)).toEqual(["aiMessage", "done"]);
-  });
-
-  it("promotes a MESSAGE_TOOL into a stateful tool event by status", () => {
-    const events = snapshotToEvents([
-      exec({ messages: [toolMsg(tool("tc1", ToolCallStatus.TOOL_CALL_COMPLETED))] }),
-    ]);
-    expect(kinds(events)).toEqual(["toolCompleted", "done"]);
-    expect(events[0]).toMatchObject({ kind: "toolCompleted", toolCallId: "tc1" });
-  });
-
-  it("replays a platform-interrupted call as toolInterrupted — never a live running block", () => {
-    // Issue #207: before the fix an INTERRUPTED status fell through to
-    // "unknown" (non-terminal) and replayed as toolRunning, a block that never
-    // closes. It must replay as its own settled event.
-    const events = snapshotToEvents([
-      exec({
-        phase: ExecutionPhase.EXECUTION_CANCELLED,
-        messages: [toolMsg(tool("tc1", ToolCallStatus.TOOL_CALL_INTERRUPTED))],
-      }),
-    ]);
-    expect(kinds(events)).toEqual(["toolInterrupted", "done"]);
-    expect(events[0]).toMatchObject({ kind: "toolInterrupted", toolCallId: "tc1" });
-  });
-
-  it("only the final execution emits done", () => {
-    const events = snapshotToEvents([
-      exec({ message: "first", messages: [aiMsg("a")] }),
-      exec({ message: "second", messages: [aiMsg("b")] }),
-    ]);
-    expect(kinds(events)).toEqual(["humanMessage", "aiMessage", "humanMessage", "aiMessage", "done"]);
-  });
-
-  it("carries the failure phase + error into done", () => {
-    const events = snapshotToEvents([
-      exec({ phase: ExecutionPhase.EXECUTION_FAILED, error: "boom", messages: [systemMsg("context")] }),
-    ]);
-    const done = events.at(-1);
-    expect(done).toMatchObject({ kind: "done", phase: "failed", error: "boom" });
-  });
-});

package/src/resources/stream/submit.test.ts

@@ -1,77 +0,0 @@
-// Tests for approval-submit resilience: retry classification, backoff loop,
-// and stream-error message parity with Go.
-
-import { describe, expect, it } from "vitest";
-import { Code, ConnectError } from "@connectrpc/connect";
-import { classifyStreamError, isRetryableSubmitError, retryWithBackoff } from "./submit.js";
-
-const never = new AbortController().signal;
-
-describe("isRetryableSubmitError", () => {
-  it("retries transient gRPC codes", () => {
-    for (const code of [Code.Unavailable, Code.DeadlineExceeded, Code.ResourceExhausted, Code.Aborted, Code.Internal, Code.Unknown]) {
-      expect(isRetryableSubmitError(new ConnectError("x", code))).toBe(true);
-    }
-  });
-
-  it("retries FailedPrecondition only for 'no pending approvals'", () => {
-    expect(isRetryableSubmitError(new ConnectError("no pending approvals yet", Code.FailedPrecondition))).toBe(true);
-    expect(isRetryableSubmitError(new ConnectError("something else", Code.FailedPrecondition))).toBe(false);
-  });
-
-  it("does not retry permanent codes, but retries non-RPC errors", () => {
-    expect(isRetryableSubmitError(new ConnectError("nope", Code.NotFound))).toBe(false);
-    expect(isRetryableSubmitError(new ConnectError("nope", Code.InvalidArgument))).toBe(false);
-    expect(isRetryableSubmitError(new Error("socket hang up"))).toBe(true);
-  });
-});
-
-describe("retryWithBackoff", () => {
-  it("retries a retryable failure then succeeds", async () => {
-    let calls = 0;
-    await retryWithBackoff(never, 3, 1, async () => {
-      calls++;
-      if (calls < 3) throw new ConnectError("lost", Code.Unavailable);
-    });
-    expect(calls).toBe(3);
-  });
-
-  it("stops immediately on a non-retryable failure", async () => {
-    let calls = 0;
-    await expect(
-      retryWithBackoff(never, 3, 1, async () => {
-        calls++;
-        throw new ConnectError("bad", Code.InvalidArgument);
-      }),
-    ).rejects.toBeInstanceOf(ConnectError);
-    expect(calls).toBe(1);
-  });
-
-  it("gives up after maxAttempts and throws the last error", async () => {
-    let calls = 0;
-    await expect(
-      retryWithBackoff(never, 2, 1, async () => {
-        calls++;
-        throw new ConnectError("still down", Code.Unavailable);
-      }),
-    ).rejects.toBeInstanceOf(ConnectError);
-    expect(calls).toBe(2);
-  });
-});
-
-describe("classifyStreamError", () => {
-  it("maps known codes and appends a resume hint", () => {
-    const msg = classifyStreamError(new ConnectError("x", Code.Unavailable), "ses_1");
-    expect(msg).toContain("Connection to server lost.");
-    expect(msg).toContain("stigmer resume ses_1");
-  });
-
-  it("omits the resume hint when there is no session", () => {
-    const msg = classifyStreamError(new ConnectError("x", Code.DeadlineExceeded), "");
-    expect(msg).toBe("Server response timed out.");
-  });
-
-  it("falls back for non-RPC errors", () => {
-    expect(classifyStreamError(new Error("boom"), "")).toBe("Unexpected stream error: boom");
-  });
-});

package/src/resources/stream/workflow-event-view.test.ts

@@ -1,116 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import {
-  ApprovalRequestedPayloadSchema,
-  ApprovalResolvedPayloadSchema,
-  BudgetCheckpointPayloadSchema,
-  ExecutionFailedPayloadSchema,
-  TaskFailedPayloadSchema,
-  TaskRetryingPayloadSchema,
-  WorkflowExecutionEventSchema,
-  WorkflowEventType,
-} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
-import { describe, expect, it } from "vitest";
-import { toWorkflowEventView, workflowEventTypeName } from "./workflow-event-view.js";
-
-describe("workflowEventTypeName", () => {
-  it("returns the canonical proto name for the type", () => {
-    expect(workflowEventTypeName(WorkflowEventType.execution_started)).toBe("execution_started");
-    expect(workflowEventTypeName(WorkflowEventType.approval_requested)).toBe("approval_requested");
-  });
-});
-
-describe("toWorkflowEventView", () => {
-  it("formats the HH:MM:SS slice of occurred_at", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      eventType: WorkflowEventType.execution_started,
-      occurredAt: "2026-06-12T13:45:09.123Z",
-      payload: { case: "executionStarted", value: {} as never },
-    });
-    expect(toWorkflowEventView(event).time).toBe("13:45:09");
-  });
-
-  it("falls back to dashes when occurred_at is empty", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      eventType: WorkflowEventType.execution_started,
-      payload: { case: "executionStarted", value: {} as never },
-    });
-    expect(toWorkflowEventView(event).time).toBe("--------");
-  });
-
-  it("marks execution_completed/failed/cancelled/terminated as terminal", () => {
-    for (const c of ["executionCompleted", "executionCancelled", "executionTerminated"] as const) {
-      const event = create(WorkflowExecutionEventSchema, { payload: { case: c, value: {} as never } });
-      expect(toWorkflowEventView(event).terminal).toBe(true);
-    }
-    const failed = create(WorkflowExecutionEventSchema, {
-      payload: { case: "executionFailed", value: create(ExecutionFailedPayloadSchema, { error: "boom" }) },
-    });
-    const view = toWorkflowEventView(failed);
-    expect(view.terminal).toBe(true);
-    expect(view.tone).toBe("error");
-    expect(view.text).toBe("execution failed: boom");
-  });
-
-  it("does not mark task/lifecycle non-terminal events as terminal", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      taskName: "validate",
-      payload: { case: "taskStarted", value: {} as never },
-    });
-    const view = toWorkflowEventView(event);
-    expect(view.terminal).toBe(false);
-    expect(view.text).toBe("task started: validate");
-  });
-
-  it("extracts the error and task name for task_failed", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      taskName: "send",
-      payload: { case: "taskFailed", value: create(TaskFailedPayloadSchema, { error: "timeout" }) },
-    });
-    expect(toWorkflowEventView(event).text).toBe("task failed: send — timeout");
-  });
-
-  it("includes the next attempt for task_retrying", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      taskName: "send",
-      payload: { case: "taskRetrying", value: create(TaskRetryingPayloadSchema, { nextAttempt: 3 }) },
-    });
-    expect(toWorkflowEventView(event).text).toBe("task retrying: send (attempt 3)");
-  });
-
-  it("renders the prompt for approval_requested", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      taskName: "review",
-      payload: { case: "approvalRequested", value: create(ApprovalRequestedPayloadSchema, { prompt: "ok?" }) },
-    });
-    expect(toWorkflowEventView(event).text).toBe("approval requested: review — ok?");
-  });
-
-  it("renders the action and resolver for approval_resolved", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      taskName: "review",
-      payload: {
-        case: "approvalResolved",
-        value: create(ApprovalResolvedPayloadSchema, { action: ApprovalAction.APPROVE, resolvedBy: "alice" }),
-      },
-    });
-    expect(toWorkflowEventView(event).text).toBe("approval resolved: review — approve by alice");
-  });
-
-  it("converts micros to a dollar amount for budget_checkpoint", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      payload: { case: "budgetCheckpoint", value: create(BudgetCheckpointPayloadSchema, { costConsumedMicros: 1_234_500n }) },
-    });
-    expect(toWorkflowEventView(event).text).toBe("budget: $1.2345 spent");
-  });
-
-  it("falls back to a generic line for events without a dedicated view", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      eventType: WorkflowEventType.signal_received,
-      payload: { case: "signalReceived", value: {} as never },
-    });
-    const view = toWorkflowEventView(event);
-    expect(view.glyph).toBe("");
-    expect(view.text).toBe("event: signal_received");
-  });
-});

package/src/resources/stream/workflow-render.test.ts

@@ -1,81 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import {
-  ApprovalRequestedPayloadSchema,
-  ExecutionFailedPayloadSchema,
-  WorkflowExecutionEventSchema,
-  WorkflowEventType,
-} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
-import { describe, expect, it } from "vitest";
-import { renderWorkflowEventPlaintext } from "./workflow-render-plaintext.js";
-import { workflowEventToNdjson } from "./workflow-render-ndjson.js";
-
-function collect(): { sink: { write(line: string): void }; lines: string[] } {
-  const lines: string[] = [];
-  return { sink: { write: (line) => lines.push(line) }, lines };
-}
-
-describe("renderWorkflowEventPlaintext", () => {
-  it("renders a single uncolored line with timestamp, glyph, and text", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      eventType: WorkflowEventType.task_started,
-      occurredAt: "2026-06-12T13:45:09Z",
-      taskName: "validate",
-      payload: { case: "taskStarted", value: {} as never },
-    });
-    const { sink, lines } = collect();
-    renderWorkflowEventPlaintext(event, sink, false);
-    expect(lines).toEqual(["[13:45:09] → task started: validate\n"]);
-  });
-
-  it("pads the glyph column for the generic fallback line", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      eventType: WorkflowEventType.signal_received,
-      occurredAt: "2026-06-12T13:45:09Z",
-      payload: { case: "signalReceived", value: {} as never },
-    });
-    const { sink, lines } = collect();
-    renderWorkflowEventPlaintext(event, sink, false);
-    expect(lines).toEqual(["[13:45:09]    event: signal_received\n"]);
-  });
-});
-
-describe("workflowEventToNdjson", () => {
-  it("uses the canonical event type as `type` and carries the occurred_at ts", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      eventType: WorkflowEventType.execution_started,
-      occurredAt: "2026-06-12T13:45:09Z",
-      sequenceNumber: 1n,
-      payload: { case: "executionStarted", value: {} as never },
-    });
-    const env = workflowEventToNdjson(event);
-    expect(env.type).toBe("execution_started");
-    expect(env.ts).toBe("2026-06-12T13:45:09Z");
-    expect(env.payload).toEqual({ sequence: 1 });
-  });
-
-  it("surfaces salient fields and strips empty ones", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      eventType: WorkflowEventType.execution_failed,
-      occurredAt: "2026-06-12T13:45:10Z",
-      sequenceNumber: 7n,
-      payload: { case: "executionFailed", value: create(ExecutionFailedPayloadSchema, { error: "boom" }) },
-    });
-    const env = workflowEventToNdjson(event);
-    expect(env.payload).toEqual({ sequence: 7, error: "boom" });
-  });
-
-  it("includes the tool call id on approval_requested (drives interactive approval)", () => {
-    const event = create(WorkflowExecutionEventSchema, {
-      eventType: WorkflowEventType.approval_requested,
-      occurredAt: "2026-06-12T13:45:11Z",
-      sequenceNumber: 9n,
-      taskName: "review",
-      payload: {
-        case: "approvalRequested",
-        value: create(ApprovalRequestedPayloadSchema, { prompt: "ok?", toolCallId: "tc_1" }),
-      },
-    });
-    const env = workflowEventToNdjson(event);
-    expect(env.payload).toMatchObject({ task: "review", prompt: "ok?", toolCallId: "tc_1" });
-  });
-});

package/src/resources/task-configs.test.ts

@@ -1,98 +0,0 @@
-import { fromJson, type JsonValue } from "@bufbuild/protobuf";
-import { type Workflow, WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
-import {
-  WorkflowTaskKind,
-  WorkflowTaskKindSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
-import { describe, expect, it } from "vitest";
-import { decodeWorkflowTaskConfigs, TASK_CONFIG_SCHEMAS } from "./task-configs.js";
-
-function makeWorkflow(tasks: JsonValue): Workflow {
-  return fromJson(WorkflowSchema, {
-    apiVersion: "agentic.stigmer.ai/v1",
-    kind: "Workflow",
-    metadata: { name: "decode-test", org: "acme" },
-    spec: {
-      description: "task-config decode fixture",
-      document: { dsl: "1.0.0", namespace: "acme", name: "decode-test", version: "1.0.0" },
-      tasks,
-    },
-  }) as Workflow;
-}
-
-describe("TASK_CONFIG_SCHEMAS", () => {
-  // The stigmer/stigmer#353 drift class: hold the map and the proto enum to
-  // strict bidirectional equality, so a new task kind cannot ship without a
-  // CLI schema binding and a retired kind cannot linger in the map. The
-  // server-side twin of this promise is unmarshalTaskConfig's kind switch.
-  it("covers every WorkflowTaskKind exactly (bidirectional)", () => {
-    const declaredKinds = WorkflowTaskKindSchema.values
-      .map((v) => v.number as WorkflowTaskKind)
-      .filter((n) => n !== WorkflowTaskKind.workflow_task_kind_unspecified)
-      .sort((a, b) => a - b);
-    const mappedKinds = [...TASK_CONFIG_SCHEMAS.keys()].sort((a, b) => a - b);
-    expect(mappedKinds).toEqual(declaredKinds);
-  });
-});
-
-describe("decodeWorkflowTaskConfigs", () => {
-  it("rejects the string duration form a real apply rejects (the #778 repro)", () => {
-    const workflow = makeWorkflow([
-      { name: "conditional_wait", kind: "wait", task_config: { duration: "5s" } },
-    ]);
-    expect(() => decodeWorkflowTaskConfigs(workflow)).toThrow(
-      /task 'conditional_wait' \(wait\): invalid task_config/,
-    );
-  });
-
-  it("accepts the typed duration object", () => {
-    const workflow = makeWorkflow([
-      { name: "cooldown", kind: "wait", task_config: { duration: { seconds: 5 } } },
-    ]);
-    expect(() => decodeWorkflowTaskConfigs(workflow)).not.toThrow();
-  });
-
-  it("rejects unknown task_config fields, mirroring the server's strict decode", () => {
-    const workflow = makeWorkflow([
-      {
-        name: "gate",
-        kind: "human_input",
-        task_config: { prompt: "Approve?", escalation_task: "somewhere" },
-      },
-    ]);
-    expect(() => decodeWorkflowTaskConfigs(workflow)).toThrow(/gate.*human_input.*task_config/);
-  });
-
-  it("rejects values outside an enum's membership", () => {
-    const workflow = makeWorkflow([
-      {
-        name: "gate",
-        kind: "human_input",
-        task_config: { prompt: "Approve?", timeout: 60, on_timeout: "sometimes" },
-      },
-    ]);
-    expect(() => decodeWorkflowTaskConfigs(workflow)).toThrow(/gate.*invalid task_config/);
-  });
-
-  it("accepts the agent_call DSL shorthands a real apply accepts (never stricter)", () => {
-    const workflow = makeWorkflow([
-      {
-        name: "review",
-        kind: "agent_call",
-        task_config: {
-          agent: "acme/code-reviewer",
-          message: "Review ${ $context.pr.diff }",
-          harness: "cursor",
-          run_config: { model_name: "composer-2.5", service_tier: "fast" },
-          environment_refs: [{ slug: "shared-secrets" }],
-        },
-      },
-    ]);
-    expect(() => decodeWorkflowTaskConfigs(workflow)).not.toThrow();
-  });
-
-  it("skips tasks without a task_config (protovalidate territory, not decode truth)", () => {
-    const workflow = makeWorkflow([{ name: "bare", kind: "set_vars" }]);
-    expect(() => decodeWorkflowTaskConfigs(workflow)).not.toThrow();
-  });
-});