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

package/src/__test-utils__/__tests__/execution-record-barrier.test.ts

@@ -0,0 +1,70 @@
+/**
+ * `ExecutionRecord.whenToolCallsSettled` — the barrier the hermetic scripted
+ * model waits on before it ticks (since #1097): resolves once every named row is
+ * persisted settled, across the root and the sub-agent transcripts; resolves
+ * at once when there is nothing to wait for; fails naming the open ids rather
+ * than hanging when no persist ever carries them.
+ */
+import { describe, expect, it } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionPhase, MessageType, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { deepAgentExecutionRecord } from "../../activities/execute-deep-agent/__test-utils__/hermetic-deep-agent.js";
+
+function statusWith(rows: Array<{ id: string; status: ToolCallStatus; subAgent?: boolean }>) {
+  const message = (ids: typeof rows) => ({
+    type: MessageType.MESSAGE_AI,
+    content: "",
+    toolCalls: ids.map((r) => ({ id: r.id, name: "probe", status: r.status })),
+  });
+  return create(AgentExecutionStatusSchema, {
+    phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+    messages: [message(rows.filter((r) => !r.subAgent))],
+    subAgentExecutions: rows.some((r) => r.subAgent)
+      ? [{ id: "task-1", name: "helper", messages: [message(rows.filter((r) => r.subAgent))] }]
+      : [],
+  });
+}
+
+describe("ExecutionRecord.whenToolCallsSettled", () => {
+  it("resolves at once for no ids, and for ids already persisted settled", async () => {
+    const record = deepAgentExecutionRecord({ message: "go" });
+    await expect(record.whenToolCallsSettled([])).resolves.toBeUndefined();
+
+    record.applyStatusUpdate(statusWith([{ id: "c-1", status: ToolCallStatus.TOOL_CALL_COMPLETED }]));
+    await expect(record.whenToolCallsSettled(["c-1"])).resolves.toBeUndefined();
+  });
+
+  it("waits through a RUNNING persist and releases on the persist that settles the row", async () => {
+    const record = deepAgentExecutionRecord({ message: "go" });
+    let released = false;
+    const barrier = record.whenToolCallsSettled(["c-1"]).then(() => {
+      released = true;
+    });
+
+    record.applyStatusUpdate(statusWith([{ id: "c-1", status: ToolCallStatus.TOOL_CALL_RUNNING }]));
+    await Promise.resolve();
+    expect(released, "a RUNNING row is not settled").toBe(false);
+
+    record.applyStatusUpdate(statusWith([{ id: "c-1", status: ToolCallStatus.TOOL_CALL_WAITING_APPROVAL }]));
+    await barrier;
+    expect(released).toBe(true);
+  });
+
+  it("finds a sub-agent's rows in its own transcript", async () => {
+    const record = deepAgentExecutionRecord({ message: "go" });
+    record.applyStatusUpdate(
+      statusWith([
+        { id: "task-1", status: ToolCallStatus.TOOL_CALL_RUNNING },
+        { id: "sub-1", status: ToolCallStatus.TOOL_CALL_COMPLETED, subAgent: true },
+      ]),
+    );
+    await expect(record.whenToolCallsSettled(["sub-1"])).resolves.toBeUndefined();
+  });
+
+  it("fails naming the ids still open when no persist ever settles them, instead of hanging", async () => {
+    const record = deepAgentExecutionRecord({ message: "go" });
+    record.applyStatusUpdate(statusWith([{ id: "c-1", status: ToolCallStatus.TOOL_CALL_RUNNING }]));
+    await expect(record.whenToolCallsSettled(["c-1", "c-2"], 20)).rejects.toThrow(/c-1, c-2 never settled/);
+  });
+});

package/src/__test-utils__/__tests__/harness-contract-self-check.test.ts

@@ -27,7 +27,9 @@
 
 import { describe, it, expect } from "vitest";
 import { CancelledFailure } from "@temporalio/activity";
