@stigmer/runner 3.1.3 → 3.1.4

package/dist/shared/tool-row.d.ts

@@ -115,3 +115,19 @@ export declare function isToolCallRowHidden(tc: ToolCall): boolean;
  * none; Cursor clones them in) — the snapshot reflects whatever is present.
  */
 export declare function collectSubAgentToolCallIds(subAgents: readonly SubAgentExecution[]): Set<string>;
+/**
+ * Collect the ids of tool-call rows that have already SETTLED (reached a terminal
+ * state: completed, failed, or skipped) in a transcript.
+ *
+ * The deep-agent turn-boundary provenance derivation (DD-28) snapshots this
+ * BEFORE a turn's stream to scope "this turn's tool calls" by identity: a call
+ * whose id is absent from the snapshot is this-turn's — either freshly streamed,
+ * or a prior gate that was WAITING_APPROVAL before the stream and executes now on
+ * resume (StatusBuilder updates the seeded row in place, so it keeps its id).
+ * Unlike the Cursor harness, the deep-agent cannot scope positionally — an
+ * approved command executes at its SEEDED position — so identity is the only
+ * correct scope, mirroring {@link collectSubAgentToolCallIds}. Terminal (not just
+ * completed) so a PRIOR turn's failed/skipped non-shell call is excluded and
+ * cannot spuriously disqualify this turn.
+ */
+export declare function collectSettledToolCallIds(messages: readonly AgentMessage[]): Set<string>;

package/dist/shared/tool-row.js

@@ -173,4 +173,35 @@ export function collectSubAgentToolCallIds(subAgents) {
     }
     return ids;
 }
+/** Terminal tool-call statuses — a row that has finished (however it finished). */
+const TERMINAL_TOOL_CALL_STATUSES = new Set([
+    ToolCallStatus.TOOL_CALL_COMPLETED,
+    ToolCallStatus.TOOL_CALL_FAILED,
+    ToolCallStatus.TOOL_CALL_SKIPPED,
+]);
+/**
+ * Collect the ids of tool-call rows that have already SETTLED (reached a terminal
+ * state: completed, failed, or skipped) in a transcript.
+ *
+ * The deep-agent turn-boundary provenance derivation (DD-28) snapshots this
+ * BEFORE a turn's stream to scope "this turn's tool calls" by identity: a call
+ * whose id is absent from the snapshot is this-turn's — either freshly streamed,
+ * or a prior gate that was WAITING_APPROVAL before the stream and executes now on
+ * resume (StatusBuilder updates the seeded row in place, so it keeps its id).
+ * Unlike the Cursor harness, the deep-agent cannot scope positionally — an
+ * approved command executes at its SEEDED position — so identity is the only
+ * correct scope, mirroring {@link collectSubAgentToolCallIds}. Terminal (not just
+ * completed) so a PRIOR turn's failed/skipped non-shell call is excluded and
+ * cannot spuriously disqualify this turn.
+ */
+export function collectSettledToolCallIds(messages) {
+    const ids = new Set();
+    for (const msg of messages) {
+        for (const tc of msg.toolCalls) {
+            if (TERMINAL_TOOL_CALL_STATUSES.has(tc.status))
+                ids.add(tc.id);
+        }
+    }
+    return ids;
+}
 //# sourceMappingURL=tool-row.js.map

package/dist/shared/tool-row.js.map

