@stigmer/runner 3.14.1 → 3.15.0

package/src/activities/execute-cursor/__tests__/hermetic/goldens/stall.status.json

@@ -0,0 +1,59 @@
+{
+  "messages": [
+    {
+      "type": "MESSAGE_AI",
+      "content": "Running the suite.",
+      "timestamp": "2026-01-01T00:00:02.000Z",
+      "toolCalls": [
+        {
+          "id": "call-hermetic-stall-0001",
+          "name": "shell",
+          "args": {
+            "command": "npm test"
+          },
+          "status": "TOOL_CALL_RUNNING",
+          "startedAt": "2026-01-01T00:00:03.000Z",
+          "requiresApproval": true,
+          "approvalMessage": "Run command: npm test",
+          "argsPreview": "{\"command\":\"npm test\"}",
+          "toolKind": "TOOL_KIND_SHELL",
+          "approvalPolicySource": "APPROVAL_POLICY_SOURCE_BUILTIN_CATEGORY",
+          "policyEngineVersion": "phase-7"
+        }
+      ]
+    },
+    {
+      "type": "MESSAGE_SYSTEM",
+      "content": "Execution failed: the agent made no progress for too long and was stopped (Agent stream stalled: no activity for 3s (last tool: shell)). You can retry or resume.",
+      "timestamp": "2026-01-01T00:00:06.000Z"
+    }
+  ],
+  "phase": "EXECUTION_FAILED",
+  "error": "[StallTimeoutError] Agent stream stalled: no activity for 3s (last tool: shell). Retry or resume.",
+  "startedAt": "2026-01-01T00:00:00.000Z",
+  "completedAt": "2026-01-01T00:00:06.000Z",
+  "fileReviewEventStream": {
+    "executionId": "aex_hermetic_0001",
+    "events": [
+      {
+        "eventId": "aex_hermetic_0001:0:aex_hermetic_0001:0:FILE_REVIEW_EVENT_TYPE_BASELINE_CAPTURED",
+        "changeSetId": "aex_hermetic_0001:0",
+        "eventType": "FILE_REVIEW_EVENT_TYPE_BASELINE_CAPTURED",
+        "timestamp": "2026-01-01T00:00:00.000Z",
+        "actor": "runner",
+        "baselineCaptured": {
+          "changeSetId": "aex_hermetic_0001:0",
+          "turnId": "aex_hermetic_0001:0",
+          "harnessId": "cursor",
+          "baselineSnapshot": {
+            "kind": "SNAPSHOT_KIND_CAS_MANIFEST"
+          }
+        }
+      }
+    ]
+  },
+  "fileChangeProgress": {
+    "changeSetId": "aex_hermetic_0001:0",
+    "capturedAt": "2026-01-01T00:00:01.000Z"
+  }
+}

package/src/activities/execute-cursor/__tests__/hermetic/goldens/unattributed-hook-block.status.json

