@stigmer/runner 3.15.3-dev.20260914121148 → 3.16.0

package/src/activities/execute-deep-agent/__tests__/translator.test.ts

@@ -0,0 +1,505 @@
+/**
+ * The native translator's own arms (`execute-deep-agent/translator.ts`): one
+ * raw LangGraph v3 protocol event in, the `TranscriptEvent`s out. Two layers,
+ * tested apart: `normalize`, the stateless core that reads the wire's shape
+ * (root-scoped, unattributed), and `DeepAgentTranslator`, which lays scope
+ * and the gate's answers on top and speaks a sub-agent's lifecycle.
+ * Beside them, what `usageOf` reads off the same wire for the loop.
+ * The events the wire carries and the transcript does not
+ * (`lifecycle`, `provider`, the standalone `usage`) are pinned as producing
+ * NOTHING, so a member cannot creep back into the union unnoticed.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { DeepAgentTranslator, normalize, usageOf } from "../translator.js";
+import {
+  resetSeq,
+  makeProtocolEvent,
+  makeMessageStart,
+  makeMessageFinish,
+  makeTextDelta,
+  makeReasoningDelta,
+  makeToolCallArgDelta,
+  makeToolStarted,
+  makeToolFinished,
+  makeToolError,
+  makeToolOutputDelta,
+  makeUsageEvent,
+  makeProviderEvent,
+  makeLifecycleRunning,
+  makeLifecycleCompleted,
+  makeContentBlockStartText,
+  makeContentBlockFinish,
+  makeCheckpointEvent,
+  makeTasksEvent,
+  makeValuesEvent,
+  makeUpdatesEvent,
+} from "../__test-utils__/v3-event-fixtures.js";
+
+beforeEach(() => resetSeq());
+
+describe("V3ProtocolNormalizer", () => {
+
+  // ── Message channel ──────────────────────────────────────────────
+
+  describe("messages channel", () => {
+    it("normalizes message-start to the run id alone (the wire's message id is not a transcript fact)", () => {
+      const result = normalize(makeMessageStart("run-1", { messageId: "msg_abc" }));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ kind: "message_start", runId: "run-1" });
+    });
+
+    it("normalizes text-delta", () => {
+      const result = normalize(makeTextDelta("run-1", "Hello "));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        kind: "text_delta",
+        runId: "run-1",
+        text: "Hello ",
+      });
+    });
+
+    it("normalizes reasoning-delta", () => {
+      const result = normalize(makeReasoningDelta("run-1", "Let me think..."));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        kind: "reasoning_delta",
+        runId: "run-1",
+        text: "Let me think...",
+      });
+    });
+
+    it("normalizes tool_call_chunk via block-delta", () => {
+      const result = normalize(makeToolCallArgDelta("run-1", "toolu_123", '{"path":'));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        kind: "tool_arg_delta",
+        callId: "toolu_123",
+        argsChunk: '{"path":',
+      });
+    });
+
+    it("normalizes message-finish to the run id alone — its usage and reason are the loop's, not the transcript's", () => {
+      const result = normalize(makeMessageFinish("run-1", {
+        reason: "end_turn",
+        usage: { input_tokens: 100, output_tokens: 20, total_tokens: 120 },
+      }));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ kind: "message_finish", runId: "run-1" });
+    });
+
+    it("emits nothing for the standalone usage event", () => {
+      expect(normalize(makeUsageEvent("run-1", { input_tokens: 50, output_tokens: 10 }))).toHaveLength(0);
+    });
+
+    it("emits nothing for the provider event", () => {
+      expect(normalize(makeProviderEvent("run-1", "anthropic", "claude-sonnet-4-6"))).toHaveLength(0);
+    });
+
+    it("returns empty for content-block-start", () => {
+      const result = normalize(makeContentBlockStartText("run-1"));
+      expect(result).toHaveLength(0);
+    });
+
+    it("returns empty for content-block-finish", () => {
+      const result = normalize(makeContentBlockFinish("run-1"));
+      expect(result).toHaveLength(0);
+    });
+
+    it("ignores empty text-delta", () => {
+      const result = normalize(makeTextDelta("run-1", ""));
+      expect(result).toHaveLength(0);
+    });
+
+    it("ignores empty reasoning-delta", () => {
+      const result = normalize(makeReasoningDelta("run-1", ""));
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  // ── Tools channel ────────────────────────────────────────────────
+
+  describe("tools channel", () => {
+    it("normalizes tool-started with snake_case fields", () => {
+      const result = normalize(makeToolStarted("toolu_abc", "read_file", '{"path":"/src/main.ts"}'));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        kind: "tool_started",
+        callId: "toolu_abc",
+        name: "read_file",
+        input: { path: "/src/main.ts" },
+      });
+    });
+
+    it("normalizes tool-started with camelCase fields", () => {
+      const event = makeProtocolEvent("tools", {
+        event: "tool-started",
+        toolCallId: "toolu_abc",
+        toolName: "read_file",
+        input: { path: "/src/main.ts" },
+      }, { namespace: ["tools:toolu_abc"] });
+      const result = normalize(event);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        kind: "tool_started",
+        callId: "toolu_abc",
+        name: "read_file",
+      });
+    });
+
+    it("normalizes tool-finished to the row's result string", () => {
+      const result = normalize(makeToolFinished("toolu_abc", "file content here"));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        kind: "tool_finished",
+        callId: "toolu_abc",
+        result: "file content here",
+      });
+    });
+
+    it("normalizes tool-error", () => {
+      const result = normalize(makeToolError("toolu_abc", "permission denied"));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        kind: "tool_error",
+        callId: "toolu_abc",
+        message: "permission denied",
+      });
+    });
+
+    it("normalizes tool-output-delta", () => {
+      const result = normalize(makeToolOutputDelta("toolu_abc", "partial output"));
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        kind: "tool_output_delta",
+        callId: "toolu_abc",
+        delta: "partial output",
+      });
+    });
+
+    it("parses string JSON input into object", () => {
+      const result = normalize(makeToolStarted("toolu_abc", "think", '{"thought":"test"}'));
+      expect(result[0]).toMatchObject({
+        kind: "tool_started",
+        input: { thought: "test" },
+      });
+    });
+
+    it("handles malformed JSON input gracefully", () => {
+      const result = normalize(makeToolStarted("toolu_abc", "think", "not json"));
+      expect(result[0]).toMatchObject({
+        kind: "tool_started",
+        input: {},
+      });
+    });
+  });
+
+  // ── The tool result: the engine's envelope, rendered here ──
+
+  describe("tool-finished output → result string", () => {
+    // Image/mixed content blocks (e.g. a computer-use screenshot). The result
+    // must be the BLOCKS ARRAY serialized — not the LangChain envelope around
+    // it — so the persist-time offload can detect the image and lift it into
+    // a renderable ToolCallOutputRef.
+    const imageBlock = { type: "image_url", image_url: { url: "data:image/png;base64,AAAA" } };
+    const resultOf = (output: unknown): string => {
+      const [event] = normalize(makeToolFinished("toolu_x", output));
+      if (event?.kind !== "tool_finished") throw new Error("expected one tool_finished");
+      return event.result;
+    };
+    const envelope = (content: unknown) => ({
+      lc: 1,
+      type: "constructor",
+      id: ["langchain_core", "messages", "ToolMessage"],
+      kwargs: { status: "success", content },
+    });
+
+    it("passes a plain string output through unchanged", () => {
+      expect(resultOf("just text")).toBe("just text");
+    });
+
+    it("unwraps a ToolMessage envelope to its text content", () => {
+      expect(resultOf(envelope("hello"))).toBe("hello");
+    });
+
+    it("serializes the blocks array (not the envelope) when the content is an array", () => {
+      const result = resultOf(envelope([{ type: "text", text: "shot" }, imageBlock]));
+      expect(JSON.parse(result)).toEqual([{ type: "text", text: "shot" }, imageBlock]);
+      expect(result).not.toContain("constructor");
+      expect(result).not.toContain("langchain_core");
+    });
+
+    it("serializes the blocks array on a live ToolMessage-shaped object (obj.content)", () => {
+      expect(JSON.parse(resultOf({ content: [imageBlock] }))).toEqual([imageBlock]);
+    });
+
+    it("falls back to JSON.stringify for unrecognized shapes", () => {
+      expect(resultOf({ foo: "bar" })).toBe(JSON.stringify({ foo: "bar" }));
+    });
+
+    // Since #1097: a state-mutating tool (deepagents' write_todos,
+    // task) returns a LangGraph Command with its ToolMessage nested in the
+    // update; the row shows that message's content, never the whole Command.
+    it("unwraps a LangGraph Command to its ToolMessage's content", () => {
+      const command = {
+        lg_name: "Command",
+        update: {
+          todos: [{ content: "Read the fixture", status: "pending" }],
+          messages: [envelope("Updated todo list to [...]")],
+        },
+        goto: [],
+      };
+      expect(resultOf(command)).toBe("Updated todo list to [...]");
+    });
+
+    it("unwraps a Command whose ToolMessage carries a blocks array to the array (the task tool's shape)", () => {
+      const command = { lg_name: "Command", update: { files: {}, messages: [envelope([{ type: "text", text: "forty-two" }])] }, goto: [] };
+      expect(JSON.parse(resultOf(command))).toEqual([{ type: "text", text: "forty-two" }]);
+    });
+
+    it("reads the LAST message of a Command that carries several, and serializes a Command with none as it came", () => {
+      const several = { lg_name: "Command", update: { messages: [envelope("first"), envelope("the tool's reply")] } };
+      expect(resultOf(several)).toBe("the tool's reply");
+      const none = { lg_name: "Command", update: { todos: [] }, goto: [] };
+      expect(resultOf(none)).toBe(JSON.stringify(none));
+    });
+  });
+
+  // ── Usage, read beside the transcript ────────────────────────────
+
+  describe("usageOf — what the loop reads off the wire", () => {
+    it("reads a message-finish's usage, the cache buckets included", () => {
+      expect(usageOf(makeMessageFinish("run-1", {
+        usage: { input_tokens: 100, output_tokens: 20, total_tokens: 120, input_token_details: { cache_creation: 40, cache_read: 5 } },
+      }))).toEqual({
+        input_tokens: 100,
+        output_tokens: 20,
+        total_tokens: 120,
+        input_token_details: { cache_creation: 40, cache_read: 5 },
+      });
+    });
+
+    it("is undefined for a message-finish without usage", () => {
+      expect(usageOf(makeMessageFinish("run-1"))).toBeUndefined();
+    });
+
+    it("ignores the standalone usage event — v3 emits both for one turn, and reading both would double-count", () => {
+      expect(usageOf(makeUsageEvent("run-1", { input_tokens: 50, output_tokens: 10 }))).toBeUndefined();
+    });
+
+    it("reads a sub-agent's finish too — its spend is the execution's", () => {
+      expect(usageOf(makeMessageFinish("sub-run", {
+        namespace: ["tools:task-1", "model_request:sub-run"],
+        usage: { input_tokens: 600, output_tokens: 12 },
+      }))).toMatchObject({ input_tokens: 600, output_tokens: 12 });
+    });
+
+    it("is undefined for every other channel", () => {
+      expect(usageOf(makeTextDelta("run-1", "hi"))).toBeUndefined();
+      expect(usageOf(makeToolFinished("toolu_abc", "ok"))).toBeUndefined();
+      expect(usageOf(makeLifecycleCompleted("root"))).toBeUndefined();
+    });
+  });
+
+  // ── Lifecycle channel: carried by the wire, not the transcript ───
+
+  describe("lifecycle channel", () => {
+    it("emits nothing for running", () => {
+      expect(normalize(makeLifecycleRunning("root"))).toHaveLength(0);
+    });
+
+    it("emits nothing for completed", () => {
+      expect(normalize(makeLifecycleCompleted("model_request", ["model_request:abc"]))).toHaveLength(0);
+    });
+  });
+
+  // ── Ignored channels ─────────────────────────────────────────────
+
+  describe("ignored channels", () => {
+    it("returns empty for checkpoints", () => {
+      expect(normalize(makeCheckpointEvent())).toHaveLength(0);
+    });
+
+    it("returns empty for tasks", () => {
+      expect(normalize(makeTasksEvent())).toHaveLength(0);
+    });
+
+    it("returns empty for values", () => {
+      expect(normalize(makeValuesEvent())).toHaveLength(0);
+    });
+
+    it("returns empty for updates", () => {
+      expect(normalize(makeUpdatesEvent())).toHaveLength(0);
+    });
+  });
+
+  // ── Edge cases ───────────────────────────────────────────────────
+
+  describe("edge cases", () => {
+    it("returns empty for unknown method", () => {
+      const event = makeProtocolEvent("input", { event: "something" });
+      expect(normalize(event)).toHaveLength(0);
+    });
+
+    it("returns empty for missing data", () => {
+      const event = makeProtocolEvent("messages", undefined);
+      expect(normalize(event)).toHaveLength(0);
+    });
+
+    it("returns empty for unknown message event type", () => {
+      const event = makeProtocolEvent("messages", { event: "brand-new-thing", run_id: "r" });
+      expect(normalize(event)).toHaveLength(0);
+    });
+
+    it("carries no namespace and no scope — the core is root-scoped; scope is the translator's", () => {
+      const result = normalize(makeTextDelta("run-1", "hi", { namespace: ["tools:x", "model_request:y"] }));
+      expect(result[0]).not.toHaveProperty("namespace");
+      expect(result[0]).not.toHaveProperty("subAgentId");
+    });
+
+    it("carries neither seq nor node — the recorder keeps them on the raw event; no handler reads them", () => {
+      const event = makeTextDelta("run-1", "hi");
+      const result = normalize(event);
+      expect(result[0]).not.toHaveProperty("seq");
+      expect(result[0]).not.toHaveProperty("node");
+    });
+
+    it("handles delta with no type gracefully", () => {
+      const event = makeProtocolEvent("messages", {
+        event: "content-block-delta",
+        index: 0,
+        delta: {},
+        run_id: "run-1",
+      });
+      expect(normalize(event)).toHaveLength(0);
+    });
+
+    it("handles missing tool_call_id in tool-started", () => {
+      const event = makeProtocolEvent("tools", {
+        event: "tool-started",
+        tool_name: "read_file",
+      }, { namespace: ["tools:abc"] });
+      const result = normalize(event);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({ kind: "tool_started", callId: "" });
+    });
+  });
+
+  // ── Scope and the sub-agent lifecycle: the translator over the core ──
+
+  describe("DeepAgentTranslator — scope by LangGraph namespace, a sub-agent per task call", () => {
+    const TASK_NS = ["tools:pregel-1"];
+    const CHILD_NS = ["tools:pregel-1", "model_request:inner-1"];
+    const CHILD_TOOL_NS = ["tools:pregel-1", "tools:inner-tool"];
+
+    function translator(): DeepAgentTranslator {
+      return new DeepAgentTranslator(null);
+    }
+
+    it("a root event carries no subAgentId", () => {
+      const [event] = translator().translate(makeTextDelta("run-1", "hi"));
+      expect(event).toEqual({ kind: "text_delta", runId: "run-1", text: "hi" });
+    });
+
+    it("a task start at depth 1 opens a sub-agent BEFORE its own row, keyed by the call id, named from its args", () => {
+      const events = translator().translate(
+        makeToolStarted("task-1", "task", { subagent_type: "helper", description: "Look it up." }, { namespace: TASK_NS }),
+      );
+      expect(events.map((e) => e.kind)).toEqual(["sub_agent_started", "tool_started"]);
+      expect(events[0]).toEqual({
+        kind: "sub_agent_started",
+        subAgentId: "task-1",
+        name: "helper",
+        subject: "Look it up.",
+        input: "Look it up.",
+      });
+      expect(events[1]).toMatchObject({ kind: "tool_started", callId: "task-1", name: "task" });
+      expect(events[1]).not.toHaveProperty("subAgentId");
+    });
+
+    it("a task start with no subagent_type is named after the tool", () => {
+      const [opened] = translator().translate(makeToolStarted("task-2", "task", {}, { namespace: TASK_NS }));
+      expect(opened).toMatchObject({ kind: "sub_agent_started", name: "task", subject: "", input: "" });
+    });
+
+    it("events under a registered prefix, two or more segments deep, are the sub-agent's", () => {
+      const t = translator();
+      t.translate(makeToolStarted("task-1", "task", { subagent_type: "helper" }, { namespace: TASK_NS }));
+      const [text] = t.translate(makeTextDelta("inner-1", "Working.", { namespace: CHILD_NS }));
+      expect(text).toEqual({ kind: "text_delta", runId: "inner-1", text: "Working.", subAgentId: "task-1" });
+      const [tool] = t.translate(makeToolStarted("inner-tool", "grep", { pattern: "x" }, { namespace: CHILD_TOOL_NS }));
+      expect(tool).toMatchObject({ kind: "tool_started", callId: "inner-tool", subAgentId: "task-1", mcpServerSlug: "" });
+    });
+
+    it("a task start INSIDE a sub-agent is an ordinary row of that sub-agent — one level of delegation is tracked", () => {
+      const t = translator();
+      t.translate(makeToolStarted("task-1", "task", { subagent_type: "helper" }, { namespace: TASK_NS }));
+      const events = t.translate(makeToolStarted("nested", "task", { subagent_type: "deeper" }, { namespace: CHILD_TOOL_NS }));
+      expect(events.map((e) => e.kind)).toEqual(["tool_started"]);
+      expect(events[0]).toMatchObject({ subAgentId: "task-1" });
+    });
+
+    it("a nested namespace whose prefix nobody registered folds into the root", () => {
+      const [event] = translator().translate(makeTextDelta("r", "hi", { namespace: ["tools:unknown", "model_request:x"] }));
+      expect(event).not.toHaveProperty("subAgentId");
+    });
+
+    it("a one-segment event under a registered prefix is the ROOT's — the task row's own lifecycle", () => {
+      const t = translator();
+      t.translate(makeToolStarted("task-1", "task", { subagent_type: "helper" }, { namespace: TASK_NS }));
+      const [finished] = t.translate(makeToolOutputDelta("task-1", "…", { namespace: TASK_NS }));
+      expect(finished).not.toHaveProperty("subAgentId");
+    });
+
+    it("the task's finish closes the sub-agent AFTER the row's own finish, with the same result as its output", () => {
+      const t = translator();
+      t.translate(makeToolStarted("task-1", "task", { subagent_type: "helper" }, { namespace: TASK_NS }));
+      const events = t.translate(makeToolFinished("task-1", "forty-two", { namespace: TASK_NS }));
+      expect(events).toEqual([
+        { kind: "tool_finished", callId: "task-1", result: "forty-two" },
+        { kind: "sub_agent_finished", subAgentId: "task-1", output: "forty-two" },
+      ]);
+    });
+
+    it("the task's error fails the sub-agent after the row's own error", () => {
+      const t = translator();
+      t.translate(makeToolStarted("task-1", "task", { subagent_type: "helper" }, { namespace: TASK_NS }));
+      const events = t.translate(makeToolError("task-1", "boom", { namespace: TASK_NS }));
+      expect(events).toEqual([
+        { kind: "tool_error", callId: "task-1", message: "boom" },
+        { kind: "sub_agent_failed", subAgentId: "task-1", error: "boom" },
+      ]);
+    });
+
+    it("an ordinary tool's finish closes no sub-agent", () => {
+      const t = translator();
+      const events = t.translate(makeToolFinished("toolu_1", "ok"));
+      expect(events.map((e) => e.kind)).toEqual(["tool_finished"]);
+    });
+
+    it("a depth-0 task start (no namespace) still opens a sub-agent, under a synthetic prefix its children can name", () => {
+      const t = translator();
+      const events = t.translate(makeToolStarted("task-0", "task", { subagent_type: "w" }, { namespace: [] }));
+      expect(events[0]).toMatchObject({ kind: "sub_agent_started", subAgentId: "task-0" });
+      const [child] = t.translate(makeTextDelta("in", "hi", { namespace: ["tools:task-0", "model_request:in"] }));
+      expect(child).toMatchObject({ subAgentId: "task-0" });
+    });
+
+    it("attributes root calls only: a sub-agent's tool start carries no server and no provenance even under a gate", () => {
+      const t = new DeepAgentTranslator({
+        policies: new Map(),
+        toolServerMap: new Map([["grep", "search-server"]]),
+        leasedCategories: new Set(),
+        globalBypass: false,
+        unattended: false,
+        unattendedSkips: new Set(),
+      });
+      t.translate(makeToolStarted("task-1", "task", { subagent_type: "helper" }, { namespace: TASK_NS }));
+      const [root] = t.translate(makeToolStarted("root-grep", "grep", {}));
+      expect(root).toMatchObject({ mcpServerSlug: "search-server", provenance: "classifier_default" });
+      const [sub] = t.translate(makeToolStarted("sub-grep", "grep", {}, { namespace: CHILD_TOOL_NS }));
+      expect(sub).toMatchObject({ subAgentId: "task-1", mcpServerSlug: "" });
+      expect(sub).not.toHaveProperty("provenance");
+    });
+  });
+});

package/src/activities/execute-deep-agent/__tests__/turn-stream.test.ts

@@ -6,21 +6,25 @@
  *
  *  - how the graph is invoked (the two-arg v3 `streamEvents` shape, the
  *    runtime's `langgraphConfig` carried whole, the loop's own abort signal);
- *  - what each event becomes (the normalizer feeds the builder; the sink
+ *  - what each event becomes (the translator feeds the builder; the sink
  *    learns of activity per event, with the tool's name as the detail);
  *  - what the sink is told and when (usage priced per `message_finish`;
  *    a persist requested on the shared cadence rule, a tool start forcing it);
- *  - how the loop ends: `completed` with the run's output, `awaiting_approval`
- *    at a gate, `interrupted` when the runtime stops it — taken at the NEXT
- *    event, the engine's own step boundary (S3 M2a F-M2a-18), and before the
- *    first if the stop came earlier;
+ *  - how the loop ends: `completed` with the run's output, `interrupted` when
+ *    the runtime stops it — taken at the NEXT event, the engine's own step
+ *    boundary, and before the first if the stop came
+ *    earlier. (`awaiting_approval` from the stream itself has no producer
+ *    on native since #1097: a held call never emits a
+ *    `tool_started`, so the builder never leaves a row WAITING during the
+ *    stream; the gate's hold reaches the transcript at the settle. The arm
+ *    that pinned that path went with it.)
  *  - what it refuses and what it tolerates: an empty stream throws; the
  *    engine's own error propagates; a `run.output` that rejects is logged
  *    and the turn completes without a final state;
  *  - the recorder exists only under `V3_EVENT_RECORD_DIR`.
  *
  * Carried from the legacy v3 loop's suite (`streaming-v3.test.ts`, retired
- * with the loop at S3 M2b, Q-M2b-5): the arms whose rule the adapter's loop
+ * with the loop in #1096): the arms whose rule the adapter's loop
  * still has, re-stated against the sink. The loop-specific arms it dropped
  * (the in-band heartbeat timer, the 120 s stall, STOP read from the persist,
  * pause as a terminal status) are the turn runtime's now and pinned in
@@ -39,7 +43,6 @@ import { makeInMemoryArtifactStorage } from "../../../__test-utils__/fake-artifa
 import { turnInputFixture } from "../../../__test-utils__/turn-input-fixture.js";
 import type { WorkspaceBackend } from "../../../shared/workspace/types.js";
 import type { ModelPricing } from "../../../shared/model-pricing.js";
-import type { MergedToolPolicy } from "../../../shared/approval-policy.js";
 import { CasCaptureObserver } from "../cas-capture-observer.js";
 import type { DeepAgentEngine, DeepAgentGateState, DeepAgentGraphInput, DeepAgentWorkspace } from "../turn-setup.js";
 import { consumeDeepAgentStream, createDeepAgentTranscript, type StreamableRun } from "../turn-stream.js";
@@ -185,7 +188,7 @@ describe("consumeDeepAgentStream — how the graph is invoked", () => {
 });
 
 describe("consumeDeepAgentStream — what each event becomes", () => {
-  it("feeds every event through the normalizer into the transcript and completes with the run's output", async () => {
+  it("feeds every event through the translator into the transcript and completes with the run's output", async () => {
     const h = harness();
     const result = await h.run(
       scriptedRun(
@@ -258,27 +261,6 @@ describe("consumeDeepAgentStream — what each event becomes", () => {
 });
 
 describe("consumeDeepAgentStream — how the loop ends", () => {
-  it("ends awaiting_approval when the builder leaves a gated tool WAITING, without awaiting the run's output", async () => {
-    const policy: MergedToolPolicy = {
-      toolName: "dangerous_tool",
-      mcpServerSlug: "my-server",
-      requiresApproval: true,
-      approvalMessage: "Approve?",
-      source: "classifier_default",
-    };
-    const h = harness({
-      gate: openGate({ policies: new Map([["my-server/dangerous_tool", policy]]), toolServerMap: new Map([["dangerous_tool", "my-server"]]) }),
-    });
-    const neverResolves = new Promise<unknown>(() => undefined);
-    const result = await h.run(
-      scriptedRun([...textTurn("run-1", "Gated."), makeToolStarted("toolu_g", "dangerous_tool", { target: "prod" })], { output: () => neverResolves }),
-    );
-
-    expect(result.reason).toBe("awaiting_approval");
-    expect(result.runOutput).toBeUndefined();
-    expect(h.sink.status.messages[0].toolCalls[0].status).toBe(ToolCallStatus.TOOL_CALL_WAITING_APPROVAL);
-  });
-
   it("a stop before the first event settles interrupted without invoking the graph", async () => {
     const h = harness();
     h.sink.abort("stopped before start");

package/src/activities/execute-deep-agent/adapter.ts

@@ -30,7 +30,7 @@
  * (the thread id is the runtime's, `deterministic`), or import
  * `@temporalio/*` (`__tests__/adapter-is-temporal-free.test.ts`).
  *
- * Extracted from `index.ts` `createDeepAgentActivities` at S3 M2a on the
+ * Extracted from `index.ts` `createDeepAgentActivities` in #1096 on the
  * Cursor adapter's layout (`execute-cursor/adapter.ts`).
  */
 