+import { create } from "@bufbuild/protobuf";
 import { ApprovalAction, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { SubAgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/subagent_pb";
 
 import type { HarnessAdapter, TurnInput, TurnOutcome, TurnSink } from "../../harness/types.js";
 import {
@@ -41,11 +43,12 @@ import {
   assertStopSignalInterrupts,
   assertUsageReachesSinkAsDeltas,
 } from "../harness-contract/contract.js";
+import { assertTranscriptStreamsNothing } from "../harness-contract/runtime-contract.js";
 import { scriptedSubject } from "../harness-contract/scripted-adapter.js";
 import type { ScriptedSubject } from "../harness-contract/scripted-adapter.js";
 import { scenario } from "../harness-contract/types.js";
 import type { EngineView, HarnessContractSubject, TurnScenario } from "../harness-contract/types.js";
-import { findToolCallRow } from "../proto-helpers.js";
+import { aiMessage, emptyStatus, findToolCallRow, toolCall } from "../proto-helpers.js";
 
 /** Short enough to keep this file fast; long enough that an honest microtask settle never trips it. */
 const SHORT_BOUND_MS = 100;
@@ -75,6 +78,7 @@ function adapterOver(inner: HarnessAdapter, name: string, patch: Partial<Harness
 function sinkOver(inner: TurnSink, patch: Partial<TurnSink>): TurnSink {
   return {
     status: inner.status,
+    transcript: inner.transcript,
     stopSignal: inner.stopSignal,
     setupTiming: inner.setupTiming,
     requestPersist: () => inner.requestPersist(),
@@ -324,3 +328,33 @@ describe("harness contract kit self-check — the driver stands in for the runti
     expect(turn.sink.status.messages.map((m) => m.content), "the stop landed in the hang, after the setup step and before the step after it").toEqual(["setting up"]);
   });
 });
+
+// ── The runtime half's transcript fact ──────────────────────────────────────
+
+describe("harness contract kit self-check — the settled-transcript assertion can fail", () => {
+  it("passes a transcript with every flag off", () => {
+    const status = emptyStatus();
+    const message = aiMessage("done");
+    message.toolCalls.push(toolCall("t-1", "read", ToolCallStatus.TOOL_CALL_COMPLETED));
+    status.messages.push(message);
+    expect(() => assertTranscriptStreamsNothing("honest", status)).not.toThrow();
+  });
+
+  it("names a message left streaming", () => {
+    const status = emptyStatus();
+    const message = aiMessage("still typing");
+    message.isStreaming = true;
+    status.messages.push(message);
+    expect(() => assertTranscriptStreamsNothing("broken:streams", status)).toThrow(/broken:streams: a settled turn's transcript is still streaming at messages\[0\]/);
+  });
+
+  it("names a tool-call row left streaming, inside a sub-agent's transcript", () => {
+    const status = emptyStatus();
+    const row = toolCall("t-2", "shell");
+    row.isStreaming = true;
+    const message = aiMessage("");
+    message.toolCalls.push(row);
+    status.subAgentExecutions.push(create(SubAgentExecutionSchema, { id: "sub-1", messages: [message] }));
+    expect(() => assertTranscriptStreamsNothing("broken:streams", status)).toThrow(/subAgentExecutions\[sub-1\]\.messages\[0\]\.toolCalls\[t-2\]/);
+  });
+});

package/src/__test-utils__/approval-contract/contract.ts

@@ -90,7 +90,7 @@ export function describeGatewayContract(substrate: GatewaySubstrate): void {
     // effect is always auditable to the policy layer that governed it. Gated to
     // substrates that decide the source at the gate (the deep-agent gate); the
     // Cursor substrate projects provenance at reconstruction time and is covered
-    // by the message-translator + corpus suites.
+    // by the translator + boundary-rows + corpus suites.
     if (substrate.capabilities.surfacesGatePolicySource) {
       it("tags every gated side effect with a non-UNSPECIFIED policy source", async () => {
         for (const action of [WRITE_A, SHELL, DELETE]) {

package/src/__test-utils__/approval-contract/types.ts

@@ -137,7 +137,7 @@ export interface SubstrateCapabilities {
    * and stamps the source at interrupt time (`true`); the Cursor substrate's
    * provenance is a reconstruction-time projection over the persisted tool call,
    * not a property of the hook's deny decision, so it is `false` here and is
-   * covered instead by the message-translator and corpus suites.
+   * covered instead by the translator, boundary-rows and corpus suites.
    */
   readonly surfacesGatePolicySource: boolean;
 }

package/src/__test-utils__/harness-boot-order-child.ts

@@ -15,7 +15,7 @@
  *    a bound token ref. Success means the pre-boot graph was connect-free,
  *    both interceptors installed, `assertHttp2ConnectPatched` passed, the
  *    Cursor SDK slice loaded from inside its `boot`, and the native
- *    deep-agent adapter (the table's second row since S3 M2b) registered its
+ *    deep-agent adapter (the table's second row since #1096) registered its
  *    profiles and loaded LangChain after the patch. That neither engine is
  *    on the table's STATIC graph is each adapter's own fence
  *    (`adapter-graph-is-sdk-free.test.ts`); this child proves the boot

package/src/__test-utils__/harness-contract/contract.ts

@@ -38,7 +38,7 @@
  *     is carried to COMPLETED; with REJECT or SKIP → never executes and the
  *     turn continues (the row's SKIPPED status is the runtime's to write,
  *     `harness/approval-decisions.ts`, proven in the runtime half — the
- *     driver stands in for that write between turns, Q-M1-3); reinvoked again
+ *     driver stands in for that write between turns); reinvoked again
  *     after the approval → still once, never re-gated.
  *  4. Aborting `stopSignal` mid-hang settles `runTurn` as `interrupted` within
  *     {@link INTERRUPT_SETTLE_BOUND_MS} and nothing after the stop executes or
@@ -48,8 +48,8 @@
  *     executes on the resumed turn is the pause primitive's business — an
  *     interrupt engine completes the pending task before its model speaks,
  *     a deny-and-retry engine re-reaches it whenever its model does — so it
- *     is below the contract line (S3 M3 Q-M3-2; each harness's own kit file
- *     observes its order).
+ *     is below the contract line (each harness's own kit file observes its
+ *     order).
  *  5. Usage reaches the sink as non-negative deltas summing to what the engine
  *     emitted.
  *  6. Capability and behaviour agree on the state id: an `engine-minted`
@@ -154,7 +154,7 @@ export class ExecutionDriver {
 
   /** Start a turn without awaiting it, for invariants about turns in flight. */
   begin(turn: TurnScenario, options: TurnOptions = {}): TurnInFlight {
-    const sink = options.sink ?? new RecordingTurnSink({ status: this.seedStatus() });
+    const sink = options.sink ?? new RecordingTurnSink({ status: this.seedStatus(), executionId: this.executionId });
     // The engine's view and the record's copy both derive from the status
     // this turn folds into, so a prepared sink's status is honoured too.
     const view: EngineView = {
@@ -297,7 +297,7 @@ export async function assertEveryExitIsAnOutcome(subject: HarnessContractSubject
     driver.recordTurn(sink);
   }
 
-  const preAborted = new RecordingTurnSink({ status: driver.seedStatus() });
+  const preAborted = new RecordingTurnSink({ status: driver.seedStatus(), executionId: driver.executionId });
   preAborted.abort("kit: aborted before the turn");
   const { settled } = driver.begin([scenario.say("never")], { sink: preAborted });
   await settleAsOutcome(subject, settleWithinBound(subject, settled, "under a pre-aborted signal", boundMs), "under a pre-aborted signal");
@@ -335,8 +335,8 @@ export async function assertProposalIsWaitingAndUnexecuted(subject: HarnessContr
  * turn continues — the row's terminal status is NOT asserted here because
  * it is not the adapter's to write (the decision is the server's field and
  * the WAITING → SKIPPED transition follows from it with no engine knowledge,
- * so it is the runtime's — `terminalizeNonExecutingDecisions`, landed at
- * S3 M1 and pinned by the runtime half's REJECT / SKIP arms; S2 M4 Q-M4-1).
+ * so it is the runtime's — `terminalizeNonExecutingDecisions`, landed in
+ * #1096 and pinned by the runtime half's REJECT / SKIP arms).
  * The reinvocation sees a CLONE of the persisted status, as it would from
  * the server.
  */
@@ -391,7 +391,7 @@ export async function assertStopSignalInterrupts(subject: HarnessContractSubject
   expect(findToolCallRow(hanging.sink.status, id), `${subject.name}: nothing after the stop may even reach the gate — the proposal after the hang has no row`).toBeUndefined();
   driver.recordTurn(hanging.sink);
 
-  const preAborted = new RecordingTurnSink({ status: driver.seedStatus() });
+  const preAborted = new RecordingTurnSink({ status: driver.seedStatus(), executionId: driver.executionId });
   preAborted.abort("kit: aborted before the turn");
   const early = driver.begin([scenario.propose(id, WRITE_ALPHA)], { sink: preAborted });
   const earlyOutcome = await settleWithinBound(subject, early.settled, "under a pre-aborted signal", boundMs);

package/src/__test-utils__/harness-contract/recording-sink.ts

@@ -20,6 +20,7 @@
 
 import type { AgentExecutionStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 
+import { TranscriptBuilder } from "../../harness/transcript/builder.js";
 import type { TurnSink, UsageDelta } from "../../harness/types.js";
 import type { CasTouchedReader } from "../../shared/filereview/cas-touched.js";
 import { TimingRecorder } from "../../shared/cold-start-timing.js";
@@ -35,14 +36,22 @@ export type SinkEvent =
   | { readonly kind: "cas-observations" };
 
 export interface RecordingTurnSinkOptions {
-  /** The status this turn folds into; a fresh empty one when omitted. */
+  /**
+   * The status this turn folds into; a fresh empty one when omitted. A
+   * reinvocation's clone arrives already carrying last turn's rows, and the
+   * builder indexes them as the runtime's would after its seed.
+   */
   readonly status?: AgentExecutionStatus;
+  /** The execution the builder names in its log lines; the kit's driver passes its own. */
+  readonly executionId?: string;
   /** When set, `bindHarnessState` rejects with this error (a failed session write). */
   readonly bindRejectsWith?: Error;
 }
 
 export class RecordingTurnSink implements TurnSink {
   readonly status: AgentExecutionStatus;
+  /** The one builder over `status`, as the runtime hands every adapter; the fake creates its rows through it. */
+  readonly transcript: TranscriptBuilder;
   readonly stopSignal: AbortSignal;
   readonly setupTiming = new TimingRecorder();
 
@@ -52,6 +61,7 @@ export class RecordingTurnSink implements TurnSink {
 
   constructor(options: RecordingTurnSinkOptions = {}) {
     this.status = options.status ?? emptyStatus();
+    this.transcript = new TranscriptBuilder(options.executionId ?? "kit-exec", this.status);
     this.stopSignal = this.controller.signal;
     this.bindRejectsWith = options.bindRejectsWith;
   }

package/src/__test-utils__/harness-contract/runtime-contract.ts

@@ -19,7 +19,9 @@
  * the facts the runtime owes on it: the terminal phase, the copy
  * (`terminal-table.ts` `TERMINAL_COPY`, byte-pinned), `status.error`,
  * `completedAt`, "the step after never runs", the whole-activity heartbeat,
- * one bind for an engine-minted harness, the slim return. What is NOT
+ * one bind for an engine-minted harness, the slim return, and — on every
+ * arm, whatever the outcome — a transcript that streams nothing once the
+ * turn has settled ({@link assertTranscriptStreamsNothing}). What is NOT
  * asserted here is engine cadence — how many IN_PROGRESS persists precede
  * the WAITING write, the exact setup labels beyond the runtime's own, the
  * exact price a vendor's table yields — because those are a subject's facts;
@@ -216,13 +218,47 @@ export class RuntimeExecutionDriver {
   }
 }
 
-/** The final full status the record holds; an arm that persisted nothing is a failure, named. */
+/**
+ * The final full status the record holds, checked for the one fact every
+ * settled turn owes its transcript before the arm reads anything else. An
+ * arm that persisted nothing is a failure, named.
+ */
 function finalStatusOf(harness: RuntimeContractHarness, driver: RuntimeExecutionDriver): AgentExecutionStatus {
   const final = driver.record.lastFullStatus;
   if (!final) throw new Error(`${harness.subject.name}: the runtime persisted no full status`);
+  assertTranscriptStreamsNothing(harness.subject.name, final);
   return final;
 }
 
+/**
+ * No streaming flag survives a settled turn — on any message, any tool-call
+ * row, in the root transcript or a sub-agent's — however the turn ended. A
+ * flag left on is a spinner the console never stops. The runtime closes
+ * them once, after `runTurn` returns, on every path (`harness/run-turn.ts`),
+ * so the fact holds for every subject and every outcome, and every arm
+ * checks it through {@link finalStatusOf}. Before the runtime owned that
+ * close, this fired on both real adapters' internal-failure arm: a turn that
+ * failed before its settle left its last message streaming. Exported so the
+ * kit's self-check can hand it a status that still streams and prove it
+ * fires.
+ */
+export function assertTranscriptStreamsNothing(subjectName: string, status: AgentExecutionStatus): void {
+  const streaming: string[] = [];
+  const sweep = (scope: string, messages: AgentExecutionStatus["messages"]): void => {
+    messages.forEach((m, i) => {
+      if (m.isStreaming) streaming.push(`${scope}messages[${i}]`);
+      for (const tc of m.toolCalls) {
+        if (tc.isStreaming) streaming.push(`${scope}messages[${i}].toolCalls[${tc.id}]`);
+      }
+    });
+  };
+  sweep("", status.messages);
+  for (const sub of status.subAgentExecutions) sweep(`subAgentExecutions[${sub.id}].`, sub.messages);
+  if (streaming.length > 0) {
+    throw new Error(`${subjectName}: a settled turn's transcript is still streaming at ${streaming.join(", ")}`);
+  }
+}
+
 /** What every arm hands back so a subject's file can add its own facts. */
 export interface RuntimeArmResult {
   readonly driver: RuntimeExecutionDriver;
@@ -357,11 +393,11 @@ export async function assertFileReviewRoundTrip(harness: RuntimeContractHarness,
   expect(rows.get(keepId)?.fileChangeSetId, `${subject.name}: a flowed row is badged with the change set`).toBe(changeSetId);
   expect(rows.get(dropId)?.fileChangeSetId).toBe(changeSetId);
   expect(rows.get(keepId)?.status, `${subject.name}: a flowed row is COMPLETED, never gated`).toBe(ToolCallStatus.TOOL_CALL_COMPLETED);
-  // The strip is the runtime's, attached on its writes (Q-M4-7). Its COUNT is
+  // The strip is the runtime's, attached on its writes. Its COUNT is
   // the capture floor's: a real engine's first persist precedes its first
   // write and both writes land within one floor interval, so the pause can
-  // honestly read "0 files" beside a two-file candidate (F-M4-3, recorded
-  // for S5: whether the terminal write should bypass the floor). The arm
+  // honestly read "0 files" beside a two-file candidate (#1114: whether the
+  // terminal write should bypass the floor). The arm
   // asserts the ownership, not the floor.
   expect(afterCapture.fileChangeProgress?.changeSetId, `${subject.name}: the runtime carries this turn's strip`).toBe(changeSetId);
   expect(afterCapture.completedAt, `${subject.name}: a review pause is not complete`).toBe("");
@@ -374,7 +410,7 @@ export async function assertFileReviewRoundTrip(harness: RuntimeContractHarness,
   const second = await driver.turn([]);
   expect(slimOf(subject, second).phase, `${subject.name}: a pure file-review resume completes without the engine`).toBe("EXECUTION_COMPLETED");
   // The kept file is the engine-not-re-run witness: a subject that counts
-  // executions by reading its ledger off disk (the native one, Q-M3-4) reads
+  // executions by reading its ledger off disk (the native one) reads
   // the DISCARDED file's count as 0 now, because the reconcile just restored
   // that file to its baseline — which is the reconcile working, not the
   // engine forgetting.
@@ -398,7 +434,7 @@ export async function assertFileReviewRoundTrip(harness: RuntimeContractHarness,
  * settles the row SKIPPED (a REJECT row carries `error: "Rejected by user"`),
  * so no WAITING row survives on a finished execution. This is the proto
  * contract as of stigmer#197 and the runtime's own write
- * (`harness/approval-decisions.ts`); before S3 M1 the runtime FAILED a
+ * (`harness/approval-decisions.ts`); before #1096 the runtime FAILED a
  * REJECTed reinvocation before any engine ran.
  */
 export async function assertNonExecutingDecisionSettlesSkipped(
@@ -440,14 +476,14 @@ export async function assertNonExecutingDecisionSettlesSkipped(
  * the next message), `error` starting with the cross-repo prefix Stigmer
  * Cloud's channel delivery matches on, the user copy as the one system row,
  * `completedAt` stamped, RETURNED (a retry would spend the same budget), and
- * the step after the limit never processed. Before S3 M1 the native harness
- * RETURNED this terminal without persisting it (M0 finding F-M0-4); the
+ * the step after the limit never processed. Before #1096 the native harness
+ * RETURNED this terminal without persisting it; the
  * runtime's arm is the one persisted terminal.
  *
  * The execution SETS the budget it exhausts: the record carries the smallest
  * valid `max_tool_rounds` (an unbounded execution has no limit to reach — on
  * native `resolveRecursionLimit(0)` is unlimited, and the first run of this
- * arm against it spun until the test timed out; S3 M3 F-M3-3). The fake
+ * arm against it spun until the test timed out). The fake
  * exhausts whatever budget it is given; a real engine spins its cheapest
  * ungated tool until the graph stops it.
  */
@@ -625,12 +661,12 @@ const STALL_CLOCK_INTERVAL_MS = 25;
  * park is reported while the chunks the engine produced before parking are
  * still in its event pipeline ahead of the adapter's loop, so activity marks
  * land AFTER a single tick and a frozen clock reads idle 0 from then on
- * (S3 M3 F-M3-5, measured on the native adapter: 35 marks at the park, 37
+ * (measured on the native adapter: 35 marks at the park, 37
  * within 10 ms). A pull-based double's park implies everything before it
  * was seen; a real stall is wall time passing while the engine is silent,
  * whichever shape the engine has. The interval advances a SCRIPTED clock —
  * the kit's rule against timers is about stopping a turn on a guess, which
- * this never does (Q-M3-7).
+ * this never does.
  */
 export async function assertStallFailsTheTurn(harness: RuntimeContractHarness, label = "rt-stall"): Promise<RuntimeArmResult> {
   const { subject, clock } = harness;
@@ -692,7 +728,7 @@ export async function assertCostCapTerminates(harness: RuntimeContractHarness, l
 /**
  * A platform STOP answered to a mid-turn persist: the turn completes early
  * with the platform-stop row and no error, and the step after the STOP never
- * runs — the awaited `requestPersist` at work (Q-M3-2). The persist the
+ * runs — the awaited `requestPersist` at work. The persist the
  * control plane answers is the one carrying a completed `read`: the discrete
  * event every harness flushes on (the Cursor golden's lever), where a bare
  * assistant message may ride an engine's cadence to the settle persist, too
@@ -786,7 +822,7 @@ export async function assertFailedSurfaceWritesItsCopy(harness: RuntimeContractH
 
 /**
  * A rejected `bindHarnessState` (the session write refused) ends the turn
- * FAILED on the internal surface with nothing executed (Q-S2-11, R3).
+ * FAILED on the internal surface with nothing executed.
  * Engine-minted harnesses only: a deterministic one never binds.
  */
 export async function assertRejectedBindFails(harness: RuntimeContractHarness, label = "rt-bind-rejects"): Promise<RuntimeArmResult> {
@@ -884,7 +920,7 @@ export interface RuntimeContractOptions {
    * to wait for (`scenario.cancelled()`, an SDK-side cancel); the arm is
    * registered SKIPPED otherwise. On by default; the native subject turns it
    * off (no LangGraph path ends a turn `cancelled` — a stop is the runtime's
-   * and settles `interrupted`; S3 M3 F-M3-2).
+   * and settles `interrupted`).
    */
   readonly engineCancel?: boolean;
 }
@@ -968,7 +1004,7 @@ export function describeHarnessRuntimeContract(harness: RuntimeContractHarness,
         await assertFailedSurfaceWritesItsCopy(harness, surface, FAILURE_MESSAGES[surface]);
       });
     }
-    it.skipIf(subject.adapter.capabilities.stateIdSource !== "engine-minted")("a rejected bindHarnessState ends the turn failed with nothing executed (Q-S2-11)", async () => {
+    it.skipIf(subject.adapter.capabilities.stateIdSource !== "engine-minted")("a rejected bindHarnessState ends the turn failed with nothing executed", async () => {
       clock.reset();
       await assertRejectedBindFails(harness);
     });

package/src/__test-utils__/harness-contract/scripted-adapter.ts

@@ -22,8 +22,12 @@
  *
  * What is deliberately simple here and would be real work in an adapter:
  * "executing" a side effect is incrementing a counter; the engine state id is
- * a counter too; the transcript rows are built with the shared proto
- * factories. What is NOT simplified is the contract behaviour itself —
+ * a counter too; there is no engine event to translate, so each step emits
+ * the canonical `TranscriptEvent`s a translator would (a run for a `say`, a
+ * start and a finish for a tool, a proposal for a gate) straight into
+ * `sink.transcript` — the one way any harness creates a transcript row, and
+ * the whole of what a real adapter's translator adds on top of this file.
+ * What is NOT simplified is the contract behaviour itself —
  * settling with an outcome and never rejecting, stopping at every step
  * boundary and inside a hang, binding before the first persist, executing an
  * approval exactly once, refusing to resume a state it never minted — because
@@ -34,8 +38,8 @@
  * is on the row (the server's field) and the transition follows from it with
  * no engine knowledge, so it belongs to the runtime — one writer per field,
  * as `approvalDecisionsOf` is the runtime's one reader and
- * `terminalizeNonExecutingDecisions` its one writer (S2 M4, Q-M4-1; landed at
- * S3 M1, `harness/approval-decisions.ts`). An adapter's whole duty for a
+ * `terminalizeNonExecutingDecisions` its one writer (landed in #1096,
+ * `harness/approval-decisions.ts`). An adapter's whole duty for a
  * non-executing decision is to not execute.
  *
  * Scenarios are arranged PER SESSION (the engine is per session in every real
@@ -57,7 +61,7 @@ import type { HarnessAdapter, TurnInput, TurnOutcome, TurnSink } from "../../har
 import { DEEP_AGENT_VISION_PROFILE } from "../../shared/attachment-vision.js";
 import type { ProposedAction } from "../approval-contract/types.js";
 import { testConfig } from "../config-fixture.js";
-import { aiMessage, findToolCallRow, toolCall, waitingToolCall } from "../proto-helpers.js";
+import { findToolCallRow } from "../proto-helpers.js";
 import type { EngineView, HarnessContractSubject, ScenarioStep, TurnScenario } from "./types.js";
 
 export interface ScriptedHarnessOptions {
@@ -101,6 +105,8 @@ export class ScriptedHarnessAdapter implements HarnessAdapter {
   private readonly executions = new Map<string, number>();
   private readonly hangWaiters: Array<() => void> = [];
   private mintCounter = 0;
+  /** One `runId` per `say`, as an engine mints one per model run; the builder keys a message on it. */
+  private runCounter = 0;
 
   constructor(options: ScriptedHarnessOptions) {
     this.name = options.name ?? `scripted(${options.pausePrimitive}, ${options.stateIdSource})`;
@@ -211,7 +217,12 @@ export class ScriptedHarnessAdapter implements HarnessAdapter {
   private async play(step: ScenarioStep, input: TurnInput, sink: TurnSink): Promise<TurnOutcome | undefined> {
     switch (step.kind) {
       case "say": {
-        sink.status.messages.push(aiMessage(step.text));
+        // One model run: start, its text, finish — the shape every
+        // translator emits for an assistant message.
+        const runId = `run-${++this.runCounter}`;
+        sink.transcript.apply({ kind: "message_start", runId });
+        sink.transcript.apply({ kind: "text_delta", runId, text: step.text });
+        sink.transcript.apply({ kind: "message_finish", runId });
         sink.recordActivity();
         // Awaited, as the Cursor loop awaits its own: a platform STOP the
         // runtime reads from this write aborts the signal before the next
@@ -223,14 +234,12 @@ export class ScriptedHarnessAdapter implements HarnessAdapter {
         if (step.flows) return this.flowingWrite(step.toolCallId, step.action, input, sink);
         return this.propose(step.toolCallId, step.action, input, sink);
       case "read": {
-        // Ungated: the row lands COMPLETED at once, the effect counts as run,
-        // and the persist is awaited like `say`'s — a real engine's tool call
-        // is the discrete event its loop flushes on.
-        const message = aiMessage("");
-        const row = toolCall(step.toolCallId, "read", ToolCallStatus.TOOL_CALL_COMPLETED);
-        row.result = `contents of ${step.path}`;
-        message.toolCalls.push(row);
-        sink.status.messages.push(message);
+        // Ungated: the row starts and finishes at once, the effect counts as
+        // run, and the persist is awaited like `say`'s — a real engine's tool
+        // call is the discrete event its loop flushes on. The builder puts
+        // the row on the message whose text preceded it.
+        sink.transcript.apply({ kind: "tool_started", callId: step.toolCallId, name: "read", input: { path: step.path }, mcpServerSlug: "" });
+        sink.transcript.apply({ kind: "tool_finished", callId: step.toolCallId, result: `contents of ${step.path}` });
         this.executions.set(step.toolCallId, this.executionCount(step.toolCallId) + 1);
         sink.recordActivity("read");
         await sink.requestPersist();
@@ -279,12 +288,18 @@ export class ScriptedHarnessAdapter implements HarnessAdapter {
     switch (decision) {
       case ApprovalAction.UNSPECIFIED: {
         // Propose: surface the gated call as a WAITING row and stop the turn.
-        // Never write a second row for the same id on a resumed turn.
-        if (!existing) {
-          const message = aiMessage("");
-          message.toolCalls.push(waitingToolCall(toolCallId, action.kind, `Approve ${action.kind} ${action.resource}?`));
-          sink.status.messages.push(message);
-        }
+        // `approval_proposed` is an upsert by id — a resumed turn that
+        // re-proposes reopens the seeded row, never writes a second one. No
+        // `args` on purpose: a `write` carrying whole-file content would make
+        // the runtime's exact-apply eligible on APPROVE, and this fake's
+        // execution count would then measure a path the engine never ran.
+        sink.transcript.apply({
+          kind: "approval_proposed",
+          callId: toolCallId,
+          name: action.kind,
+          mcpServerSlug: "",
+          message: `Approve ${action.kind} ${action.resource}?`,
+        });
         sink.recordActivity();
         sink.requestPersist();
         return { kind: "awaiting_approval" };
@@ -292,7 +307,7 @@ export class ScriptedHarnessAdapter implements HarnessAdapter {
       case ApprovalAction.APPROVE:
       case ApprovalAction.APPROVE_ALL: {
         this.executions.set(toolCallId, this.executionCount(toolCallId) + 1);
-        this.completeRow(existing, toolCallId, action, sink);
+        this.completeRow(toolCallId, action, sink);
         return undefined;
       }
       case ApprovalAction.SKIP:
@@ -321,11 +336,8 @@ export class ScriptedHarnessAdapter implements HarnessAdapter {
     const file = join(input.workspace.primaryDir, action.resource);
     await mkdir(dirname(file), { recursive: true });
     await writeFile(file, `${toolCallId}\n`);
-    const message = aiMessage("");
-    const row = toolCall(toolCallId, "write", ToolCallStatus.TOOL_CALL_COMPLETED);
-    row.args = { path: action.resource };
-    message.toolCalls.push(row);
-    sink.status.messages.push(message);
+    sink.transcript.apply({ kind: "tool_started", callId: toolCallId, name: "write", input: { path: action.resource }, mcpServerSlug: "" });
+    sink.transcript.apply({ kind: "tool_finished", callId: toolCallId, result: "" });
     this.executions.set(toolCallId, this.executionCount(toolCallId) + 1);
     sink.recordActivity("write");
     await sink.requestPersist();
@@ -333,22 +345,14 @@ export class ScriptedHarnessAdapter implements HarnessAdapter {
   }
 
   /**
-   * Report the executed action on its row, as a real engine's completion
-   * event does. The row normally exists (the runtime seeded the status with
-   * last turn's WAITING row); a decision with no row is a runtime that decided
-   * out of band, and the adapter still records what happened rather than
-   * losing the fact.
+   * Report the executed action on its row, as a real engine's re-issue does:
+   * a start (which flips the seeded WAITING row to RUNNING — or creates the
+   * row when a runtime decided out of band and no row exists, so the fact is
+   * recorded rather than lost) and a finish.
    */
-  private completeRow(existing: ToolCall | undefined, toolCallId: string, action: ProposedAction, sink: TurnSink): void {
-    if (existing) {
-      existing.status = ToolCallStatus.TOOL_CALL_COMPLETED;
-    } else {
-      const message = aiMessage("");
-      const row = waitingToolCall(toolCallId, action.kind, "");
-      row.status = ToolCallStatus.TOOL_CALL_COMPLETED;
-      message.toolCalls.push(row);
-      sink.status.messages.push(message);
-    }
+  private completeRow(toolCallId: string, action: ProposedAction, sink: TurnSink): void {
+    sink.transcript.apply({ kind: "tool_started", callId: toolCallId, name: action.kind, input: {}, mcpServerSlug: "" });
+    sink.transcript.apply({ kind: "tool_finished", callId: toolCallId, result: "" });
     sink.recordActivity();
     sink.requestPersist();
   }
@@ -360,8 +364,8 @@ export interface ScriptedSubject extends HarnessContractSubject {
 }
 
 /**
- * The fake declares the `deep-agent` row: in S2 the runtime served that row
- * through this fake alone; since S3 M3 the real native adapter takes it over
+ * The fake declares the `deep-agent` row: in #1070 the runtime served that row
+ * through this fake alone; since #1096 the real native adapter takes it over
  * in the runtime half
  * (`execute-deep-agent/__test-utils__/contract-subject.ts`), and the fake
  * keeps declaring it so the kit's self-check runs a full subject under both