@@ -1 +1 @@
-{"version":3,"file":"tool-row.js","sourceRoot":"","sources":["../../src/shared/tool-row.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tool-row.js","sourceRoot":"","sources":["../../src/shared/tool-row.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigmer/runner",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "description": "Embeddable Temporal worker for the Stigmer AI agent platform — handles agent execution, workflow orchestration, and MCP server management",
   "license": "Apache-2.0",
   "type": "module",
@@ -85,7 +85,7 @@
     "@opentelemetry/sdk-metrics": "^2.0.0",
     "@opentelemetry/sdk-trace-base": "^2.0.0",
     "@opentelemetry/sdk-trace-node": "^2.0.0",
-    "@stigmer/protos": "3.1.3",
+    "@stigmer/protos": "3.1.4",
     "@temporalio/activity": "^1.11.0",
     "@temporalio/client": "^1.11.0",
     "@temporalio/common": "^1.11.0",

package/src/__tests__/otel-turn-span.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Spy span/tracer, hoisted so the vi.mock factory (which runs before imports)
+// can close over them without a temporal-dead-zone error.
+const { spanEnd, spanSetAttribute, startSpan } = vi.hoisted(() => {
+  const spanEnd = vi.fn();
+  const spanSetAttribute = vi.fn();
+  const startSpan = vi.fn(() => ({ end: spanEnd, setAttribute: spanSetAttribute }));
+  return { spanEnd, spanSetAttribute, startSpan };
+});
+
+vi.mock("@opentelemetry/api", () => ({
+  trace: { getTracer: () => ({ startSpan }) },
+}));
+
+import {
+  startCursorTurnSpan,
+  ATTR_LLM_INPUT_TOKENS,
+  ATTR_LLM_OUTPUT_TOKENS,
+} from "../otel.js";
+
+const spanAttrs = { model: "gpt-x", mode: "local", sessionId: "sess-1" };
+
+describe("startCursorTurnSpan", () => {
+  beforeEach(() => {
+    spanEnd.mockClear();
+    spanSetAttribute.mockClear();
+    startSpan.mockClear();
+  });
+
+  it("records the input and output token attributes", async () => {
+    const span = await startCursorTurnSpan(spanAttrs);
+    span.setTokens(1200, 340);
+    expect(spanSetAttribute).toHaveBeenCalledWith(ATTR_LLM_INPUT_TOKENS, 1200);
+    expect(spanSetAttribute).toHaveBeenCalledWith(ATTR_LLM_OUTPUT_TOKENS, 340);
+  });
+
+  it("omits zero-valued token attributes (no count = no attribute)", async () => {
+    const span = await startCursorTurnSpan(spanAttrs);
+    span.setTokens(0, 0);
+    expect(spanSetAttribute).not.toHaveBeenCalled();
+  });
+
+  it("ends the span exactly once even when end() is called repeatedly", async () => {
+    // finishTurnTelemetry is invoked from the activity's finally on every exit
+    // path; a second end() (e.g. a defensive double-invoke) must be a no-op so
+    // OTel never warns about ending an already-ended span.
+    const span = await startCursorTurnSpan(spanAttrs);
+    span.end();
+    span.end();
+    span.end();
+    expect(spanEnd).toHaveBeenCalledTimes(1);
+  });
+
+  it("ignores setTokens after the span has ended (no late mutation)", async () => {
+    const span = await startCursorTurnSpan(spanAttrs);
+    span.end();
+    span.setTokens(1200, 340);
+    expect(spanSetAttribute).not.toHaveBeenCalled();
+  });
+});

package/src/activities/execute-cursor/__tests__/progress-substrate.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Unit tests for the Cursor mid-run progress substrate selection (DD-33) —
+ * `buildCursorProgressSubstrate`. This is the Cursor adapter's responsibility:
+ * pick git / non-git CAS / hybrid for the turn's workspace shape (the CAS + git
+ * capture behaviors themselves are covered in shared/filereview/__tests__).
+ *
+ * The chosen substrate is driven against a real temp workspace to prove WHICH
+ * kind was built: a git-only substrate surfaces the tracked change; a hybrid adds
+ * the (empty here) CAS slice; a non-git substrate reads the (empty) hook sidecar
+ * without touching git.
+ */
+
+import { execFile } from "node:child_process";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { buildCursorProgressSubstrate } from "../capture-flow.js";
+import { snapshotBaseline, dropCaptureRefs } from "../../../shared/filereview/git-substrate.js";
+import { makeInMemoryArtifactStorage } from "../../../__test-utils__/fake-artifact-storage.js";
+
+const execFileAsync = promisify(execFile);
+const EXEC_ID = "exec-cursor-progress";
+
+let repo: string;
+let hitlDir: string;
+
+async function git(args: string[]): Promise<void> {
+  await execFileAsync("git", args, { cwd: repo });
+}
+
+async function write(rel: string, content: string): Promise<void> {
+  await mkdir(join(repo, rel, ".."), { recursive: true });
+  await writeFile(join(repo, rel), content, "utf-8");
+}
+
+beforeEach(async () => {
+  repo = await mkdtemp(join(tmpdir(), "cursor-progress-"));
+  hitlDir = await mkdtemp(join(tmpdir(), "cursor-progress-hitl-"));
+  await git(["init", "-q"]);
+  await git(["config", "user.email", "t@t.local"]);
+  await git(["config", "user.name", "t"]);
+  await write("src/main.ts", "export const x = 1;\n");
+  await git(["add", "-A"]);
+  await git(["commit", "-q", "-m", "initial"]);
+});
+
+afterEach(async () => {
+  await dropCaptureRefs(repo, EXEC_ID).catch(() => {});
+  await rm(repo, { recursive: true, force: true });
+  await rm(hitlDir, { recursive: true, force: true });
+});
+
+describe("buildCursorProgressSubstrate — selection", () => {
+  it("returns undefined outside capture mode", () => {
+    const sub = buildCursorProgressSubstrate({
+      captureMode: false,
+      gitWorkspace: true,
+      workspaceRoot: repo,
+      baselineTree: "sha",
+      executionId: EXEC_ID,
+      hitlDir,
+      storage: undefined,
+    });
+    expect(sub).toBeUndefined();
+  });
+
+  it("returns undefined with no workspace root", () => {
+    const sub = buildCursorProgressSubstrate({
+      captureMode: true,
+      gitWorkspace: true,
+      workspaceRoot: undefined,
+      baselineTree: "sha",
+      executionId: EXEC_ID,
+      hitlDir,
+      storage: undefined,
+    });
+    expect(sub).toBeUndefined();
+  });
+
+  it("returns undefined for a git tree with no baseline tree yet", () => {
+    const sub = buildCursorProgressSubstrate({
+      captureMode: true,
+      gitWorkspace: true,
+      workspaceRoot: repo,
+      baselineTree: undefined,
+      executionId: EXEC_ID,
+      hitlDir,
+      storage: undefined,
+    });
+    expect(sub).toBeUndefined();
+  });
+
+  it("returns undefined for a non-git workspace with no storage/sidecar", () => {
+    const sub = buildCursorProgressSubstrate({
+      captureMode: true,
+      gitWorkspace: false,
+      workspaceRoot: repo,
+      baselineTree: undefined,
+      executionId: EXEC_ID,
+      hitlDir: undefined,
+      storage: undefined,
+    });
+    expect(sub).toBeUndefined();
+  });
+
+  it("builds a git-only substrate (no storage) that surfaces the tracked change", async () => {
+    const baselineTree = await snapshotBaseline(repo, EXEC_ID);
+    const sub = buildCursorProgressSubstrate({
+      captureMode: true,
+      gitWorkspace: true,
+      workspaceRoot: repo,
+      baselineTree,
+      executionId: EXEC_ID,
+      hitlDir,
+      storage: undefined,
+    });
+    expect(sub).toBeDefined();
+
+    await write("src/main.ts", "export const x = 2;\nexport const y = 3;\n");
+    const { delta, changed } = await sub!.capture();
+    expect(changed).toBe(true);
+    expect(delta.entries.some((e) => e.pathAfter === "src/main.ts")).toBe(true);
+  });
+
+  it("builds a hybrid substrate (git + storage) surfacing the git slice + empty CAS", async () => {
+    const baselineTree = await snapshotBaseline(repo, EXEC_ID);
+    const { storage } = makeInMemoryArtifactStorage();
+    const sub = buildCursorProgressSubstrate({
+      captureMode: true,
+      gitWorkspace: true,
+      workspaceRoot: repo,
+      baselineTree,
+      executionId: EXEC_ID,
+      hitlDir,
+      storage,
+    });
+    expect(sub).toBeDefined();
+
+    await write("src/main.ts", "export const x = 9;\n");
+    const { delta } = await sub!.capture();
+    // The git slice contributes the tracked change; the CAS sidecar is empty, so
+    // it adds nothing — total equals the git entries.
+    expect(delta.entries.some((e) => e.pathAfter === "src/main.ts")).toBe(true);
+    expect(delta.totalFilesChanged).toBe(delta.entries.length);
+  });
+
+  it("builds a non-git CAS substrate that reads the (empty) sidecar without git", async () => {
+    const { storage } = makeInMemoryArtifactStorage();
+    const sub = buildCursorProgressSubstrate({
+      captureMode: true,
+      gitWorkspace: false,
+      workspaceRoot: repo,
+      baselineTree: undefined,
+      executionId: EXEC_ID,
+      hitlDir,
+      storage,
+    });
+    expect(sub).toBeDefined();
+
+    // Even with a git change on disk, the non-git substrate ignores git entirely;
+    // the sidecar is empty, so it reports zero changed files.
+    await write("src/main.ts", "export const x = 42;\n");
+    const { delta } = await sub!.capture();
+    expect(delta.totalFilesChanged).toBe(0);
+    expect(delta.entries).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,349 @@
+/**
+ * Unit tests for the Cursor harness's shared stream seam (turn-stream.ts).
+ *
+ * These lock the behaviors the old bare retry loops used to DROP — live persist,
+ * DD-32/DD-33 mid-run progress, sub-agent tracking, the first-denial early stop,
+ * and correct pause/platform-stop mapping — so that unifying the primary turn and
+ * both recovery retries onto this one loop cannot silently regress any of them.
+ *
+ * The loop is driven with a structural `mockRun` (an async-iterable `.stream()`)
+ * and injected `heartbeat`/`isCancelled`, so it runs without the live Cursor SDK
+ * or Temporal — mirroring the deep-agent `streaming.test.ts` pattern.
+ */
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionControlSignal } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { CancelledFailure } from "@temporalio/activity";
+import type { SDKMessage } from "@cursor/sdk";
+import {
+  consumeCursorTurnStream,
+  makeCursorTurnOnDelta,
+  newTurnStreamState,
+  type CursorTurnStreamDeps,
+  type StreamableRun,
+  type TurnStreamState,
+} from "../turn-stream.js";
+import type { ProgressSubstrate } from "../../../shared/filereview/progress.js";
+
+// A stream event is only inspected by the loop for `type`/`name`/`status`/
+// `message`; the accumulator (stubbed) owns the rest, so a minimal cast is safe.
+function ev(obj: Record<string, unknown>): SDKMessage {
+  return obj as unknown as SDKMessage;
+}
+
+async function* asyncIter(events: SDKMessage[]): AsyncIterable<SDKMessage> {
+  for (const e of events) yield e;
+}
+
+interface MockRun extends StreamableRun {
+  cancel: ReturnType<typeof vi.fn>;
+}
+
+function mockRun(events: SDKMessage[]): MockRun {
+  return {
+    stream: () => asyncIter(events),
+    supports: () => true,
+    cancel: vi.fn(async () => {}),
+  };
+}
+
+function stubAccumulator(overrides: Record<string, unknown> = {}) {
+  return {
+    processEvent: vi.fn(),
+    trackSubAgentExecution: vi.fn(),
+    finalize: vi.fn(),
+    markPersisted: vi.fn(),
+    cancelInProgressSubAgents: vi.fn(),
+    isDirty: true,
+    subAgentExecutions: [],
+    ...overrides,
+  };
+}
+
+function stubEnricher() {
+  return {
+    processDelta: vi.fn(),
+    applyEnrichments: vi.fn(),
+    finalize: vi.fn(),
+    markPersisted: vi.fn(),
+    isDirty: false,
+  };
+}
+
+function stubUsageAccumulator() {
+  return {
+    addTurn: vi.fn(),
+    // hasTurns:false keeps the loop from building a StreamingUsageSummary (which
+    // would need a real snapshot); usage plumbing is covered by usage-accumulator's
+    // own tests.
+    hasTurns: false,
+    snapshot: vi.fn(() => ({ inputTokens: 0n, outputTokens: 0n })),
+  };
+}
+
+interface BuiltDeps {
+  deps: CursorTurnStreamDeps;
+  state: TurnStreamState;
+  persist: ReturnType<typeof vi.fn>;
+  accumulator: ReturnType<typeof stubAccumulator>;
+  status: ReturnType<typeof create<typeof AgentExecutionStatusSchema>>;
+}
+
+function buildDeps(overrides: Partial<CursorTurnStreamDeps> = {}): BuiltDeps {
+  const state = overrides.state ?? newTurnStreamState();
+  const status = overrides.status ?? create(AgentExecutionStatusSchema, {});
+  const accumulator = (overrides.accumulator as unknown as ReturnType<typeof stubAccumulator>) ??
+    stubAccumulator();
+  const persist =
+    (overrides.persist as ReturnType<typeof vi.fn>) ??
+    vi.fn(async () => ExecutionControlSignal.UNSPECIFIED);
+
+  const deps = {
+    // TurnOnDeltaDeps
+    usageAccumulator: stubUsageAccumulator(),
+    deltaEnricher: stubEnricher(),
+    heartbeat: vi.fn(),
+    promptEstimatedTokens: 100,
+    executionId: "exec-test",
+    state,
+    // CursorTurnStreamDeps
+    status,
+    accumulator,
+    todoTracker: { processEvent: vi.fn(), markPersisted: vi.fn(), isDirty: false },
+    eventRecorder: undefined,
+    // contentDirty (accumulator.isDirty) forces the persist, so shouldSendUpdate
+    // is never consulted; markUpdateSent must still exist.
+    scheduler: { shouldSendUpdate: () => false, markUpdateSent: vi.fn() },
+    progressSubstrate: undefined,
+    progressState: { lastAtMs: 0 },
+    changeSetId: "exec-test:0",
+    hitlDir: undefined,
+    stallTimeoutMs: 120_000,
+    persist,
+    isCancelled: () => false,
+    ...overrides,
+  } as unknown as CursorTurnStreamDeps;
+
+  return { deps, state, persist, accumulator, status };
+}
+
+describe("consumeCursorTurnStream", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("processes every event, persists live, and returns 'completed' on a natural end", async () => {
+    const { deps, state, persist, accumulator } = buildDeps();
+
+    const reason = await consumeCursorTurnStream(
+      mockRun([ev({ type: "assistant" }), ev({ type: "assistant" })]),
+      deps,
+    );
+
+    expect(reason).toBe("completed");
+    expect(accumulator.processEvent).toHaveBeenCalledTimes(2);
+    // The #1 retry gap: the bare loop never persisted mid-stream. This proves the
+    // shared loop persists live.
+    expect(persist).toHaveBeenCalled();
+    expect(state.eventCount).toBe(2);
+  });
+
+  it("tracks a sub-agent delegation (the 'task' tool call) — dropped by the old bare retry loop", async () => {
+    const { deps, accumulator } = buildDeps();
+
+    await consumeCursorTurnStream(
+      mockRun([ev({ type: "tool_call", name: "task" })]),
+      deps,
+    );
+
+    expect(accumulator.trackSubAgentExecution).toHaveBeenCalledTimes(1);
+  });
+
+  it("attaches DD-32/DD-33 mid-run progress when a substrate is present", async () => {
+    const capture = vi.fn(async () => ({ delta: { entries: [] }, changed: true }));
+    const progressSubstrate = { capture } as unknown as ProgressSubstrate;
+    const { deps, status } = buildDeps({ progressSubstrate });
+
+    await consumeCursorTurnStream(mockRun([ev({ type: "assistant" })]), deps);
+
+    expect(capture).toHaveBeenCalled();
+    // changed:true → the transient snapshot is attached to status.
+    expect(status.fileChangeProgress).toBeDefined();
+  });
+
+  it("does not touch progress when no substrate is configured", async () => {
+    const { deps, status } = buildDeps({ progressSubstrate: undefined });
+
+    await consumeCursorTurnStream(mockRun([ev({ type: "assistant" })]), deps);
+
+    expect(status.fileChangeProgress).toBeUndefined();
+  });
+
+  it("returns 'paused' and sets pauseDetected when the activity is cancelled", async () => {
+    const { deps, state, accumulator } = buildDeps({ isCancelled: () => true });
+
+    const reason = await consumeCursorTurnStream(mockRun([ev({ type: "assistant" })]), deps);
+
+    expect(reason).toBe("paused");
+    expect(state.pauseDetected).toBe(true);
+    // Cancellation is checked before the event is processed.
+    expect(accumulator.processEvent).not.toHaveBeenCalled();
+  });
+
+  it("returns 'platform-stop' when a persist reports the STOP control signal", async () => {
+    const persist = vi.fn(async () => ExecutionControlSignal.STOP);
+    const { deps, state } = buildDeps({ persist });
+
+    const reason = await consumeCursorTurnStream(
+      mockRun([ev({ type: "assistant" }), ev({ type: "assistant" })]),
+      deps,
+    );
+
+    expect(reason).toBe("platform-stop");
+    expect(state.platformStopSignaled).toBe(true);
+    // Broke after the first persist — the second event never persisted.
+    expect(persist).toHaveBeenCalledTimes(1);
+  });
+
+  it("captures a stream ERROR status message onto state.streamErrorMessage", async () => {
+    const { deps, state } = buildDeps();
+
+    await consumeCursorTurnStream(
+      mockRun([ev({ type: "status", status: "ERROR", message: "boom" })]),
+      deps,
+    );
+
+    expect(state.streamErrorMessage).toBe("boom");
+  });
+
+  describe("first-denial early stop", () => {
+    let hitlDir: string;
+
+    afterEach(async () => {
+      if (hitlDir) await rm(hitlDir, { recursive: true, force: true });
+    });
+
+    it("stops the turn, cancels the run, and arms denialCancelSettled on a ledger entry", async () => {
+      hitlDir = await mkdtemp(join(tmpdir(), "turn-stream-denial-"));
+      await writeFile(
+        join(hitlDir, "denials.jsonl"),
+        JSON.stringify({ toolName: "shell", token: "tok-1" }) + "\n",
+        "utf-8",
+      );
+      const { deps, state } = buildDeps({ hitlDir });
+      const run = mockRun([ev({ type: "tool_call", name: "shell" })]);
+
+      const reason = await consumeCursorTurnStream(run, deps);
+
+      expect(reason).toBe("first-denial");
+      expect(state.firstDenialDetected).toBe(true);
+      expect(run.cancel).toHaveBeenCalled();
+      expect(state.denialCancelSettled).toBeDefined();
+    });
+
+    it("does not stop when the ledger is empty", async () => {
+      hitlDir = await mkdtemp(join(tmpdir(), "turn-stream-nodenial-"));
+      await writeFile(join(hitlDir, "denials.jsonl"), "", "utf-8");
+      const { deps, state } = buildDeps({ hitlDir });
+
+      const reason = await consumeCursorTurnStream(
+        mockRun([ev({ type: "tool_call", name: "shell" })]),
+        deps,
+      );
+
+      expect(reason).toBe("completed");
+      expect(state.firstDenialDetected).toBe(false);
+    });
+  });
+
+  it("returns 'stalled' and cancels the run when the stall watchdog fires", async () => {
+    vi.useFakeTimers();
+    // The generator yields one event, then awaits a promise resolved only by
+    // run.cancel() — so the loop is suspended when the watchdog fires.
+    let unblock: (() => void) | undefined;
+    async function* gen(): AsyncIterable<SDKMessage> {
+      yield ev({ type: "assistant" });
+      await new Promise<void>((resolve) => {
+        unblock = resolve;
+      });
+    }
+    const run: MockRun = {
+      stream: () => gen(),
+      supports: () => true,
+      cancel: vi.fn(async () => {
+        unblock?.();
+      }),
+    };
+    const { deps, state } = buildDeps({ stallTimeoutMs: 40 });
+
+    const pending = consumeCursorTurnStream(run, deps);
+    // Advance past the stall window (tick = stallMs/4 = 10ms), flushing the
+    // microtasks between ticks so the loop reaches its await first.
+    await vi.advanceTimersByTimeAsync(80);
+    const reason = await pending;
+
+    expect(reason).toBe("stalled");
+    expect(state.stallDetected).toBe(true);
+    expect(run.cancel).toHaveBeenCalled();
+  });
+});
+
+describe("makeCursorTurnOnDelta", () => {
+  it("flags a pause (not a throw) when the heartbeat reports CancelledFailure", () => {
+    const state = newTurnStreamState();
+    const onDelta = makeCursorTurnOnDelta({
+      usageAccumulator: stubUsageAccumulator() as never,
+      deltaEnricher: stubEnricher() as never,
+      heartbeat: () => {
+        throw new CancelledFailure("paused");
+      },
+      promptEstimatedTokens: 10,
+      executionId: "e",
+      state,
+    });
+
+    expect(() => onDelta({ update: { type: "text" } as never })).not.toThrow();
+    expect(state.pauseDetected).toBe(true);
+  });
+
+  it("rethrows a non-cancellation heartbeat error", () => {
+    const state = newTurnStreamState();
+    const onDelta = makeCursorTurnOnDelta({
+      usageAccumulator: stubUsageAccumulator() as never,
+      deltaEnricher: stubEnricher() as never,
+      heartbeat: () => {
+        throw new Error("boom");
+      },
+      promptEstimatedTokens: 10,
+      executionId: "e",
+      state,
+    });
+
+    expect(() => onDelta({ update: { type: "text" } as never })).toThrow("boom");
+    expect(state.pauseDetected).toBe(false);
+  });
+
+  it("accumulates turn usage and logs first-turn attribution exactly once", () => {
+    const state = newTurnStreamState();
+    const usageAccumulator = stubUsageAccumulator();
+    const onDelta = makeCursorTurnOnDelta({
+      usageAccumulator: usageAccumulator as never,
+      deltaEnricher: stubEnricher() as never,
+      heartbeat: vi.fn(),
+      promptEstimatedTokens: 10,
+      executionId: "e",
+      state,
+    });
+
+    onDelta({ update: { type: "turn-ended", usage: { inputTokens: 100 } } as never });
+    onDelta({ update: { type: "turn-ended", usage: { inputTokens: 50 } } as never });
+
+    expect(usageAccumulator.addTurn).toHaveBeenCalledTimes(2);
+    expect(state.firstTurnAttributionLogged).toBe(true);
+  });
+});