@@ -0,0 +1,79 @@
+{
+  "messages": [
+    {
+      "type": "MESSAGE_AI",
+      "content": "Removing the build directory.",
+      "timestamp": "2026-01-01T00:00:02.000Z",
+      "toolCalls": [
+        {
+          "id": "call-hermetic-hookblock-0001",
+          "name": "shell",
+          "args": {
+            "command": "rm -rf build"
+          },
+          "result": "blocked by a hook",
+          "status": "TOOL_CALL_FAILED",
+          "completedAt": "2026-01-01T00:00:03.000Z",
+          "error": "blocked by a hook",
+          "requiresApproval": true,
+          "approvalMessage": "Run command: rm -rf build",
+          "approvalRequestedAt": "2026-01-01T00:00:03.000Z",
+          "argsPreview": "{\"command\":\"rm -rf build\"}",
+          "toolKind": "TOOL_KIND_SHELL",
+          "approvalPolicySource": "APPROVAL_POLICY_SOURCE_BUILTIN_CATEGORY",
+          "policyEngineVersion": "phase-7"
+        }
+      ]
+    },
+    {
+      "type": "MESSAGE_AI",
+      "content": "I could not clean the build directory: the shell command was blocked.",
+      "timestamp": "2026-01-01T00:00:04.000Z"
+    },
+    {
+      "type": "MESSAGE_SYSTEM",
+      "content": "Execution failed: A Cursor hook outside Stigmer's approval gate blocked tool(s): shell. The workspace's .cursor/hooks.json registers hook(s) outside Stigmer's control [./scripts/team-policy-hook.sh], which most likely denied it. Stigmer cannot request approval on a foreign hook's behalf — remove or adjust the hook in .cursor/hooks.json and retry.",
+      "timestamp": "2026-01-01T00:00:06.000Z"
+    }
+  ],
+  "phase": "EXECUTION_FAILED",
+  "error": "A Cursor hook outside Stigmer's approval gate blocked tool(s): shell. The workspace's .cursor/hooks.json registers hook(s) outside Stigmer's control [./scripts/team-policy-hook.sh], which most likely denied it. Stigmer cannot request approval on a foreign hook's behalf — remove or adjust the hook in .cursor/hooks.json and retry.",
+  "startedAt": "2026-01-01T00:00:00.000Z",
+  "completedAt": "2026-01-01T00:00:06.000Z",
+  "streamingUsage": {
+    "inputTokens": "1500",
+    "outputTokens": "40",
+    "totalTokens": "1540",
+    "turnCount": 1,
+    "estimatedCostUsd": 0.00166,
+    "model": "composer-2.5",
+    "observedAt": "2026-01-01T00:00:05.000Z",
+    "requestedServiceTier": "SERVICE_TIER_STANDARD",
+    "requestedModelParams": "[{\"id\":\"fast\",\"value\":\"false\"},{\"id\":\"thinking\",\"value\":\"false\"}]",
+    "requestedThinkingMode": "THINKING_MODE_DISABLED"
+  },
+  "fileReviewEventStream": {
+    "executionId": "aex_hermetic_0001",
+    "events": [
+      {
+        "eventId": "aex_hermetic_0001:0:aex_hermetic_0001:0:FILE_REVIEW_EVENT_TYPE_BASELINE_CAPTURED",
+        "changeSetId": "aex_hermetic_0001:0",
+        "eventType": "FILE_REVIEW_EVENT_TYPE_BASELINE_CAPTURED",
+        "timestamp": "2026-01-01T00:00:00.000Z",
+        "actor": "runner",
+        "baselineCaptured": {
+          "changeSetId": "aex_hermetic_0001:0",
+          "turnId": "aex_hermetic_0001:0",
+          "harnessId": "cursor",
+          "baselineSnapshot": {
+            "kind": "SNAPSHOT_KIND_CAS_MANIFEST"
+          }
+        }
+      }
+    ]
+  },
+  "fileChangeProgress": {
+    "changeSetId": "aex_hermetic_0001:0",
+    "capturedAt": "2026-01-01T00:00:01.000Z"
+  }
+}

package/src/activities/execute-cursor/__tests__/hermetic/goldens/worker-shutdown.status.json

@@ -8,18 +8,13 @@
     {
       "type": "MESSAGE_SYSTEM",
       "content": "Execution interrupted: the runner worker was shut down while the agent was still running. You can retry or resume.",
-      "timestamp": "2026-01-01T00:00:04.000Z"
-    },
-    {
-      "type": "MESSAGE_SYSTEM",
-      "content": "Execution interrupted: the runner worker was shut down while the agent was still running. You can retry or resume.",
-      "timestamp": "2026-01-01T00:00:04.000Z"
+      "timestamp": "2026-01-01T00:00:03.000Z"
     }
   ],
   "phase": "EXECUTION_FAILED",
   "error": "Execution interrupted: runner worker was shut down. Retry or resume.",
   "startedAt": "2026-01-01T00:00:00.000Z",