package/src/activities/execute-deep-agent/approval-file-change.ts

@@ -1,35 +1,34 @@
 /**
  * Pre-execution args capture for the HITL approval gate (native harness).
  *
- * When the graph pauses for approval — before the tool runs — this captures a
- * sanitized args preview so the gate can show the proposed change. It owns only
- * the native-specific seam: correlating a gated `tool_call_id` to its arguments
- * from graph state (the authoritative single source of truth at the interrupt,
- * since the streamed input cache is empty and the interrupt value carries only a
- * few fields). The approval card renders the proposed write/edit content from
- * these args; there is no separate captured `file_changes` (removed in Phase 5
- * Slice 4 — the args are the single source, and the Cursor deny-gate's
- * exact-apply reads the same args on resume; see shared/exact-apply.ts).
+ * When the graph pauses for approval — before the tool runs — this recovers
+ * the proposed call's arguments so the gate can show the proposed change. It
+ * owns only the native-specific seam: correlating a gated `tool_call_id` to
+ * its arguments from graph state (the authoritative single source of truth at
+ * the interrupt, since the streamed input cache is empty and the interrupt
+ * value carries only a few fields). The approval card renders the proposed
+ * write/edit content from these args; there is no separate captured
+ * `file_changes` (removed in Phase 5 Slice 4 — the args are the single
+ * source, and the Cursor deny-gate's exact-apply reads the same args on
+ * resume; see shared/exact-apply.ts). The row's `args_preview` is the
+ * builder's to write from these args (since #1097; until then this module
+ * rendered it too, a second call of the one sanitizer).
  *
  * @since First-Class Diff Review (#186), approval-gate phase
  */
 
 /** What the gate capture contributes to a `WAITING_APPROVAL` `ToolCall`. */
 export interface ApprovalCaptureResult {
-  /** Sanitized JSON args preview, omitted when there are no args to show. */
-  readonly argsPreview?: string;
   /**
    * The secret-redacted args object, for stamping `ToolCall.args` on the
-   * interrupt-placeholder row. Without it the placeholder carried ONLY the
-   * preview string, so every args-driven UI read — the row header's
-   * filename-first path above all — rendered nothing for a pending gate
-   * (issue #754). Redacted (never raw): the placeholder must not widen the
-   * exposure the preview sanitizer bounds.
+   * proposed row. Without it the row carried ONLY the preview string, so
+   * every args-driven UI read — the row header's filename-first path above
+   * all — rendered nothing for a pending gate (issue #754). Redacted (never
+   * raw): the row must not widen the exposure the preview sanitizer bounds.
    */
   readonly args?: Record<string, unknown>;
 }
 
-import { sanitizeArgsPreview } from "./status-builder-shared.js";
 import { redactSensitiveArgs } from "../../shared/args-preview.js";
 
 /**
@@ -72,11 +71,11 @@ export function findAiMessageToolCallArgs(
 }
 
 /**
- * Capture the gate's args preview from a single correlation lookup, keeping the
- * call site thin.
+ * Capture the gate's redacted args from a single correlation lookup, keeping
+ * the call site thin.
  *
  * Returns an empty result when the tool call cannot be correlated or took no
- * arguments, so the gate falls back to today's behavior for that interrupt.
+ * arguments, so the proposed row carries no args for that interrupt.
  */
 export function captureApprovalArtifacts(opts: {
   readonly toolCallId: string;
@@ -85,6 +84,5 @@ export function captureApprovalArtifacts(opts: {
   const args = findAiMessageToolCallArgs(opts.messages, opts.toolCallId);
   if (!args || Object.keys(args).length === 0) return {};
 
-  const argsPreview = sanitizeArgsPreview(args) || undefined;
-  return { argsPreview, args: redactSensitiveArgs(args) };
+  return { args: redactSensitiveArgs(args) };
 }