@stigmer/runner 3.15.3-dev.20260914100347 → 3.15.3-dev.20260916211208

package/src/activities/execute-deep-agent/__tests__/hermetic/write-todos.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Hermetic golden: the agent's TO-DO LIST on the native harness — the model
+ * proposes deepagents' built-in `write_todos`, the tools node runs it for
+ * real, and the builder projects the list into `status.todos`.
+ *
+ * Invariant pinned: `TranscriptBuilder.handleToolStarted` classifies
+ * the row `ToolKind.TODO` by name; `handleToolFinished` projects `tc.args.todos`
+ * into `status.todos` through the shared `applyTodoUpdate` as a FULL REPLACE
+ * (deepagents' schema has no `merge`), keyed `todo-<i>`, and KEEPS the row in
+ * the transcript — the clients filter `ToolKind.TODO` from the thread. As an
+ * ungated built-in it carries `argsPreview` like every row since #1097
+ * (until then native stamped a preview on gated rows only).
+ *
+ * What the golden shows:
+ *  - The row sits on the AI message whose text proposed it, "Planning the two
+ *    steps." (since #1097; until then on an empty message between the two
+ *    texts — see `tool-call.test.ts`'s header).
+ *  - The row's `result` is the tool's confirmation text, "Updated todo list
+ *    to [...]" (since #1097). deepagents' `write_todos` returns a
+ *    LangGraph `Command` (`{ lg_name: "Command", update: { todos, messages:
+ *    [ToolMessage] } }`); until then the native extractor unwrapped a
+ *    LangChain `ToolMessage` envelope but not a `Command`, so the row carried
+ *    the whole serialized Command — the todos array a second time and the
+ *    text nested inside it (pinned as found when this net opened,
+ *    regenerated in #1097 with that one hunk).
+ *
+ * The #1097 moves, as landed (2026-09-14): the
+ * row joined `messages[0]` ("Planning the two steps.") and the empty message
+ * went; the row gained `argsPreview`, the elided preview of
+ * its `args`. `todos` is byte-identical (the builder keeps native's
+ * full-replace: `write_todos` never sends `merge`). Any other hunk is a pause.
+ *
+ * Why this net exists: none of the twenty-three earlier native goldens
+ * carried a todo, and #1097 moved the projection from the native builder
+ * into the canonical one.
+ *
+ * Regenerate ONLY after a deliberate behavior change:
+ *   npx vitest run src/activities/execute-deep-agent/__tests__/hermetic -u
+ */
+
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { toJson } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  ExecutionPhase,
+  MessageType,
+  TodoStatus,
+  ToolCallStatus,
+  ToolKind,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+vi.mock("../../../../shared/model-client.js", async () =>
+  (await import("../../__test-utils__/scripted-model-module.js")).scriptedModelClientModule(),
+);
+vi.mock("../../../../client/stigmer-client.js", async () =>
+  (await import("../../../../__test-utils__/hermetic-activity.js")).hermeticStigmerClientModule(),
+);
+
+import {
+  ScriptedClock,
+  createHermeticEnvironment,
+  type HermeticEnvironment,
+} from "../../../../__test-utils__/hermetic-activity.js";
+import { stubRegistryFetch } from "../../../../__test-utils__/model-registry-fixture.js";
+import {
+  beginDeepAgentScenario,
+  deepAgentExecutionRecord,
+  runDeepAgentTurn,
+} from "../../__test-utils__/hermetic-deep-agent.js";
+
+const CALL_ID = "call-hermetic-todos-0001";
+const USER_MESSAGE = "Plan the two steps.";
+const TEXT_PLAN = "Planning the two steps.";
+/** deepagents' `write_todos` schema: `{ content, status }` per item, three statuses, no id, no merge. */
+const TODOS = [
+  { content: "Read the fixture", status: "pending" },
+  { content: "Summarise it", status: "in_progress" },
+];
+const TEXT_CLOSING = "The plan is written.";
+
+describe("ExecuteDeepAgent hermetic — write_todos", () => {
+  let env: HermeticEnvironment;
+  let registry: ReturnType<typeof stubRegistryFetch>;
+  const clock = new ScriptedClock();
+
+  beforeAll(() => {
+    env = createHermeticEnvironment();
+    registry = stubRegistryFetch();
+    clock.install();
+  });
+
+  afterAll(() => {
+    clock.uninstall();
+    registry.restore();
+    env.dispose();
+  });
+
+  it("projects the completed write into status.todos, keeps the row, and completes", async () => {
+    // ── Arrange ──────────────────────────────────────────────────────────────
+    const record = deepAgentExecutionRecord({ message: USER_MESSAGE });
+    const scenario = beginDeepAgentScenario({
+      env,
+      clock,
+      record,
+      script: () => ({
+        turns: [
+          {
+            text: TEXT_PLAN,
+            toolCalls: [{ id: CALL_ID, name: "write_todos", args: { todos: TODOS } }],
+            usage: { inputTokens: 1_400, outputTokens: 70 },
+          },
+          { text: TEXT_CLOSING, usage: { inputTokens: 1_600, outputTokens: 20 } },
+        ],
+      }),
+    });
+
+    // ── Act ──────────────────────────────────────────────────────────────────
+    const invocation = await runDeepAgentTurn(scenario);
+
+    // ── Assert: outcome ──────────────────────────────────────────────────────
+    expect(invocation.outcome.kind).toBe("returned");
+    expect((invocation.outcome as { value: Record<string, unknown> }).value.phase).toBe("EXECUTION_COMPLETED");
+    expect(record.persistedPhases.at(-1)).toBe(ExecutionPhase.EXECUTION_COMPLETED);
+
+    // ── Assert: the row stays in the transcript, classified TODO ─────────────
+    const rows = record.toolCalls();
+    expect(rows).toHaveLength(1);
+    const row = rows[0];
+    expect(row.id).toBe(CALL_ID);
+    expect(row.name).toBe("write_todos");
+    expect(row.toolKind).toBe(ToolKind.TODO);
+    expect(row.status).toBe(ToolCallStatus.TOOL_CALL_COMPLETED);
+    expect(row.args).toEqual({ todos: TODOS });
+    expect(JSON.parse(row.argsPreview), "every row carries its elided preview").toEqual({ todos: TODOS });
+    expect(row.requiresApproval).toBe(false);
+    // Since #1097: the ToolMessage's content, never the serialized Command.
+    expect(row.result.startsWith("Updated todo list to"), "the tool's own confirmation text is what the row carries").toBe(true);
+    expect(row.result).not.toContain("lg_name");
+
+    // ── Assert: the transcript — the row beside the text that proposed it ──
+    const final = record.lastFullStatus!;
+    const ai = final.messages.filter((m) => m.type === MessageType.MESSAGE_AI);
+    expect(ai.map((m) => [m.content, m.toolCalls.map((tc) => tc.id)])).toEqual([
+      [TEXT_PLAN, [CALL_ID]],
+      [TEXT_CLOSING, []],
+    ]);
+
+    // ── Assert: the projection, by key (byte-identical across the swap) ─────
+    expect(Object.keys(final.todos).sort()).toEqual(["todo-0", "todo-1"]);
+    expect([final.todos["todo-0"].content, final.todos["todo-0"].status]).toEqual(["Read the fixture", TodoStatus.TODO_PENDING]);
+    expect([final.todos["todo-1"].content, final.todos["todo-1"].status]).toEqual(["Summarise it", TodoStatus.TODO_IN_PROGRESS]);
+
+    // ── Assert: hermeticity ──────────────────────────────────────────────────
+    expect(registry.urls.every((u) => u.includes("/model-registry"))).toBe(true);
+
+    // ── Assert: the golden ───────────────────────────────────────────────────
+    const json = JSON.stringify(toJson(AgentExecutionStatusSchema, final), null, 2) + "\n";
+    await expect(json).toMatchFileSnapshot("./goldens/write-todos.status.json");
+  });
+});

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

@@ -4,19 +4,21 @@ import { writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { create } from "@bufbuild/protobuf";
-import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { type AgentExecutionStatus, AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { InlinePublisher } from "../inline-publisher.js";
-import { V3StatusBuilder } from "../v3-status-builder.js";
+import { TranscriptBuilder } from "../../../harness/transcript/builder.js";
 import { LocalWorkspaceBackend } from "../../../shared/workspace/local-backend.js";
 import type { ArtifactStorage } from "../../../shared/artifact-storage.js";
 import { makeInMemoryArtifactStorage } from "../../../__test-utils__/fake-artifact-storage.js";
 import type { WorkspaceBackend } from "../../../shared/workspace/types.js";
 
-// The publisher writes artifacts through the transcript builder's
-// `ExecutionStatusWriter` face (`addArtifact`); the one builder since S3 M2b.
-function makeStatusBuilder(): V3StatusBuilder {
-  return new V3StatusBuilder("exec-test", create(AgentExecutionStatusSchema, {}));
+// The publisher registers artifacts on the transcript builder (`addArtifact`);
+// the one builder since #1096.
+/** A builder and the status it builds into: the test writes through `sb` and reads `status`, as production reads `TurnSink.status`. */
+function makeStatusBuilder(): { sb: TranscriptBuilder; status: AgentExecutionStatus } {
+  const status = create(AgentExecutionStatusSchema, {});
+  return { sb: new TranscriptBuilder("exec-test", status), status };
 }
 
 function mockWorkspaceBackend(files: Record<string, string>): WorkspaceBackend {
@@ -55,19 +57,20 @@ function sha256(content: string): string {
 }
 
 describe("InlinePublisher", () => {
-  let sb: V3StatusBuilder;
+  let sb: TranscriptBuilder;
+  let status: AgentExecutionStatus;
   let storage: ReturnType<typeof mockArtifactStorage>;
   let backend: WorkspaceBackend;
   let publisher: InlinePublisher;
 
   beforeEach(() => {
-    sb = makeStatusBuilder();
+    ({ sb, status } = makeStatusBuilder());
     storage = mockArtifactStorage();
     backend = mockWorkspaceBackend({ "src/main.ts": "console.log('hello');" });
     publisher = new InlinePublisher({
       workspaceBackend: backend,
       artifactStorage: storage,
-      statusWriter: sb,
+      artifacts: sb,
       executionId: "exec-123",
     });
   });
@@ -76,9 +79,9 @@ describe("InlinePublisher", () => {
     await publisher.publish("src/main.ts");
 
     expect(storage.uploadedKeys).toEqual(["artifacts/exec-123/main.ts"]);
-    expect(sb.currentStatus.artifacts).toHaveLength(1);
+    expect(status.artifacts).toHaveLength(1);
 
-    const artifact = sb.currentStatus.artifacts[0];
+    const artifact = status.artifacts[0];
     expect(artifact.name).toBe("main.ts");
     expect(artifact.sandboxPath).toBe("src/main.ts");
     expect(artifact.kind).toBe(ExecutionArtifactKind.FILE);
@@ -90,8 +93,8 @@ describe("InlinePublisher", () => {
   it("strips leading slashes from paths", async () => {
     await publisher.publish("/src/main.ts");
 
-    expect(sb.currentStatus.artifacts).toHaveLength(1);
-    expect(sb.currentStatus.artifacts[0].sandboxPath).toBe("src/main.ts");
+    expect(status.artifacts).toHaveLength(1);
+    expect(status.artifacts[0].sandboxPath).toBe("src/main.ts");
   });
 
   it("deduplicates by path + content hash", async () => {
@@ -99,7 +102,7 @@ describe("InlinePublisher", () => {
     await publisher.publish("src/main.ts");
 
     expect(storage.uploadedKeys).toHaveLength(1);
-    expect(sb.currentStatus.artifacts).toHaveLength(1);
+    expect(status.artifacts).toHaveLength(1);
   });
 
   it("re-publishes when content changes", async () => {
@@ -109,8 +112,8 @@ describe("InlinePublisher", () => {
     await publisher.publish("src/main.ts");
 
     expect(storage.uploadedKeys).toHaveLength(2);
-    expect(sb.currentStatus.artifacts).toHaveLength(1);
-    expect(sb.currentStatus.artifacts[0].contentHash).toBe(sha256("updated content"));
+    expect(status.artifacts).toHaveLength(1);
+    expect(status.artifacts[0].contentHash).toBe(sha256("updated content"));
   });
 
   it("exposes published paths for dedup by auto-publish", async () => {
@@ -128,13 +131,13 @@ describe("InlinePublisher", () => {
     const pub = new InlinePublisher({
       workspaceBackend: failBackend,
       artifactStorage: storage,
-      statusWriter: sb,
+      artifacts: sb,
       executionId: "exec-err",
     });
 
     await pub.publish("nonexistent.txt");
 
-    expect(sb.currentStatus.artifacts).toHaveLength(0);
+    expect(status.artifacts).toHaveLength(0);
     expect(warnSpy).toHaveBeenCalledWith(
       expect.stringContaining("[InlinePublisher]"),
     );
@@ -149,7 +152,7 @@ describe("InlinePublisher", () => {
 
     await publisher.publish("src/main.ts");
 
-    expect(sb.currentStatus.artifacts).toHaveLength(0);
+    expect(status.artifacts).toHaveLength(0);
     expect(warnSpy).toHaveBeenCalled();
     warnSpy.mockRestore();
   });
@@ -160,7 +163,7 @@ describe("InlinePublisher", () => {
     const expected = createHash("sha256")
       .update(Buffer.from("console.log('hello');", "utf-8"))
       .digest("hex");
-    expect(sb.currentStatus.artifacts[0].contentHash).toBe(expected);
+    expect(status.artifacts[0].contentHash).toBe(expected);
   });
 
   it("never publishes a secret-like file to artifact storage (design doc 12, D4)", async () => {
@@ -172,14 +175,14 @@ describe("InlinePublisher", () => {
     const pub = new InlinePublisher({
       workspaceBackend: secretBackend,
       artifactStorage: storage,
-      statusWriter: sb,
+      artifacts: sb,
       executionId: "exec-secret",
     });
 
     await pub.publish(".env");
 
     expect(storage.uploadedKeys).toHaveLength(0);
-    expect(sb.currentStatus.artifacts).toHaveLength(0);
+    expect(status.artifacts).toHaveLength(0);
     expect(readSpy).not.toHaveBeenCalled(); // withheld before the file is even read
     expect(pub.publishedPaths.size).toBe(0);
   });
@@ -189,7 +192,7 @@ describe("InlinePublisher", () => {
     const pub = new InlinePublisher({
       workspaceBackend: jsonBackend,
       artifactStorage: storage,
-      statusWriter: sb,
+      artifacts: sb,
       executionId: "exec-ct",
     });
 
@@ -209,21 +212,22 @@ describe("InlinePublisher with LocalWorkspaceBackend (disk-backed)", () => {
     await mkdir(join(dir, "src"), { recursive: true });
     await writeFile(join(dir, "src/app.ts"), "export const x = 42;", "utf-8");
 
-    const sb = new V3StatusBuilder("exec-disk", create(AgentExecutionStatusSchema, {}));
+    const status = create(AgentExecutionStatusSchema, {});
+    const sb = new TranscriptBuilder("exec-disk", status);
     const storage = mockArtifactStorage();
     const backend = new LocalWorkspaceBackend(dir);
 
     const publisher = new InlinePublisher({
       workspaceBackend: backend,
       artifactStorage: storage,
-      statusWriter: sb,
+      artifacts: sb,
       executionId: "exec-disk",
     });
 
     await publisher.publish("src/app.ts");
 
-    expect(sb.currentStatus.artifacts).toHaveLength(1);
-    const artifact = sb.currentStatus.artifacts[0];
+    expect(status.artifacts).toHaveLength(1);
+    const artifact = status.artifacts[0];
     expect(artifact.name).toBe("app.ts");
     expect(artifact.sandboxPath).toBe("src/app.ts");
     expect(artifact.kind).toBe(ExecutionArtifactKind.FILE);
@@ -237,20 +241,21 @@ describe("InlinePublisher with LocalWorkspaceBackend (disk-backed)", () => {
     const dir = join(tmpdir(), `stigmer-publisher-test-${Date.now()}`);
     await mkdir(dir, { recursive: true });
 
-    const sb = new V3StatusBuilder("exec-miss", create(AgentExecutionStatusSchema, {}));
+    const status = create(AgentExecutionStatusSchema, {});
+    const sb = new TranscriptBuilder("exec-miss", status);
     const storage = mockArtifactStorage();
     const backend = new LocalWorkspaceBackend(dir);
 
     const publisher = new InlinePublisher({
       workspaceBackend: backend,
       artifactStorage: storage,
-      statusWriter: sb,
+      artifacts: sb,
       executionId: "exec-miss",
     });
 
     await publisher.publish("nonexistent.ts");
 
-    expect(sb.currentStatus.artifacts).toHaveLength(0);
+    expect(status.artifacts).toHaveLength(0);
     expect(storage.uploadedKeys).toHaveLength(0);
     expect(warnSpy).toHaveBeenCalledWith(
       expect.stringContaining("[InlinePublisher]"),

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

@@ -2,13 +2,12 @@ import { describe, it, expect } from "vitest";
 import { InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { buildEnhancedSystemPrompt, composeUserMessage } from "../prompt-builder.js";
 import { PLAN_MODE_DIRECTIVE } from "../../../shared/plan-mode-prompt.js";
-import { SourceType } from "../../../shared/workspace/types.js";
 import type { ProvisionResult } from "../../../shared/workspace/types.js";
 
 function makeProvisionResult(overrides: Partial<ProvisionResult> = {}): ProvisionResult {
   return {
     rootDir: "/workspace/project",
-    sourceType: SourceType.LOCAL_PATH,
+    sourceType: "local_path",
     consumedKeys: [],
     workspaceDescription: "User project directory at /workspace/project",
     entryName: "project",
@@ -266,7 +265,7 @@ describe("buildEnhancedSystemPrompt", () => {
       instructions: "Test",
       provisionResults: [
         makeProvisionResult({
-          sourceType: SourceType.GIT_REPO,
+          sourceType: "git_repo",
           entryName: "my-repo",
           rootDir: "/workspace/my-repo",
           gitMetadata: {
@@ -277,7 +276,7 @@ describe("buildEnhancedSystemPrompt", () => {
           },
         }),
         makeProvisionResult({
-          sourceType: SourceType.EMPTY,
+          sourceType: "empty",
           entryName: "scratch",
           rootDir: "/workspace/scratch",
         }),

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

@@ -2,13 +2,14 @@
  * The native system prompt, whole, as goldens.
  *
  * Every other prompt test in this directory asserts with `toContain`; the
- * hermetic goldens are status JSON and never see a prompt. So until S3 M5 no
+ * hermetic goldens are status JSON and never see a prompt. So until #1096 no
  * test pinned a rendered prompt byte for byte, and the relevance-filtered
  * `## Skills` section (eight or more skills, `turn-setup.ts`
  * `renderRootSkillsSection`) had no test at all. These goldens are the
  * photograph taken BEFORE the shared prompt glue moved into
- * `shared/prompt-sections.ts` (S3 M5, Q-M5-1), so the move could be proven
- * byte-identical — the same discipline M0 applied to the activity's status.
+ * `shared/prompt-sections.ts` (#1096), so the move could be proven
+ * byte-identical — the same discipline the hermetic net applied to the
+ * activity's status.
  *
  * Why bytes matter here beyond taste: `ScriptedModel` tells its scripted
  * roles apart by the system prompt's text (`__test-utils__/scripted-model.ts`
@@ -25,9 +26,10 @@
  *
  * The goldens are taken through `turn-setup.ts` `composeSystemPrompt`, the
  * production mapping from the runtime's resolved record to the builder's
- * input, so they pin the mapping too, not a copy of it. (C0 photographed the
- * prompt through a field-for-field copy of the mapping as it then sat inline
- * in `buildEngine`; C1 extracted it and re-took the goldens through the
+ * input, so they pin the mapping too, not a copy of it. (The first cut
+ * photographed the prompt through a field-for-field copy of the mapping as
+ * it then sat inline in `buildEngine`; the next extracted it and re-took the
+ * goldens through the
  * extraction — byte-identical, which is the proof the extraction is one.)
  *
  * A golden moves only under a ruling quoted in this header; never a quiet
@@ -49,7 +51,7 @@ import type { TurnInput } from "../../../harness/types.js";
 import type { ResolvedAttachment } from "../../../shared/attachment-resolver.js";
 import type { SkillMetadata } from "../../../shared/skill-resolver.js";
 import type { RecalledMemoriesContent } from "../../../shared/recalled-memories.js";
-import { SourceType, type ProvisionResult } from "../../../shared/workspace/types.js";
+import type { ProvisionResult } from "../../../shared/workspace/types.js";
 import { buildEnhancedSystemPrompt } from "../prompt-builder.js";
 import { composeSystemPrompt } from "../turn-setup.js";
 
@@ -81,7 +83,7 @@ const THREE_SKILLS: readonly SkillMetadata[] = NINE_SKILLS.slice(0, 3);
 const PROVISION_RESULTS: readonly ProvisionResult[] = [
   {
     rootDir: "/ws/app",
-    sourceType: SourceType.GIT_REPO,
+    sourceType: "git_repo",
     consumedKeys: [],
     workspaceDescription: "The payments service, cloned from git.",
     entryName: "app",
@@ -90,7 +92,7 @@ const PROVISION_RESULTS: readonly ProvisionResult[] = [
   },
   {
     rootDir: "/ws/docs",
-    sourceType: SourceType.LOCAL_PATH,
+    sourceType: "local_path",
     consumedKeys: [],
     workspaceDescription: "The docs folder on the user's machine.",
     entryName: "docs",
@@ -209,7 +211,7 @@ async function systemPromptOf(input: TurnInput): Promise<string> {
 // Goldens
 // ---------------------------------------------------------------------------
 
-describe("native system prompt goldens (S3 M5, Q-M5-1)", () => {
+describe("native system prompt goldens", () => {
   it("everything at once, nine skills so the relevance filter fires", async () => {
     const prompt = await systemPromptOf(everythingInput({ skills: NINE_SKILLS }));
     await expect(prompt).toMatchFileSnapshot("./goldens/system-prompt.everything.prompt.md");

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

@@ -25,7 +25,7 @@
  *     deepagents graph aborted mid-hang through the run's own signal, the
  *     parked model unparks, the stream rejects with the abort, and the
  *     process sees no orphaned rejection — the posture the contract kit's
- *     hang arms and the runtime's stall watchdog rely on (S3 M2a F-M2a-18
+ *     hang arms and the runtime's stall watchdog rely on (#1096
  *     measured one orphan for a forced mid-step abort of a WEDGED engine;
  *     an engine that honours its signal leaves none, and this arm is where
  *     that fact is pinned).
@@ -102,12 +102,22 @@ describe("ScriptedModel — turns are indexed by the transcript, not by a counte
     expect(replayed.tool_calls?.[0]?.id).toBe("call_b");
   });
 
-  it("reports the role and round to onTurn before rendering", async () => {
+  it("reports the role, the round and the calls it answers to onTurn before rendering", async () => {
     const seen: ScriptedTurnInfo[] = [];
     const model = new ScriptedModel(() => script, [], { onTurn: (info) => void seen.push(info) });
     const bound = model.bindTools([{ name: "probe" }]);
     await bound.invoke(transcriptWithRounds(2));
-    expect(seen).toEqual([{ boundToolNames: ["probe"], round: 2 }]);
+    // The prior calls are the LAST AI message's — the results this turn
+    // answers — read from the transcript, not the script.
+    expect(seen).toEqual([{ boundToolNames: ["probe"], round: 2, priorToolCallIds: ["call_1"] }]);
+  });
+
+  it("reports no prior calls on a first turn or after a text-only turn", async () => {
+    const seen: ScriptedTurnInfo[] = [];
+    const model = new ScriptedModel(() => script, [], { onTurn: (info) => void seen.push(info) });
+    await model.invoke(transcriptWithRounds(0));
+    await model.invoke([...transcriptWithRounds(1), new AIMessage("a text-only turn"), new HumanMessage("more")]);
+    expect(seen.map((s) => s.priorToolCallIds)).toEqual([[], []]);
   });
 
   it("throws a diagnosing error when the script runs out", async () => {

package/src/activities/execute-deep-agent/__tests__/streaming-side-effects.test.ts

@@ -1,19 +1,27 @@
 /**
- * `StreamingSideEffects`: the v3 `tools` events carry the tool INPUT on
- * `tool-started` and the OUTPUT on `tool-finished`, so the trigger correlates
- * the two by `tool_call_id` and publishes a file-modifying tool's target path
- * once the call has finished.
+ * `StreamingSideEffects`: a `tool_started` carries the tool INPUT and a
+ * `tool_finished` its completion, so the trigger correlates the two by
+ * `callId` and publishes a file-modifying tool's target path once the call
+ * has finished. Driven the way the loop drives it (since #1097): raw v3 events
+ * through the translator, the canonical events into the trigger.
  *
  * Carried from the legacy v3 loop's suite (`streaming-v3.test.ts`, retired
- * with the loop at S3 M2b) — the trigger itself never had a test of its own.
+ * with the loop in #1096) — the trigger itself never had a test of its own.
  */
 
 import { describe, it, expect, vi } from "vitest";
 
 import { StreamingSideEffects } from "../streaming-side-effects.js";
+import { DeepAgentTranslator } from "../translator.js";
 import type { InlinePublisher } from "../inline-publisher.js";
+import type { V3ProtocolEvent } from "../v3-event-recorder.js";
 import { makeToolFinished, makeToolStarted, resetSeq } from "../__test-utils__/v3-event-fixtures.js";
 
+/** What the loop does per raw event: translate, then hand every canonical event to the trigger. */
+function feed(effects: StreamingSideEffects, raw: V3ProtocolEvent): void {
+  for (const event of new DeepAgentTranslator(null).translate(raw)) effects.onEvent(event);
+}
+
 function publisherDouble(): { publisher: InlinePublisher; publish: ReturnType<typeof vi.fn> } {
   const publish = vi.fn(async (_path: string) => undefined);
   // The trigger reads exactly one member of the publisher.
@@ -26,10 +34,10 @@ describe("StreamingSideEffects", () => {
     const { publisher, publish } = publisherDouble();
     const effects = new StreamingSideEffects({ inlinePublisher: publisher });
 
-    effects.onProtocolEvent(makeToolStarted("toolu_1", "write_file", { file_path: "/ws/index.ts", content: "x" }));
+    feed(effects, makeToolStarted("toolu_1", "write_file", { file_path: "/ws/index.ts", content: "x" }));
     expect(publish, "not before the call finishes").not.toHaveBeenCalled();
 
-    effects.onProtocolEvent(makeToolFinished("toolu_1", "written"));
+    feed(effects, makeToolFinished("toolu_1", "written"));
     expect(publish).toHaveBeenCalledWith("/ws/index.ts");
     expect(effects.pendingPublishPromises).toHaveLength(1);
   });
@@ -39,8 +47,8 @@ describe("StreamingSideEffects", () => {
     const { publisher, publish } = publisherDouble();
     const effects = new StreamingSideEffects({ inlinePublisher: publisher });
 
-    effects.onProtocolEvent(makeToolStarted("toolu_2", "read_file", { path: "/ws/index.ts" }));
-    effects.onProtocolEvent(makeToolFinished("toolu_2", "contents"));
+    feed(effects, makeToolStarted("toolu_2", "read_file", { path: "/ws/index.ts" }));
+    feed(effects, makeToolFinished("toolu_2", "contents"));
     expect(publish).not.toHaveBeenCalled();
     expect(effects.pendingPublishPromises).toHaveLength(0);
   });
@@ -50,10 +58,10 @@ describe("StreamingSideEffects", () => {
     const { publisher, publish } = publisherDouble();
     const effects = new StreamingSideEffects({ inlinePublisher: publisher });
 
-    effects.onProtocolEvent(makeToolStarted("toolu_3", "edit", { filePath: "/ws/a.ts" }));
-    effects.onProtocolEvent(makeToolFinished("toolu_3", "ok"));
-    effects.onProtocolEvent(makeToolStarted("toolu_4", "write", JSON.stringify({ path: "/ws/b.ts" })));
-    effects.onProtocolEvent(makeToolFinished("toolu_4", "ok"));
+    feed(effects, makeToolStarted("toolu_3", "edit", { filePath: "/ws/a.ts" }));
+    feed(effects, makeToolFinished("toolu_3", "ok"));
+    feed(effects, makeToolStarted("toolu_4", "write", JSON.stringify({ path: "/ws/b.ts" })));
+    feed(effects, makeToolFinished("toolu_4", "ok"));
     expect(publish.mock.calls.map((c) => c[0])).toEqual(["/ws/a.ts", "/ws/b.ts"]);
   });
 
@@ -62,17 +70,17 @@ describe("StreamingSideEffects", () => {
     const { publisher, publish } = publisherDouble();
     const effects = new StreamingSideEffects({ inlinePublisher: publisher });
 
-    effects.onProtocolEvent(makeToolFinished("toolu_never_started", "ok"));
-    effects.onProtocolEvent(makeToolStarted("toolu_5", "write_file", { content: "no path" }));
-    effects.onProtocolEvent(makeToolFinished("toolu_5", "ok"));
+    feed(effects, makeToolFinished("toolu_never_started", "ok"));
+    feed(effects, makeToolStarted("toolu_5", "write_file", { content: "no path" }));
+    feed(effects, makeToolFinished("toolu_5", "ok"));
     expect(publish).not.toHaveBeenCalled();
   });
 
   it("does nothing at all without a publisher", () => {
     resetSeq();
     const effects = new StreamingSideEffects({});
-    effects.onProtocolEvent(makeToolStarted("toolu_6", "write_file", { path: "/ws/x" }));
-    effects.onProtocolEvent(makeToolFinished("toolu_6", "ok"));
+    feed(effects, makeToolStarted("toolu_6", "write_file", { path: "/ws/x" }));
+    feed(effects, makeToolFinished("toolu_6", "ok"));
     expect(effects.pendingPublishPromises).toHaveLength(0);
   });
 });

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

@@ -46,7 +46,7 @@ describe("buildSubAgentMiddleware", () => {
 
     const subView = stack[4];
     expect(subView.afterModel).toBeDefined();
-    expect(subView.wrapToolCall, "the advisory never blocks a tool; the runtime enforces the cap (Q-S3-3)").toBeUndefined();
+    expect(subView.wrapToolCall, "the advisory never blocks a tool; the runtime enforces the cap").toBeUndefined();
     expect(subView.beforeAgent).toBeUndefined();
   });