-  "completedAt": "2026-01-01T00:00:04.000Z",
+  "completedAt": "2026-01-01T00:00:03.000Z",
   "fileReviewEventStream": {
     "executionId": "aex_hermetic_0001",
     "events": [

package/src/activities/execute-cursor/__tests__/hermetic/harness-contract.test.ts

@@ -0,0 +1,170 @@
+/**
+ * The harness contract kit, BOTH halves, against the REAL Cursor adapter.
+ *
+ * The adapter-side half (`__test-utils__/harness-contract/contract.ts`) is the
+ * single statement of what every `HarnessAdapter` owes the runtime;
+ * `src/__tests__/harness-contract.test.ts` runs it against the scripted fake
+ * under both pause primitives. The runtime-side half
+ * (`__test-utils__/harness-contract/runtime-contract.ts`) is what the turn
+ * runtime owes every harness, through the real activity under
+ * `MockActivityEnvironment`; `harness/__tests__/run-turn.test.ts` runs it
+ * against the fake. This file runs BOTH against `createCursorAdapter()`
+ * through the Cursor subject (`__test-utils__/contract-subject.ts`), which
+ * translates the kit's scenarios onto S0's scripted `@cursor/sdk` double and
+ * runs the REAL bash preToolUse hook the adapter installs for every gated
+ * proposal. Nothing of the adapter is mocked; the SDK and the control-plane
+ * client are the two doubles every hermetic golden already substitutes.
+ *
+ * Every runtime arm here has a golden twin under `goldens/`; the goldens pin
+ * the transcript byte for byte, the kit asserts the contract facts in words
+ * any harness can satisfy. The `actionable` failure arm is registered
+ * SKIPPED: only the unattributed-hook-block path produces that surface on
+ * this harness (`unattributed-hook-block.test.ts` pins it), and the kit's
+ * vocabulary has no word for it.
+ *
+ * Beside the kit, the Cursor-only observations the kit's vocabulary cannot
+ * express: the agent the SDK minted is CLOSED when the session write behind
+ * `bindHarnessState` rejects (S2 M4 finding F5, an M3b regression the kit's
+ * rejected-bind leg exposed — before the fix the handle leaked its executor
+ * lease and MCP subprocesses; Q-M4-8); the SDK is asked to create one agent
+ * per session and never to resume (the parked handle serves every later
+ * turn, #215); a DISOBEDIENT re-issue after a SKIP is denied by the hook and
+ * never executes (what makes the subject's "obedient model" modelling safe);
+ * a later proposal of an identity the user already approved and the agent
+ * already ran gets its OWN gate and inherits nothing — the approval bleed the
+ * kit's invariant 3 found in this adapter (S2 M4 finding F9;
+ * `same-identity-reproposal.test.ts` pins the translator's rule); and the
+ * hook agreed with the subject's model of it at every proposal.
+ *
+ * Needs `bash` (the hook) — skipped where it is unavailable, reported as
+ * SKIPPED, never a silent pass. The hermetic environment (temp `HOME` for the
+ * gate's per-session artifacts, temp workspace root) is created at module
+ * level because the subject's `config` is read at collection time; the forks
+ * pool keeps it private to this file. No golden: the kit asserts behaviour,
+ * the goldens under `goldens/` pin transcripts.
+ */
+
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { ApprovalAction, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+vi.mock("@cursor/sdk", async () =>
+  (await import("../../__test-utils__/scripted-sdk.js")).scriptedCursorSdkModule(),
+);
+vi.mock("../../../../client/stigmer-client.js", async () =>
+  (await import("../../../../__test-utils__/hermetic-activity.js")).hermeticStigmerClientModule(),
+);
+
+import { approvalDecisionsOf } from "../../../../harness/turn-context.js";
+import { ExecutionDriver, describeHarnessContract } from "../../../../__test-utils__/harness-contract/contract.js";
+import { RecordingTurnSink } from "../../../../__test-utils__/harness-contract/recording-sink.js";
+import { describeHarnessRuntimeContract } from "../../../../__test-utils__/harness-contract/runtime-contract.js";
+import { scenario } from "../../../../__test-utils__/harness-contract/types.js";
+import { ScriptedClock, createHermeticEnvironment } from "../../../../__test-utils__/hermetic-activity.js";
+import { stubRegistryFetch } from "../../../../__test-utils__/model-registry-fixture.js";
+import { findToolCallRow } from "../../../../__test-utils__/proto-helpers.js";
+import { createCursorContractSubject } from "../../__test-utils__/contract-subject.js";
+import { hasBash } from "../../__test-utils__/cursor-hook-harness.js";
+import { resetCursorModuleState } from "../../__test-utils__/hermetic-cursor.js";
+
+const env = createHermeticEnvironment();
+const clock = new ScriptedClock();
+const subject = createCursorContractSubject(env);
+const WRITE_GAMMA = { kind: "write", resource: "/work/gamma.txt" } as const;
+
+describe.skipIf(!hasBash)("ExecuteCursor hermetic — the harness contract kit against the real adapter", () => {
+  let registry: ReturnType<typeof stubRegistryFetch>;
+
+  beforeAll(() => {
+    // Once, never between turns: a parked agent must survive turn 1 into
+    // turn 2 as it does in a live worker.
+    resetCursorModuleState();
+    registry = stubRegistryFetch();
+    clock.install();
+  });
+
+  afterAll(() => {
+    clock.uninstall();
+    registry.restore();
+    env.dispose();
+  });
+
+  describeHarnessContract(subject);
+  describeHarnessRuntimeContract({ subject, env, clock }, { failureSurfaces: ["engine", "internal"] });
+
+  describe("cursor-only observations", () => {
+    beforeAll(async () => {
+      await subject.adapter.boot(subject.config);
+    });
+
+    it("closes the agent the SDK minted when the session write behind bindHarnessState rejects (F5)", async () => {
+      const driver = new ExecutionDriver(subject, "obs-bind-rejects");
+      const rejecting = new RecordingTurnSink({ bindRejectsWith: new Error("session write refused") });
+
+      const { outcome } = await driver.turn([scenario.say("never sent")], { sink: rejecting });
+
+      expect(outcome.kind).toBe("failed");
+      const agent = subject.agentFor(driver.sessionId);
+      expect(agent, "the SDK minted an agent for the session").toBeDefined();
+      expect(agent!.sends, "nothing was sent to it").toHaveLength(0);
+      expect(agent!.closeCalls, "and it was closed, not leaked: its id was never saved, so no later turn can resume it").toBe(1);
+    });
+
+    it("asks the SDK to create one agent per session and never to resume it (#215: the parked handle serves every later turn)", async () => {
+      const driver = new ExecutionDriver(subject, "obs-one-create");
+
+      const first = await driver.turn([scenario.say("first")]);
+      const second = await driver.turn([scenario.say("second")]);
+
+      expect(first.outcome.kind).toBe("completed");
+      expect(second.outcome.kind).toBe("completed");
+      const agent = subject.agentFor(driver.sessionId)!;
+      const resolutions = subject.sdk.resolutions.filter((r) => r.agentId === agent.agentId);
+      expect(resolutions.map((r) => r.kind), "one create, no resume").toEqual(["create"]);
+      expect(agent.sends, "both turns went to the same parked agent").toHaveLength(2);
+    });
+
+    it("denies a disobedient re-issue after a SKIP: the action never executes and the turn re-gates", async () => {
+      const driver = new ExecutionDriver(subject, "obs-disobedient");
+      const id = "obs-disobedient-write";
+
+      const proposed = await driver.turn([scenario.propose(id, WRITE_GAMMA)]);
+      expect(proposed.outcome.kind).toBe("awaiting_approval");
+      driver.decide(id, ApprovalAction.SKIP);
+
+      subject.forceReissue(id);
+      const reissued = await driver.turn([scenario.propose(id, WRITE_GAMMA), scenario.say("never reached")]);
+
+      expect(subject.executionCount(id), "the hook denied the re-issue; nothing ran").toBe(0);
+      expect(reissued.outcome.kind, "a fresh gated act pauses the turn again").toBe("awaiting_approval");
+    });
+
+    it("gates a later proposal of an already-approved-and-run identity on its own row; the executed row and its decision stand (F9)", async () => {
+      const driver = new ExecutionDriver(subject, "obs-reproposal");
+      const first = "obs-reproposal-first";
+      const later = "obs-reproposal-later";
+
+      const proposed = await driver.turn([scenario.propose(first, WRITE_GAMMA)]);
+      expect(proposed.outcome.kind).toBe("awaiting_approval");
+      driver.decide(first, ApprovalAction.APPROVE);
+      const ran = await driver.turn([scenario.propose(first, WRITE_GAMMA), scenario.say("written")]);
+      expect(ran.outcome.kind).toBe("completed");
+      expect(subject.executionCount(first)).toBe(1);
+
+      const again = await driver.turn([scenario.say("once more"), scenario.propose(later, WRITE_GAMMA)]);
+
+      expect(again.outcome.kind, "a new act of the same identity is gated afresh").toBe("awaiting_approval");
+      expect(subject.executionCount(later), "and did not run under the earlier approval").toBe(0);
+      const firstRow = findToolCallRow(again.sink.status, first)!;
+      expect(firstRow.status, "the executed row is never rewritten").toBe(ToolCallStatus.TOOL_CALL_COMPLETED);
+      expect(firstRow.approvalAction).toBe(ApprovalAction.APPROVE);
+      const laterRow = findToolCallRow(again.sink.status, later);
+      expect(laterRow?.status, "the new act has its own WAITING row").toBe(ToolCallStatus.TOOL_CALL_WAITING_APPROVAL);
+      expect(laterRow?.approvalAction, "undecided").toBe(ApprovalAction.UNSPECIFIED);
+      expect(approvalDecisionsOf(again.sink.status).size, "the runtime would read no decision for it").toBe(0);
+    });
+
+    it("the hook agreed with the subject's model of it at every proposal", () => {
+      expect(subject.hookDisagreements).toEqual([]);
+    });
+  });
+});

package/src/activities/execute-cursor/__tests__/hermetic/pause-vs-shutdown.test.ts

@@ -2,8 +2,8 @@
  * Hermetic goldens: USER PAUSE versus WORKER SHUTDOWN — the two interruptions
  * that THROW, and the byte-pinned copy that tells them apart.
  *
- * Invariant pinned (the throw-vs-return table the runtime will own in S2; parent
- * §5c): both interruptions end the activity with a thrown Temporal
+ * Invariant pinned (the throw-vs-return table the runtime owns,
+ * `harness/terminal-table.ts`; parent §5c): both interruptions end the activity with a thrown Temporal
  * `CancelledFailure` (never a return), but they persist DIFFERENT terminal
  * states the control plane keys on:
  *
@@ -22,17 +22,25 @@
  * stream loop sees `isCancelled()` on its next iteration and never processes
  * the event that follows.
  *
- * What the goldens ALSO pin, on purpose: both paths append their system message
- * TWICE — once in `resolvePreBoundaryTerminal` before the throw, once again in
- * the outer `catch (CancelledFailure)`, which re-stamps and re-persists. That is
- * today's production behavior on the wire. S2 must reproduce it byte for byte;
- * whether it is later collapsed to one message is a separate, deliberate change
- * (recorded in the entry's execution log for the owner).
+ * What the goldens ALSO pin: each path appends its system message exactly
+ * ONCE. The orchestrator this net was recorded on appended it twice — once in
+ * `resolvePreBoundaryTerminal` before the throw, once again in the outer
+ * `catch (CancelledFailure)`, which re-stamped and re-persisted — and the
+ * goldens pinned that double on purpose so S2 could reproduce the wire byte
+ * for byte (stigmer#1054, Q-S2-4). The runtime's `settleWith` is now the one
+ * writer of a terminal arm, so a second row has no code path to come from.
  *
- * Parent phase rows exercised: the stream loop's cancellation check; the
- * post-stream `classifyTurnInterruption`; `resolvePreBoundaryTerminal`'s
- * pause and worker-shutdown arms; the outer `CancelledFailure` catch; the
- * `finally` teardown under a thrown exit.
+ * Runtime phases exercised: the adapter's stop-signal cancel; the runtime's
+ * `classifyTurnInterruption`; the terminal table's pause and worker-shutdown
+ * arms through `settleWith`; the `finally` teardown under a thrown exit.
+ *
+ * Regeneration history:
+ *  - S2 M3b (entry 20260911.03): timestamp-only diff — every terminal stamp
+ *    one scripted second earlier: the adapter cancels the SDK run the instant
+ *    the runtime's stop signal aborts (Q-M3-4), before the SDK double pulls,
+ *    and the clock ticks on, one more step. Transcript unchanged.
+ *  - 2026-09-12 (stigmer#1054, the PR after S2): one removed system row per
+ *    golden, nothing else. The transcript now carries each terminal row once.
  *
  * Regenerate ONLY after a deliberate behavior change:
  *   npx vitest run src/activities/execute-cursor/__tests__/hermetic -u
@@ -63,8 +71,8 @@ import {
   beginCursorScenario,
   cursorExecutionRecord,
   runCursorTurn,
-  stubRegistryFetch,
 } from "../../__test-utils__/hermetic-cursor.js";
+import { stubRegistryFetch } from "../../../../__test-utils__/model-registry-fixture.js";
 
 const USER_MESSAGE = "Refactor the parser module.";
 const NEVER_SEEN = "This text must never reach the transcript.";
@@ -144,10 +152,7 @@ describe("ExecuteCursor hermetic — user pause vs worker shutdown", () => {
     expect(final.completedAt, "a paused turn is not complete").toBe("");
     expect(
       final.messages.filter((m) => m.type === MessageType.MESSAGE_SYSTEM).map((m) => m.content),
-    ).toEqual([
-      "Execution paused by user. Use resume to continue.",
-      "Execution paused by user. Use resume to continue.",
-    ]);
+    ).toEqual(["Execution paused by user. Use resume to continue."]);
     expect(final.messages.some((m) => m.content === NEVER_SEEN), "nothing after the cancel is processed").toBe(false);
 
     const json = JSON.stringify(toJson(AgentExecutionStatusSchema, final), null, 2) + "\n";
@@ -191,7 +196,6 @@ describe("ExecuteCursor hermetic — user pause vs worker shutdown", () => {
       final.messages.filter((m) => m.type === MessageType.MESSAGE_SYSTEM).map((m) => m.content),
     ).toEqual([
       "Execution interrupted: the runner worker was shut down while the agent was still running. You can retry or resume.",
-      "Execution interrupted: the runner worker was shut down while the agent was still running. You can retry or resume.",
     ]);
     expect(final.messages.some((m) => m.content === NEVER_SEEN)).toBe(false);
 

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

@@ -53,8 +53,8 @@ import {
   beginCursorScenario,
   cursorExecutionRecord,
   runCursorTurn,
-  stubRegistryFetch,
 } from "../../__test-utils__/hermetic-cursor.js";
+import { stubRegistryFetch } from "../../../../__test-utils__/model-registry-fixture.js";
 
 const AGENT_ID = "agent-hermetic-plain-0001";
 const RUN_ID = "run-hermetic-plain-0001";

package/src/activities/execute-cursor/__tests__/hermetic/recovery-fresh-agent.test.ts

@@ -49,8 +49,8 @@ import {
   beginCursorScenario,
   cursorExecutionRecord,
   runCursorTurn,
-  stubRegistryFetch,
 } from "../../__test-utils__/hermetic-cursor.js";
+import { stubRegistryFetch } from "../../../../__test-utils__/model-registry-fixture.js";
 
 const STALE_AGENT_ID = "agent-hermetic-stale-0001";
 const FRESH_AGENT_ID = "agent-hermetic-fresh-0002";