@stigmer/runner 3.37.0 → 3.37.1

package/dist/shared/worker-shutdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"worker-shutdown.js","sourceRoot":"","sources":["../../src/shared/worker-shutdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA2B,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,UAAU,4BAA4B,CAAC,SAAiB;IAC5D,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IACpC,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,yBAAyB,CAAC,SAAiB;IACzD,OAAO,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,SAAiB;IACpD,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC;AACnC,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,8BAA8B,CAAC,SAAiB;IAC9D,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAC7B,CAAC;AAaD,wFAAwF;AACxF,MAAM,UAAU,oBAAoB,CAAC,MAAmB;IACtD,IAAI,CAAC,MAAM,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IACtC,MAAM,MAAM,GAAY,MAAM,CAAC,MAAM,CAAC;IACtC,IAAI,MAAM,YAAY,KAAK;QAAE,OAAO,MAAM,CAAC,OAAO,CAAC;IACnD,OAAO,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC;AAC3D,CAAC;AAsBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,wBAAwB,CAAC,QAAkC;IACzE,MAAM,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,GAAG,QAAQ,CAAC;IAC/D,IAAI,kBAAkB,KAAK,SAAS,EAAE,CAAC;QACrC,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,IAAI,qBAAqB,IAAI,kBAAkB,KAAK,iBAAiB,EAAE,CAAC;QACtE,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IACD,OAAO,kBAAkB,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,gBAAgB,CAAC;AACzE,CAAC"}
+{"version":3,"file":"worker-shutdown.js","sourceRoot":"","sources":["../../src/shared/worker-shutdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA2B,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,UAAU,4BAA4B,CAAC,SAAiB;IAC5D,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IACpC,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,yBAAyB,CAAC,SAAiB;IACzD,OAAO,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,SAAiB;IACpD,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC;AACnC,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,8BAA8B,CAAC,SAAiB;IAC9D,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAC7B,CAAC;AAaD,wFAAwF;AACxF,MAAM,UAAU,oBAAoB,CAAC,MAAmB;IACtD,IAAI,CAAC,MAAM,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IACtC,MAAM,MAAM,GAAY,MAAM,CAAC,MAAM,CAAC;IACtC,IAAI,MAAM,YAAY,KAAK;QAAE,OAAO,MAAM,CAAC,OAAO,CAAC;IACnD,OAAO,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC;AAC3D,CAAC;AA2BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,wBAAwB,CAAC,QAAkC;IACzE,MAAM,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,GAAG,QAAQ,CAAC;IAC/D,IAAI,kBAAkB,KAAK,SAAS,EAAE,CAAC;QACrC,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,IAAI,qBAAqB,IAAI,kBAAkB,KAAK,iBAAiB,EAAE,CAAC;QACtE,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IACD,OAAO,kBAAkB,KAAK,WAAW,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,gBAAgB,CAAC;AACrF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigmer/runner",
-  "version": "3.37.0",
+  "version": "3.37.1",
   "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",
@@ -108,10 +108,10 @@
     "@opentelemetry/sdk-metrics": "^2.0.0",
     "@opentelemetry/sdk-trace-base": "^2.0.0",
     "@opentelemetry/sdk-trace-node": "^2.0.0",
-    "@stigmer/outbound": "3.37.0",
-    "@stigmer/protos": "3.37.0",
-    "@stigmer/temporal-codecs": "3.37.0",
-    "@stigmer/zip-structure": "3.37.0",
+    "@stigmer/outbound": "3.37.1",
+    "@stigmer/protos": "3.37.1",
+    "@stigmer/temporal-codecs": "3.37.1",
+    "@stigmer/zip-structure": "3.37.1",
     "@temporalio/activity": "1.16.2",
     "@temporalio/common": "1.16.2",
     "@temporalio/interceptors-opentelemetry": "1.16.2",

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

@@ -594,12 +594,17 @@ function hangingTurn(before: string): TurnScenario {
 }
 
 /**
- * A user pause: Temporal's cancellation delivered while the engine hangs
- * persists PAUSED with the pause row written exactly once, no error, no
- * `completedAt`, and THROWS the pause `CancelledFailure` so the workflow
- * knows to wait.
+ * An orchestrator stop (a user's Pause or Cancel, one cancellation to the
+ * turn): Temporal's cancellation delivered while the engine hangs settles
+ * the transcript into one write that carries no phase and no row (the
+ * workflow writes both, stigmer#980), no error, no `completedAt`, and
+ * THROWS the stop's `CancelledFailure` so the workflow sees the activity
+ * stop.
  */
-export async function assertPausePersistsAndThrows(harness: RuntimeContractHarness, label = "rt-pause"): Promise<RuntimeArmResult> {
+export async function assertOrchestratorStopSettlesAndThrows(
+  harness: RuntimeContractHarness,
+  label = "rt-orchestrator-stop",
+): Promise<RuntimeArmResult> {
   const { subject } = harness;
   const driver = new RuntimeExecutionDriver(harness, label);
   let controls: InvocationControls | undefined;
@@ -607,16 +612,22 @@ export async function assertPausePersistsAndThrows(harness: RuntimeContractHarne
 
   const invocation = await driver.turn(hangingTurn("Starting on the parser."), { onControls: (c) => (controls = c) });
 
-  expect(threwCancelledFailure(invocation.outcome), `${subject.name}: a pause THROWS a CancelledFailure`).toBe(true);
+  expect(threwCancelledFailure(invocation.outcome), `${subject.name}: an orchestrator stop THROWS a CancelledFailure`).toBe(true);
   if (!threwCancelledFailure(invocation.outcome)) throw new Error("unreachable");
-  expect(invocation.outcome.error.message).toBe(TERMINAL_COPY.pause.throwMessage);
-  expect(driver.record.persistedPhases.at(-1)).toBe(ExecutionPhase.EXECUTION_PAUSED);
-  const final = finalStatusOf(harness, driver);
-  expect(final.error, `${subject.name}: a pause is not an error`).toBe("");
-  expect(final.completedAt, `${subject.name}: a paused turn is not complete`).toBe("");
-  expect(systemMessages(final), `${subject.name}: the pause row, exactly once`).toEqual([TERMINAL_COPY.pause.row]);
-  expect(aiMessages(final)).not.toContain(NEVER_SEEN);
-  return { driver, invocations: [invocation], final };
+  expect(invocation.outcome.error.message).toBe(TERMINAL_COPY.orchestratorStop.throwMessage);
+  expect(
+    driver.record.persistedPhases.at(-1),
+    `${subject.name}: the stop writes no phase; the last phase is the turn's own`,
+  ).toBe(ExecutionPhase.EXECUTION_IN_PROGRESS);
+  const settle = driver.record.persisted.at(-1);
+  if (!settle) throw new Error(`${subject.name}: the runtime persisted nothing`);
+  expect(settle.phase, `${subject.name}: the settle write carries no phase`).toBe(ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED);
+  assertTranscriptStreamsNothing(subject.name, settle);
+  expect(settle.error, `${subject.name}: a stop is not an error`).toBe("");
+  expect(settle.completedAt, `${subject.name}: a stopped turn is not complete`).toBe("");
+  expect(systemMessages(settle), `${subject.name}: no stop row; the workflow writes it`).toEqual([]);
+  expect(aiMessages(settle)).not.toContain(NEVER_SEEN);
+  return { driver, invocations: [invocation], final: settle };
 }
 
 /**
@@ -970,9 +981,9 @@ export function describeHarnessRuntimeContract(harness: RuntimeContractHarness,
         await assertNonExecutingDecisionSettlesSkipped(harness, action);
       });
     }
-    it("a user pause persists PAUSED with the pause row once and throws the pause CancelledFailure", async () => {
+    it("an orchestrator stop settles the transcript with no phase and no row, and throws the stop's CancelledFailure", async () => {
       clock.reset();
-      await assertPausePersistsAndThrows(harness);
+      await assertOrchestratorStopSettlesAndThrows(harness);
     });
     it("a worker shutdown persists FAILED with the shutdown copy once and throws the shutdown CancelledFailure", async () => {
       clock.reset();

package/src/__test-utils__/hermetic-activity.ts

@@ -331,8 +331,11 @@ export class ExecutionRecord {
 
   /**
    * Apply one `UpdateStatus` write and answer the control signal the server
-   * would. A setup-progress report never carries a signal (the runner ignores
-   * the response there; the server has nothing to say about a label).
+   * would. A write with no phase never carries a signal (the runner ignores
+   * the response there). It is a setup-progress report, or the transcript an
+   * orchestrator stop settles (the runtime writes no phase for it; the
+   * workflow does, stigmer#980): the server's merge applies the transcript and
+   * leaves the phase to its writers, so the double keeps the held phase.
    */
   applyStatusUpdate(status: AgentExecutionStatus): ExecutionControlSignal {
     const snapshot = clone(AgentExecutionStatusSchema, status);
@@ -341,6 +344,12 @@ export class ExecutionRecord {
       if (snapshot.setupProgress?.currentPhase) {
         this.setupProgress.push(snapshot.setupProgress.currentPhase);
       }
+      if (snapshot.messages.length > 0) {
+        const heldPhase = this.execution.status?.phase ?? ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED;
+        this.execution.status = clone(AgentExecutionStatusSchema, snapshot);
+        this.execution.status.phase = heldPhase;
+        for (const listener of [...this.persistListeners]) listener();
+      }
       return ExecutionControlSignal.UNSPECIFIED;
     }
     this.execution.status = clone(AgentExecutionStatusSchema, snapshot);

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

@@ -4,14 +4,8 @@
       "type": "MESSAGE_AI",
       "content": "Starting on the parser.",
       "timestamp": "2026-01-01T00:00:02.000Z"
-    },
-    {
-      "type": "MESSAGE_SYSTEM",
-      "content": "Execution paused by user. Use resume to continue.",
-      "timestamp": "2026-01-01T00:00:03.000Z"
     }
   ],
-  "phase": "EXECUTION_PAUSED",
   "startedAt": "2026-01-01T00:00:00.000Z",
   "fileReviewEventStream": {
     "executionId": "aex_hermetic_0001",

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

@@ -1,23 +1,28 @@
 /**
- * Hermetic goldens: USER PAUSE versus WORKER SHUTDOWN — the two interruptions
- * that THROW, and the byte-pinned copy that tells them apart.
+ * Hermetic goldens: ORCHESTRATOR STOP versus WORKER SHUTDOWN — the two
+ * interruptions that THROW, and what tells them apart.
  *
  * 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:
  *
- *  - a user pause (Temporal delivers cancellation, no shutdown signal) persists
- *    EXECUTION_PAUSED with "Execution paused by user. Use resume to continue."
- *    and throws "Activity paused by orchestrator";
+ *  - an orchestrator stop (Temporal delivers cancellation, no shutdown
+ *    signal: a user's Pause or Cancel, which the turn cannot tell apart)
+ *    settles the transcript in one write with NO phase and NO row, and throws
+ *    "Activity paused by orchestrator" (bytes kept: wire copy). The invoke
+ *    workflow, which knows which stop it runs, writes the phase and the stop
+ *    row, and the server's merge keeps the row last (stigmer#980). Until then
+ *    this arm wrote PAUSED and the pause row, so a cancelled run ended with an
+ *    instruction to resume it;
  *  - a worker shutdown (the runner's per-queue shutdown signal is aborted AND
  *    cancellation is delivered) persists EXECUTION_FAILED with the error copy
  *    "Execution interrupted: runner worker was shut down. Retry or resume." and
  *    throws "Activity cancelled (worker shutdown, not user pause)".
  *
- * The cloud channel decision table matches on that copy, so the goldens
- * (`goldens/pause.status.json`, `goldens/worker-shutdown.status.json`) are the
- * wire contract, character for character. Both interruptions are triggered from
+ * The goldens (`goldens/pause.status.json`, the stop's settle write, and
+ * `goldens/worker-shutdown.status.json`) are the wire contract, character for
+ * character. Both interruptions are triggered from
  * a script `effect` step — never a timer — so the instant is deterministic: the
  * stream loop sees `isCancelled()` on its next iteration and never processes
  * the event that follows.
@@ -31,8 +36,9 @@
  * writer of a terminal arm, so a second row has no code path to come from.
  *
  * 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.
+ * `classifyTurnInterruption`; the terminal table's orchestrator-stop and
+ * worker-shutdown arms through `settleWith`; the `finally` teardown under a
+ * thrown exit.
  *
  * Regeneration history:
  *  - #1070: timestamp-only diff — every terminal stamp
@@ -41,6 +47,8 @@
  *    and the clock ticks on, one more step. Transcript unchanged.
  *  - 2026-09-12 (stigmer#1054, the PR after #1070): one removed system row per
  *    golden, nothing else. The transcript now carries each terminal row once.
+ *  - stigmer#980: `pause.status.json` loses its phase and its pause row (the
+ *    workflow writes both now); the transcript is otherwise unchanged.
  *
  * Regenerate ONLY after a deliberate behavior change:
  *   npx vitest run src/activities/execute-cursor/__tests__/hermetic -u
@@ -108,7 +116,7 @@ function interruptedTurn(
   });
 }
 
-describe("ExecuteCursor hermetic — user pause vs worker shutdown", () => {
+describe("ExecuteCursor hermetic — orchestrator stop vs worker shutdown", () => {
   let env: HermeticEnvironment;
   let registry: ReturnType<typeof stubRegistryFetch>;
   const clock = new ScriptedClock();
@@ -125,7 +133,7 @@ describe("ExecuteCursor hermetic — user pause vs worker shutdown", () => {
     env.dispose();
   });
 
-  it("a user pause persists PAUSED and throws CancelledFailure", async () => {
+  it("an orchestrator stop settles the transcript with no phase and no row, and throws CancelledFailure", async () => {
     // ── Arrange ──────────────────────────────────────────────────────────────
     clock.reset(); // both goldens read from :00
     let controls: InvocationControls | undefined;
@@ -143,19 +151,18 @@ describe("ExecuteCursor hermetic — user pause vs worker shutdown", () => {
     const invocation = await runCursorTurn(scenario, { onControls: (c) => (controls = c) });
 
     // ── Assert: the throw and the persisted state ────────────────────────────
-    expect(threwCancelledFailure(invocation.outcome), "a pause THROWS CancelledFailure").toBe(true);
+    expect(threwCancelledFailure(invocation.outcome), "an orchestrator stop THROWS CancelledFailure").toBe(true);
     if (!threwCancelledFailure(invocation.outcome)) throw new Error("unreachable");
     expect(invocation.outcome.error.message).toBe("Activity paused by orchestrator");
-    expect(record.persistedPhases).toEqual([
-      ExecutionPhase.EXECUTION_IN_PROGRESS,
-      ExecutionPhase.EXECUTION_PAUSED,
-    ]);
-    const final = record.lastFullStatus!;
-    expect(final.error, "a pause is not an error").toBe("");
-    expect(final.completedAt, "a paused turn is not complete").toBe("");
+    expect(record.persistedPhases, "the stop writes no phase").toEqual([ExecutionPhase.EXECUTION_IN_PROGRESS]);
+    const final = record.persisted.at(-1)!;
+    expect(final.phase, "the settle write carries no phase").toBe(ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED);
+    expect(final.error, "a stop is not an error").toBe("");
+    expect(final.completedAt, "a stopped 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."]);
+      "no stop row: the workflow writes it",
+    ).toEqual([]);
     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";

package/src/activities/execute-deep-agent/__tests__/hermetic/goldens/pause.loop.after-tool.status.json

@@ -19,14 +19,8 @@
           "toolKind": "TOOL_KIND_FILE_READ"
         }
       ]
-    },
-    {
-      "type": "MESSAGE_SYSTEM",
-      "content": "Execution paused by user. Use resume to continue.",
-      "timestamp": "2026-01-01T00:00:02.000Z"
     }
   ],
-  "phase": "EXECUTION_PAUSED",
   "startedAt": "2026-01-01T00:00:00.000Z",
   "streamingUsage": {
     "inputTokens": "1200",

package/src/activities/execute-deep-agent/__tests__/hermetic/goldens/pause.loop.mid-tool.status.json

@@ -17,14 +17,8 @@
           "toolKind": "TOOL_KIND_FILE_READ"
         }
       ]
-    },
-    {
-      "type": "MESSAGE_SYSTEM",
-      "content": "Execution paused by user. Use resume to continue.",
-      "timestamp": "2026-01-01T00:00:01.000Z"
     }
   ],
-  "phase": "EXECUTION_PAUSED",
   "startedAt": "2026-01-01T00:00:00.000Z",
   "streamingUsage": {
     "inputTokens": "1200",

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

@@ -3,19 +3,22 @@
  * the activity tells them apart — the throw-vs-return table the control
  * plane's workflow keys on. Since #1096 the activity is the turn runtime
  * over the native adapter, and the shapes below are the runtime's terminal
- * table (`harness/terminal-table.ts`; the pause copy is Cursor's) and
- * stigmer#1071 ("persist a thrown terminal once").
+ * table (`harness/terminal-table.ts`) and stigmer#1071 ("persist a thrown
+ * terminal once").
  *
- *  1. USER PAUSE: the activity's `cancellationSignal` aborts. Whether the
+ *  1. ORCHESTRATOR STOP (a user's Pause or Cancel; the turn cannot tell
+ *     them apart): the activity's `cancellationSignal` aborts. Whether the
  *     abort lands inside a model call (staged from the scripted model's
  *     `onTurn`) or while the loop is persisting (staged from the control
  *     plane's persist channel, the record's `controlSignal`), the runtime's
  *     stop controller aborts the adapter's signal, the adapter cancels the
- *     graph run and settles `interrupted`, and the runtime persists PAUSED
- *     ONCE — WITH the transcript and the row "Execution paused by user. Use
- *     resume to continue." (the runtime's pause copy is Cursor's; the
- *     orchestrator's said "… from this checkpoint.") — then throws
- *     `CancelledFailure("Activity paused by orchestrator")`. Until #1096 the
+ *     graph run and settles `interrupted`, and the runtime persists the
+ *     transcript ONCE with no phase and no row, then throws
+ *     `CancelledFailure("Activity paused by orchestrator")` (bytes kept:
+ *     wire copy). The invoke workflow writes the phase and the stop row, and
+ *     the server's merge keeps the row last (stigmer#980); until then this
+ *     write carried PAUSED and "Execution paused by user. Use resume to
+ *     continue.", which a cancelled run showed too. Until #1096 the
  *     orchestrator persisted PAUSED TWICE, the second write bare and erasing
  *     the transcript (stigmer#1054's double persist);
  *     `pause.bare.status.json` recorded that write and is gone with it. The
@@ -132,30 +135,33 @@ describe("ExecuteDeepAgent hermetic — pause vs worker shutdown", () => {
       },
       loopGolden: "./goldens/pause.loop.mid-tool.status.json",
     },
-  ])("user pause $staging", ({ begin, controlSignal, loopGolden }) => {
-    it("persists PAUSED once, with the transcript and the row, and throws as a pause", async () => {
+  ])("orchestrator stop $staging", ({ begin, controlSignal, loopGolden }) => {
+    it("settles the transcript once, with no phase and no row, and throws as the stop", async () => {
       clock.reset();
       const record = deepAgentExecutionRecord({ message: "Look at my notes.", controlSignal });
       inFlight = begin(record);
 
       const invocation = await runDeepAgentTurn(inFlight);
 
-      expect(threwCancelledFailure(invocation.outcome), "a pause THROWS CancelledFailure").toBe(true);
+      expect(threwCancelledFailure(invocation.outcome), "an orchestrator stop THROWS CancelledFailure").toBe(true);
       expect((invocation.outcome as { error: Error }).error.message).toBe("Activity paused by orchestrator");
-      expect(record.persistedPhases).toEqual([ExecutionPhase.EXECUTION_IN_PROGRESS, ExecutionPhase.EXECUTION_PAUSED]);
-
-      const pausedWrites = record.persisted.filter((s) => s.phase === ExecutionPhase.EXECUTION_PAUSED);
-      expect(pausedWrites, "PAUSED is persisted exactly once (stigmer#1071)").toHaveLength(1);
-      const [paused] = pausedWrites;
-      expect(paused.messages.filter((m) => m.type === MessageType.MESSAGE_SYSTEM).map((m) => m.content)).toEqual([
-        "Execution paused by user. Use resume to continue.",
-      ]);
+      expect(record.persistedPhases, "the stop writes no phase").toEqual([ExecutionPhase.EXECUTION_IN_PROGRESS]);
+
+      const settleWrites = record.persisted.filter(
+        (s) => s.phase === ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED && s.messages.length > 0,
+      );
+      expect(settleWrites, "the stop is settled exactly once (stigmer#1071)").toHaveLength(1);
+      const [paused] = settleWrites;
+      expect(
+        paused.messages.filter((m) => m.type === MessageType.MESSAGE_SYSTEM).map((m) => m.content),
+        "no stop row: the workflow writes it (stigmer#980)",
+      ).toEqual([]);
       expect(
         paused.messages.flatMap((m) => m.toolCalls).map((tc) => tc.name),
-        "the read that landed before the pause is in the one write",
+        "the read that landed before the stop is in the one write",
       ).toEqual(["read_file"]);
       expect(paused.completedAt).toBe("");
-      expect(record.lastFullStatus, "the wire ends on the write that carries the transcript").toEqual(paused);
+      expect(record.persisted.at(-1), "the wire ends on the write that carries the transcript").toEqual(paused);
 
       const json = JSON.stringify(toJson(AgentExecutionStatusSchema, paused), null, 2) + "\n";
       await expect(json).toMatchFileSnapshot(loopGolden);

package/src/activities/execute-deep-agent/turn-setup.ts

@@ -345,6 +345,11 @@ export async function buildEngine(
   // native-thinking heuristic, and sub-agent inheritance. The credential is
   // read from the ref at build, once per turn: a LangChain client carries
   // its headers for its life, so this is the freshest a turn's model can be.
+  //
+  // No temperature: current Anthropic models refuse one other than their
+  // default (claude-opus-4.7 and later and claude-fable-5 inside
+  // @langchain/anthropic, before any request; claude-sonnet-5 at the
+  // provider), and the Cursor harness sends none (stigmer/stigmer#1341).
   const buildModelFor = async (name: string) =>
     (await buildChatModel({
       modelName: name,
@@ -352,6 +357,7 @@ export async function buildEngine(
       stigmerToken: config.stigmerTokenRef.current ?? undefined,
       headerScope: { executionId },
       serviceTier: input.model.serviceTier,
+      temperature: null,
     })).model;
   const model = await buildModelFor(modelName);
   sink.setupTiming.mark("build_model");

package/src/harness/run-turn.ts

@@ -74,7 +74,7 @@ import {
   failedArm,
   fileReviewResolvedArm,
   infrastructureCancelArm,
-  pauseArm,
+  orchestratorStopArm,
   platformStopArm,
   stallArm,
   TERMINAL_COPY,
@@ -463,7 +463,7 @@ async function runTurn(deps: TurnRuntimeDeps, input: NormalizedActivityInput): P
    * The table for an `interrupted` outcome, in the orchestrator's precedence:
    * a stall (FAILED, return) outranks everything; a cost cap (TERMINATED,
    * return); then Temporal's cancellation as the signal's reason reads it —
-   * the runner's drain, the orchestrator's pause, an infrastructure cancel
+   * the runner's drain, the orchestrator's stop, an infrastructure cancel
    * (all thrown); last a platform stop (COMPLETED, return).
    */
   async function settleInterrupted(maxCostUsd: number, accumulator: UsageAccumulator): Promise<Settled> {
@@ -487,9 +487,9 @@ async function runTurn(deps: TurnRuntimeDeps, input: NormalizedActivityInput): P
       case "worker-shutdown":
         console.log(`${activityName} interrupted (worker shutdown): execution=${executionId}`);
         return settleWith(workerShutdownArm());
-      case "pause":
-        console.log(`${activityName} paused: execution=${executionId}`);
-        return settleWith(pauseArm());
+      case "orchestrator-stop":
+        console.log(`${activityName} stopped by the orchestrator (pause or cancel): execution=${executionId}`);
+        return settleWith(orchestratorStopArm());
       case "infrastructure":
         console.log(`${activityName} interrupted (infrastructure cancel): execution=${executionId}`);
         return settleWith(infrastructureCancelArm());
@@ -659,9 +659,9 @@ async function runTurn(deps: TurnRuntimeDeps, input: NormalizedActivityInput): P
         case "worker-shutdown":
           console.log(`${activityName} cancelled (worker shutdown) for execution ${executionId}`);
           return workerShutdownArm();
-        case "pause":
-          console.log(`${activityName} cancelled (pause) for execution ${executionId}`);
-          return pauseArm();
+        case "orchestrator-stop":
+          console.log(`${activityName} cancelled (orchestrator stop) for execution ${executionId}`);
+          return orchestratorStopArm();
         case "infrastructure":
           console.log(`${activityName} cancelled (infrastructure) for execution ${executionId}`);
           return infrastructureCancelArm();
@@ -687,11 +687,11 @@ async function runTurn(deps: TurnRuntimeDeps, input: NormalizedActivityInput): P
     if (arm !== undefined) {
       // A non-cancellation error while cancelled was most likely caused by the
       // cancellation itself (a teardown mid-flight) and must not overwrite the
-      // state the workflow already expects: a pause stays PAUSED; anything
-      // else reads as the interruption it was.
-      if (arm.phase === ExecutionPhase.EXECUTION_PAUSED) {
-        console.log(`${activityName} error during pause (treating as pause): execution=${executionId}, error=${errDetail}`);
-        return settleWith(arm, new CancelledFailure(TERMINAL_COPY.pause.throwMessageAfterError));
+      // state the workflow already expects: an orchestrator stop stays the
+      // workflow's to write; anything else reads as the interruption it was.
+      if (interruption() === "orchestrator-stop") {
+        console.log(`${activityName} error during an orchestrator stop (treating as the stop): execution=${executionId}, error=${errDetail}`);
+        return settleWith(arm, new CancelledFailure(TERMINAL_COPY.orchestratorStop.throwMessageAfterError));
       }
       console.log(`${activityName} error during infrastructure cancel: execution=${executionId}, error=${errDetail}`);
       return settleWith(

package/src/harness/terminal-table.ts

@@ -21,6 +21,16 @@
  *    infrastructure cancel it delivered — with the message the control
  *    planes recognise.
  *
+ * One stop has no copy here: the orchestrator's (a Pause or a Cancel, which
+ * reach the activity as the same workflow-requested cancellation). The turn
+ * cannot tell which it is, so its arm writes no phase and no row, and the
+ * invoke workflow, which knows, writes the phase and the stop row that the
+ * server's merge keeps last (stigmer#980;
+ * `backend/services/stigmer-server/src/domain/agentexecution/platform-rows.ts`).
+ * The pause row lived here until then, and a cancelled run ended with an
+ * instruction to resume it. The arm's throw messages keep their bytes: they
+ * are the wire copy the control planes see on the activity failure.
+ *
  * An arm's rows are appended exactly once, by `applyTerminalArm`, and an arm
  * is persisted exactly once, by `run-turn.ts`'s `settleWith` — the one
  * writer of a terminal. The orchestrator this table replaced appended the
@@ -47,6 +57,7 @@ export type TerminalDisposition = { readonly kind: "return" } | { readonly kind:
 
 /** One arm of the table: what to write, and how to end. */
 export interface TerminalArm {
+  /** `EXECUTION_PHASE_UNSPECIFIED` writes no phase: the merge applies a phase only when one is sent. */
   readonly phase: ExecutionPhase;
   /** `status.error`; absent leaves it as it is (a pause is not an error). */
   readonly error?: string;
@@ -61,8 +72,7 @@ const RETURN: TerminalDisposition = { kind: "return" };
 
 /** The fixed strings of the table, in one place. Every one is pinned by a golden or a hermetic assertion. */
 export const TERMINAL_COPY = {
-  pause: {
-    row: "Execution paused by user. Use resume to continue.",
+  orchestratorStop: {
     throwMessage: "Activity paused by orchestrator",
     throwMessageAfterError: "Activity paused by orchestrator (error during pause)",
   },
@@ -138,7 +148,7 @@ export function toolCallLimitArm(): TerminalArm {
   };
 }
 
-/** The runner is draining. Not a user pause: FAILED with the shutdown copy, thrown as cancelled. */
+/** The runner is draining. Not a user's stop: FAILED with the shutdown copy, thrown as cancelled. */
 export function workerShutdownArm(): TerminalArm {
   return {
     phase: ExecutionPhase.EXECUTION_FAILED,
@@ -149,13 +159,18 @@ export function workerShutdownArm(): TerminalArm {
   };
 }
 
-/** The orchestrator paused the execution. Not an error, not complete; thrown as cancelled. */
-export function pauseArm(): TerminalArm {
+/**
+ * The orchestrator stopped the turn: a Pause or a Cancel, indistinguishable
+ * here (the module header). The transcript is settled and persisted with no
+ * phase and no row, because the workflow writes both; not an error, not
+ * complete; thrown as cancelled so the workflow sees the activity stop.
+ */
+export function orchestratorStopArm(): TerminalArm {
   return {
-    phase: ExecutionPhase.EXECUTION_PAUSED,
-    rows: [TERMINAL_COPY.pause.row],
+    phase: ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED,
+    rows: [],
     completes: false,
-    disposition: { kind: "throw", message: TERMINAL_COPY.pause.throwMessage },
+    disposition: { kind: "throw", message: TERMINAL_COPY.orchestratorStop.throwMessage },
   };
 }
 

package/src/shared/__tests__/model-client-sampling.test.ts

@@ -0,0 +1,56 @@
+/**
+ * The native execution turn's request against the REAL @langchain/anthropic
+ * (stigmer/stigmer#1341): the unit suite in model-client.test.ts mocks the
+ * wrapper, so it cannot see the wrapper's own parameter validation. That
+ * validation is what failed every native turn on claude-opus-4.7,
+ * claude-opus-4.8 and claude-fable-5 while the runner pinned temperature 0.
+ * These tests build the client the way the execution turn does and read the
+ * request parameters offline; no request leaves the process.
+ */
+import { ChatAnthropic } from "@langchain/anthropic";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { buildChatModel } from "../model-client.js";
+import { _resetRegistryCache } from "../model-registry.js";
+
+// Ids the wrapper treats as adaptive-only and refuses a sampling override
+// for, and ids it lets one through for (the provider itself refuses it on
+// claude-sonnet-5); the registry is unreachable in these tests, so each id
+// reaches the wrapper unchanged.
+const ADAPTIVE_ONLY_IDS = ["claude-opus-4-7", "claude-opus-4-8", "claude-fable-5"];
+const SAMPLING_TOLERANT_IDS = ["claude-sonnet-4-6", "claude-opus-4-6", "claude-sonnet-5", "claude-haiku-4-5-20251001"];
+
+async function executionTurnParams(modelName: string, temperature: number | null | undefined) {
+  const { model } = await buildChatModel({
+    modelName,
+    proxyEndpoint: "http://127.0.0.1:9",
+    stigmerToken: "sampling-test",
+    temperature,
+  });
+  return (model as ChatAnthropic).invocationParams({});
+}
+
+describe("the native execution turn's sampling parameters (real @langchain/anthropic)", () => {
+  beforeEach(() => {
+    _resetRegistryCache();
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("registry unreachable in this test"));
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    _resetRegistryCache();
+    vi.restoreAllMocks();
+  });
+
+  it.each(ADAPTIVE_ONLY_IDS)("%s: the pinned temperature 0 is refused before any request", async (id) => {
+    await expect(executionTurnParams(id, undefined)).rejects.toThrow(/temperature is not supported/);
+  });
+
+  it.each([...ADAPTIVE_ONLY_IDS, ...SAMPLING_TOLERANT_IDS])(
+    "%s: with no temperature the request builds and carries no sampling override",
+    async (id) => {
+      const params = await executionTurnParams(id, null);
+      expect(params).not.toHaveProperty("temperature");
+    },
+  );
+});

package/src/shared/__tests__/model-client.test.ts

@@ -156,6 +156,21 @@ describe("buildChatModel", () => {
     expect(lastAnthropicArgs()).toMatchObject({ maxTokens: 4096 });
   });
 
+  it("pins temperature 0 by default, and sends none when the caller passes null", async () => {
+    mockRegistryResponse([
+      { id: "claude-opus-4.8", apiModelId: "claude-opus-4-8", provider: "anthropic" },
+    ]);
+
+    await buildChatModel({ modelName: "claude-opus-4.8" });
+    expect(lastAnthropicArgs()).toMatchObject({ temperature: 0 });
+
+    await buildChatModel({ modelName: "claude-opus-4.8", temperature: 0.3 });
+    expect(lastAnthropicArgs()).toMatchObject({ temperature: 0.3 });
+
+    await buildChatModel({ modelName: "claude-opus-4.8", temperature: null });
+    expect(lastAnthropicArgs()).not.toHaveProperty("temperature");
+  });
+
   it("passes the model id through unchanged when the registry is unavailable", async () => {
     vi.spyOn(globalThis, "fetch").mockRejectedValueOnce(new Error("network down"));
 

package/src/shared/__tests__/worker-shutdown.test.ts

@@ -54,8 +54,8 @@ describe("classifyTurnInterruption", () => {
     expect(classifyTurnInterruption({ cancellationReason: undefined, shutdownSignalAborted: true })).toBe("none");
   });
 
-  it("a workflow-requested cancellation without a shutdown signal is the orchestrator's pause", () => {
-    expect(classifyTurnInterruption({ cancellationReason: "CANCELLED", shutdownSignalAborted: false })).toBe("pause");
+  it("a workflow-requested cancellation without a shutdown signal is the orchestrator's stop (a Pause or a Cancel, indistinguishable here)", () => {
+    expect(classifyTurnInterruption({ cancellationReason: "CANCELLED", shutdownSignalAborted: false })).toBe("orchestrator-stop");
   });
 
   it("a delivered cancellation WITH the shutdown signal aborted is a worker shutdown, not a pause (the #776 misclassification)", () => {

package/src/shared/model-client.ts

@@ -53,8 +53,16 @@ export interface BuildChatModelOptions {
     mcpServerId?: string;
     workflowExecutionId?: string;
   };
-  /** Defaults to 0. */
-  readonly temperature?: number;
+  /**
+   * Defaults to 0. `null` sends no sampling override at all, so the
+   * provider's default applies: the native execution turn passes it,
+   * because current Anthropic models refuse a temperature other than their
+   * default (claude-opus-4.7 and later, claude-sonnet-5, claude-fable-5;
+   * @langchain/anthropic throws before the request for some of them) and
+   * the Cursor harness sends none either (stigmer/stigmer#1341). Utility
+   * calls keep their deterministic 0.
+   */
+  readonly temperature?: number | null;
   /**
    * Pass-through only; intentionally no default. Anthropic requires a value,
    * but callers differ (setup omits it, call-llm uses 4096), so the default
@@ -258,7 +266,7 @@ export async function buildChatModel(opts: BuildChatModelOptions): Promise<Built
     ? { maxRetries: opts.maxRetries ?? 0 }
     : {};
   const common = {
-    temperature: opts.temperature ?? 0,
+    ...(opts.temperature === null ? {} : { temperature: opts.temperature ?? 0 }),
     apiKey,
     ...(maxTokens ? { maxTokens } : {}),
     ...maxRetries,