@stigmer/runner 3.36.0 → 3.37.1

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

@@ -16,10 +16,11 @@
  *    module; this builder only frames them.
  *  - This harness's: the framing — `## Heading` markdown sections, the house
  *    style for a system prompt — and every text that quotes this engine's
- *    tools: the `## Skills` activation protocol (`read`, `execute(...)`), the
- *    response rules, the sub-agent delegation rules, the plan-mode
- *    read-boundary sentence, and the workspace section (the deepagents
- *    backend's path resolution is this engine's).
+ *    tools: the `## Skills` activation protocol, the response rules, the
+ *    working rules, the plan-mode read-boundary sentence, and the workspace
+ *    section (the deepagents backend's path resolution is this engine's).
+ *    Every tool name those texts quote is interpolated from `engine-tools.ts`,
+ *    the names the engine binds.
  *
  * The rendered bytes are load-bearing for the hermetic tests: `ScriptedModel`
  * tells its scripted roles apart by the system prompt's text, so this
@@ -49,13 +50,15 @@ import {
 import type { ResolvedAttachment } from "../../shared/attachment-resolver.js";
 import type { SkillMetadata } from "../../shared/skill-resolver.js";
 import { STIGMER_LOCAL_STATE_DIR } from "../../shared/workspace/stigmer-link.js";
+import { DEFAULT_MAX_CONCURRENT } from "../../shared/subagent-gate.js";
+import { ENGINE_TOOL } from "./engine-tools.js";
 
 const RESPONSE_RULES = `
 
 ## Response rules
 
-- After using the read tool, NEVER reprint, echo, list, or summarize \
-file contents in your response. Tool results are already in your \
+- After reading a file with \`${ENGINE_TOOL.readFile}\`, NEVER reprint, echo, \
+list, or summarize file contents in your response. Tool results are already in your \
 context. Proceed directly to analysis or the task.
 - Do not begin responses with phrases like \
 "Below is the complete content", \
@@ -68,53 +71,53 @@ and shell commands (e.g., \`src/main.py\`, \`handleRequest()\`, \
 code blocks that the user can see in tool results.
 - Structure complex answers with headings and bullet points.
 - If you encounter something unexpected that changes the scope, \
-explain the issue and propose options before proceeding.
-`;
-
-const SUB_AGENT_RULES = `
-
-## Sub-agent delegation rules
-
-### Concurrency limit
-
-Do NOT spawn more than 3 sub-agents concurrently. If you need to \
-explore more than 3 areas, batch them: launch the first 3, wait for \
-results, then launch more if needed. The runtime enforces this limit — \
-excess sub-agents will be rejected.
-
-### When NOT to delegate
-
-- **Reading files.** Use the \`read\` tool yourself. You need raw file \
-contents in your own context to reason about them accurately.
-- **Single-step lookups.** Use \`grep\`, \`glob\`, \`search\`, or \`read\` \
-directly for simple searches across 1-2 files. Only delegate when \
-the task requires multi-step exploration.
-- **Data you will process yourself.** If you need the output in your \
-own context (e.g., to answer a question, write code, compare files), \
-do the work directly — do not delegate it.
-- **Small tasks (fewer than 3 steps).** The overhead of spawning a \
-sub-agent outweighs the benefit for trivial operations.
-
-### When TO delegate
-
-- Multi-step, independent tasks that produce a deliverable (analysis, \
-synthesis, generated content) you will incorporate into your response.
-- Parallel exploration of genuinely different areas of a codebase or \
-knowledge base when context isolation helps.
-- Tasks that benefit from a separate context window (e.g., long \
-document summarization that would crowd your own context).
-
-### Delegation best practices
-
-- When delegating, specify the **deliverable** you need — not \
-"read these files and give me the contents."
-- You MUST reference and synthesize sub-agent results in your \
-response. If you spawn a sub-agent, its output must visibly \
-influence your answer.
-- Each sub-agent consumes tokens and time. Prefer doing work \
-directly over delegating. Only delegate when context isolation \
-or parallelism genuinely helps the user.
-`;
+explain the issue and propose options before proceeding.`;
+
+// Every section of this prompt opens with its own blank line ("\n\n## ...")
+// and ends on its last line, so sections are one blank line apart (#1127).
+
+/**
+ * How to work with the tools, and when to delegate: the rules that decide
+ * how many model calls a turn takes. Each round re-sends the whole prompt,
+ * so a round saved is the turn's largest saving; the benchmark's per-call
+ * record (test/conformance src/benchmark/tool-call-facts.ts) showed where
+ * they went.
+ *
+ * - The path model comes first because the file tools speak the virtual
+ *   root (`/` is the workspace; `middleware/path-normalization.ts`), and a
+ *   model that is told nothing uses whatever path it saw last. `execute`
+ *   runs with the workspace as its working directory (deepagents
+ *   `LocalShellBackend`), so a `cd` into it is a wasted prefix; plan mode
+ *   binds no shell, so its prompt says nothing about commands.
+ * - Edits to different files may go in one response; several edits to ONE
+ *   file are not asked for in one response, because each is a
+ *   read-modify-write of the same bytes. Changes that sit close together go
+ *   in one call instead.
+ * - The sub-agent rules keep the one hard fact the model cannot see, the
+ *   concurrency cap `shared/subagent-gate.ts` enforces by refusal, and leave
+ *   the delegation mechanics to the `task` tool's own description.
+ */
+function workingRules(interactionMode: InteractionMode | undefined): string {
+  const commands =
+    interactionMode === InteractionMode.PLAN
+      ? ""
+      : ` Commands run in the workspace, so \`${ENGINE_TOOL.execute}\` needs no \`cd\`.`;
+  return `
+
+## Working with tools
+
+- Your file tools see the workspace as \`/\`: a file at its top level is \`/README.md\`.${commands}
+- Make independent tool calls together in one response: read every file you need at once, and edit different files at once. Wait for a result only when the next call depends on it.
+- When one file needs changes that sit close together, make them in one \`${ENGINE_TOOL.editFile}\` call.
+- A file you have read stays in your context. Read it again only if something other than your own edit changed it.
+- After your edits, run the checks once. Run them again only after a fix.
+
+## Sub-agents
+
+- Do the work yourself unless it is a multi-step, independent task whose result you need only as a summary. Never delegate reading a file you must reason about.
+- At most ${DEFAULT_MAX_CONCURRENT} sub-agents run at once; the runtime rejects more.
+- Tell a sub-agent exactly what to return, and use what it returns.`;
+}
 
 export interface PromptBuilderInput {
   /** The blueprint's instructions, raw; empty reads the built-in assistant's (shared/builtin-assistant-prompt.ts). */
@@ -272,7 +275,7 @@ export function buildEnhancedSystemPrompt(input: PromptBuilderInput): string {
   }
 
   prompt += RESPONSE_RULES;
-  prompt += SUB_AGENT_RULES;
+  prompt += workingRules(input.interactionMode);
 
   // Last sections on purpose: these per-execution directives redefine the
   // turn's deliverable, so they must be the freshest instruction the model
@@ -347,7 +350,7 @@ export function renderSkillsSection(skills: readonly SkillMetadata[]): string {
     "knowledge or capabilities.",
     "",
     "**Activation protocol**: To use a skill, read its SKILL.md file " +
-    "using the `read` tool. The SKILL.md contains detailed instructions, " +
+    `with \`${ENGINE_TOOL.readFile}\`. The SKILL.md contains detailed instructions, ` +
     "available tools, and usage examples.",
     "",
     "**Usage pattern**:",
@@ -356,8 +359,8 @@ export function renderSkillsSection(skills: readonly SkillMetadata[]): string {
     "2. Read `{location}/SKILL.md` for full instructions",
     "3. Follow the skill's documented operations:",
     "",
-    "`read {location}/references/schema.md`",
-    '`execute("python3 {location}/scripts/run.py")`',
+    `\`${ENGINE_TOOL.readFile}\` on \`{location}/references/schema.md\``,
+    `\`${ENGINE_TOOL.execute}\` with \`python3 {location}/scripts/run.py\``,
     "",
   ];
 
@@ -366,7 +369,7 @@ export function renderSkillsSection(skills: readonly SkillMetadata[]): string {
     lines.push(`### ${skill.name}`);
     lines.push(`**Description**: ${skill.description || "(no description)"}`);
     lines.push(`**Location**: \`${skillDir}/\``);
-    lines.push(`**Activate**: \`read ${skillDir}/SKILL.md\``);
+    lines.push(`**Activate**: \`${ENGINE_TOOL.readFile}\` on \`${skillDir}/SKILL.md\``);
     lines.push("");
   }
 
@@ -410,16 +413,16 @@ function buildMultiWorkspaceSection(
   let section =
     `\n\n## Workspace\n\n` +
     `This session has ${results.length} workspace entries.\n\n` +
-    `**Path resolution**: All tools resolve paths relative to the ` +
-    `workspace root. Use entry-relative paths ` +
-    `(e.g., \`${firstLabel}/src/main.py\`). ` +
-    `Do not use absolute filesystem paths.\n`;
+    `**Path resolution**: each entry is a directory at the workspace ` +
+    `root; name a file by its entry (e.g., \`/${firstLabel}/src/main.py\`).`;
 
+  // Entries are joined by a blank line, so an entry's file tree never runs
+  // into the next entry's heading (#1127).
   for (let idx = 0; idx < results.length; idx++) {
     const result = results[idx];
     const label = result.entryName || `entry-${idx + 1}`;
     const relPath = workspaceRelativePath(result.rootDir, containerRoot);
-    section += `\n### ${label} (\`${relPath}\`)\n\n`;
+    section += `\n\n### ${label} (\`${relPath}\`)\n\n`;
     section += formatEntryDescription(result);
     if (result.fileTree) {
       section += "\n\n" + result.fileTree;
@@ -445,8 +448,7 @@ function formatEntryDescription(result: ProvisionResult): string {
 
   if (result.sourceType === "local_path") {
     return (
-      `Workspace entry **${name}** is the user's project directory ` +
-      `at \`${result.rootDir}\`.\n` +
+      `Workspace entry **${name}** is the user's project directory.\n` +
       "You are operating directly on the user's files — changes are " +
       "immediate and persistent. Use git to track and verify your changes."
     );
@@ -483,7 +485,7 @@ function buildReferencedFilesSection(
   let section =
     "\n\n## Referenced Files\n\n" +
     "The user has highlighted the following workspace paths for your " +
-    "attention. Use `read` to access file contents.\n\n";
+    `attention. Use \`${ENGINE_TOOL.readFile}\` to access file contents.\n\n`;
 
   for (const refPath of workspaceFileRefs) {
     section += `- \`${refPath}\`\n`;
@@ -494,7 +496,7 @@ function buildReferencedFilesSection(
 
 /**
  * The `## Input Files` section: this harness's intro (it names this engine's
- * `read` tool) around the shared lines (`prompt-sections.ts` `inputFileLines`
+ * file-reading tool) around the shared lines (`prompt-sections.ts` `inputFileLines`
  * says what each bullet and disclosure carries and why). Each disclosure
  * group is set off by a blank line, the markdown idiom.
  */
@@ -508,7 +510,7 @@ function buildInputFilesSection(
     "The following files have been provided as read-only reference " +
     "material for your task. They live under `.stigmer/inputs/` and " +
     "are NOT part of the project source tree.\n\n" +
-    "Read them using the `read` tool when you need their contents. " +
+    `Read them with \`${ENGINE_TOOL.readFile}\` when you need their contents. ` +
     "Do NOT echo, reprint, or summarize file contents in your response " +
     "-- they are reference material, not output. " +
     "Do NOT modify or delete these files.\n\n";
@@ -524,5 +526,7 @@ function buildInputFilesSection(
     section += "\n" + lines.vision.join("\n") + "\n";
   }
 
-  return section;
+  // Every section opens with its own blank line ("\n\n## ..."), so this one
+  // ends on its last line rather than adding a second blank (#1127).
+  return section.replace(/\n+$/, "");
 }

package/src/activities/execute-deep-agent/subagent-transformer.ts

@@ -22,7 +22,7 @@
  * - Empty subagent list returns null (no subagents configured)
  */
 
-import { createDeepAgent, FilesystemBackend, LocalShellBackend, DEFAULT_GENERAL_PURPOSE_DESCRIPTION, DEFAULT_SUBAGENT_PROMPT } from "deepagents";
+import { createDeepAgent, FilesystemBackend, LocalShellBackend, DEFAULT_SUBAGENT_PROMPT } from "deepagents";
 import type { AnyBackendProtocol, CompiledSubAgent, FilesystemPermission } from "deepagents";
 import type { StructuredTool } from "@langchain/core/tools";
 import type { RunnableConfig } from "@langchain/core/runnables";
@@ -42,6 +42,7 @@ import { SubAgentGate } from "../../shared/subagent-gate.js";
 import { isModelRegistered } from "../../shared/model-registry.js";
 import type { SkillMetadata } from "../../shared/skill-resolver.js";
 import { renderSkillsSection } from "./prompt-builder.js";
+import { ENGINE_TOOL } from "./engine-tools.js";
 
 // =========================================================================
 // Built-in subagent types and prompts
@@ -53,33 +54,44 @@ export const BUILTIN_SUBAGENT_TYPES: ReadonlySet<string> = new Set([
   "general-purpose",
 ]);
 
+// The task arrives as the sub-agent's first message (deepagents' `task`
+// tool), so a prompt carries no slot for it. Tool names come from the one
+// table of bound names (`engine-tools.ts`).
 const EXPLORE_SYSTEM_PROMPT = `\
 You are an exploration specialist. Your ONLY job is to explore codebases \
 and report findings back to the parent agent.
 
 STRICT BOUNDARIES:
-- Use ONLY the read-only tools provided (read_file, list_dir, glob, grep, search)
+- Use ONLY the read-only tools (${ENGINE_TOOL.readFile}, ${ENGINE_TOOL.ls}, ${ENGINE_TOOL.glob}, ${ENGINE_TOOL.grep})
 - Do NOT write files, create files, or modify anything
 - Do NOT execute shell commands
 - Do NOT follow skill activation instructions from any context
 - Do NOT create deliverables, scaffolds, or run initialization scripts
-- Report your findings concisely — the parent agent has direct file access
-
-Your task: {description}`;
+- Report your findings concisely — the parent agent has direct file access`;
 
 const SHELL_SYSTEM_PROMPT = `\
 You are a command execution specialist. Your ONLY job is to run shell \
 commands and report the results back to the parent agent.
 
 STRICT BOUNDARIES:
-- Use ONLY the tools provided (execute, read_file, list_dir)
+- Use ONLY ${ENGINE_TOOL.execute}, ${ENGINE_TOOL.readFile} and ${ENGINE_TOOL.ls}
 - Do NOT write or modify files directly — use shell commands if needed
 - Do NOT search extensively or explore the codebase beyond what is needed
 - Do NOT follow skill activation instructions from any context
 - Do NOT create deliverables, scaffolds, or run initialization scripts
-- Report command output concisely — the parent agent will interpret results
+- Report command output concisely — the parent agent will interpret results`;
 
-Your task: {description}`;
+/**
+ * The general-purpose sub-agent's line in the `task` tool. Stigmer's own
+ * words rather than upstream's `DEFAULT_GENERAL_PURPOSE_DESCRIPTION`, which
+ * invites delegating a search ("use this agent to perform the search for
+ * you") that the parent's working rules tell it to do itself
+ * (`prompt-builder.ts`): each delegation is a sub-agent's own rounds on top
+ * of the parent's.
+ */
+const GENERAL_PURPOSE_DESCRIPTION =
+  "Runs a multi-step task with the same tools as you, in its own context, and returns one report. " +
+  "Use it only for independent work you need as a summary.";
 
 const BUILTIN_DESCRIPTIONS: ReadonlyMap<string, string> = new Map([
   ["explore", (
@@ -102,8 +114,8 @@ const RESPONSE_RULES = `\
 
 ## Response rules
 
-- After using the read tool, NEVER reprint, echo, list, or \
-summarize file contents in your response. Tool results are \
+- After reading a file with ${ENGINE_TOOL.readFile}, NEVER reprint, echo, \
+list, or summarize file contents in your response. Tool results are \
 already in your context. Proceed directly to the task.
 - Your response is returned to the parent agent as a task \
 result. Return concise findings and actionable results — not \
@@ -215,8 +227,11 @@ export interface SubagentTransformOptions {
  * general-purpose is the gated replacement for the sub-agent deepagents would
  * otherwise auto-inject WITHOUT our approval gate (suppressed process-wide in
  * deepagents-profiles.ts; supplying our own under the same name is the
- * documented override path). It uses deepagents' own description/prompt so the
- * model's delegation behavior is unchanged, and receives the parent's MCP tools
+ * documented override path). It keeps deepagents' own prompt, but its line in
+ * the `task` tool is Stigmer's ({@link GENERAL_PURPOSE_DESCRIPTION}): it was
+ * upstream's while the goal was parity with the suppressed original, and
+ * upstream's invites the delegation the parent's rules advise against. It
+ * receives the parent's MCP tools
  * for capability parity with the injected original. Conscious simplification:
  * the parent's skills prompt is NOT inherited — a sub-agent needing skills
  * should be declared explicitly in the Agent spec.
@@ -239,7 +254,7 @@ export function createBuiltinSubagents(
     if (subagentType === "general-purpose") {
       result.push({
         name: "general-purpose",
-        description: DEFAULT_GENERAL_PURPOSE_DESCRIPTION,
+        description: GENERAL_PURPOSE_DESCRIPTION,
         systemPrompt: DEFAULT_SUBAGENT_PROMPT + RESPONSE_RULES,
         // Parent-parity tool set: MCP tools plus the native web_fetch the
         // parent always carries. explore/shell stay web-less on purpose —

package/src/activities/execute-deep-agent/todo-list.ts

@@ -0,0 +1,56 @@
+/**
+ * The parent's to-do list: langchain's `todoListMiddleware`, with Stigmer's
+ * words for its tool and its system line.
+ *
+ * Why the middleware and not our own: it owns the `todos` state channel, the
+ * tool, and the refusal of two list updates in one response, and the
+ * product reads what it writes (the parent's `write_todos` is what
+ * `status.todos` projects and what the clients' progress card renders,
+ * `harness/transcript/builder.ts`, `shared/todos.ts`). Parent only: a
+ * sub-agent's list never reaches the execution.
+ *
+ * Why our own words: langchain's defaults are an 11.4 KB tool description
+ * and a 1 KB system block, sent on every model call of every turn whether
+ * or not a list is kept, and they ask for the list to be updated "as soon
+ * as you are done with a step. Do not batch", which the benchmark's
+ * per-call record showed as one model call per update, five of seventeen on
+ * a multi-part task. These texts keep what the product relies on (a list for
+ * work of several parts, the three states the card shows, one item in
+ * progress) and make each update ride with another tool call.
+ *
+ * The threshold is "several separate parts", not a step count: a first cut
+ * said "three or more distinct steps", and the model then kept a list on a
+ * one-change edit (read, edit, test) with every update in a round of its
+ * own. A soft "update with your next action" was not followed either, so
+ * the rule names the call's company outright.
+ *
+ * Plan mode's build progress names no tool: its directive says "your to-do
+ * list" (`shared/implement-plan-prompt.ts`) and leaves each harness's tool
+ * to say what it is, so the description opens by saying exactly that.
+ *
+ * The system line cannot be empty: the middleware appends it as a block of
+ * its own, and an empty option would still send a whitespace block.
+ */
+
+import { todoListMiddleware } from "langchain";
+import { ENGINE_TOOL } from "./engine-tools.js";
+
+/** The to-do tool's description, as the model reads it. */
+export const TODO_TOOL_DESCRIPTION =
+  "Your to-do list, shown to the user as your progress. Use it when a request has several separate parts, " +
+  "or when the user asks for one. Skip it for a single change, however many steps it takes, and for questions.\n" +
+  "- Send the whole list each time. Each item is pending, in_progress or completed; keep exactly one " +
+  "in_progress while you work.\n" +
+  `- A \`${ENGINE_TOOL.writeTodos}\` call always shares its response with another tool call: update the list ` +
+  "alongside your next action, never in a response of its own, and send the last update with your last tool call.\n" +
+  "- Call this tool at most once per response.";
+
+/** The line the middleware adds to the system prompt. */
+export const TODO_SYSTEM_PROMPT =
+  `Keep a to-do list with \`${ENGINE_TOOL.writeTodos}\` when a request has several separate parts; ` +
+  "the user sees it as your progress.";
+
+/** The parent graph's to-do middleware, with Stigmer's texts. */
+export function createTodoListMiddleware(): ReturnType<typeof todoListMiddleware> {
+  return todoListMiddleware({ toolDescription: TODO_TOOL_DESCRIPTION, systemPrompt: TODO_SYSTEM_PROMPT });
+}

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

@@ -40,7 +40,6 @@ import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import type { DynamicStructuredTool } from "@langchain/core/tools";
 import type { Command } from "@langchain/langgraph";
 import { createDeepAgent } from "deepagents";
-import { todoListMiddleware } from "langchain";
 import { InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
 import type { Config } from "../../config.js";
@@ -77,6 +76,7 @@ import { resolveResumeInput, type GraphStateSnapshot } from "./hitl.js";
 import { buildEnhancedSystemPrompt, composeUserMessage, renderSkillsSection } from "./prompt-builder.js";
 import { buildShellEnv } from "./shell-env.js";
 import { modelHasNativeThinking, transformAndCompileSubagents } from "./subagent-transformer.js";
+import { createTodoListMiddleware } from "./todo-list.js";
 
 /**
  * The runner config this harness reads per turn, as a named slice
@@ -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");
@@ -472,13 +478,11 @@ export async function buildEngine(
     systemPrompt,
     tools: graphTools,
     // The to-do list rides ahead of Stigmer's stack: deepagents stopped
-    // installing it by default (1.12), and the product reads it — the parent's
-    // `write_todos` is what `status.todos` projects and what plan mode's
-    // build progress is instructed through (`shared/implement-plan-prompt.ts`).
-    // The framework's own middleware, with its default texts. Parent only: a
-    // sub-agent's list never reaches the execution (`harness/transcript/builder.ts`).
+    // installing it by default (1.12), and the product reads it. The
+    // framework's own middleware with Stigmer's texts; parent only
+    // (`todo-list.ts` says why for both).
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    middleware: [todoListMiddleware(), ...middleware] as any,
+    middleware: [createTodoListMiddleware(), ...middleware] as any,
     subagents: compiledSubagents ?? undefined,
     ...(responseFormat ? { responseFormat } : {}),
     ...(planModePermissions ? { permissions: planModePermissions } : {}),

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/middleware/__tests__/path-normalization.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, vi } from "vitest";
 import { ToolMessage } from "@langchain/core/messages";
 import {
   createPathNormalizationMiddleware,
+  normalizeGlobPattern,
   normalizeWorkspacePathArg,
 } from "../path-normalization.js";
 import type { ToolCallRequest } from "../types.js";
@@ -110,6 +111,23 @@ describe("createPathNormalizationMiddleware", () => {
     }
   });
 
+  it("maps a glob pattern that opens with the real root to its virtual form", async () => {
+    const args = await argsSeenByHandler("glob", { pattern: `${ROOT}/duration/*_test.go` });
+    expect(args.pattern).toBe("/duration/*_test.go");
+  });
+
+  it("repairs the glob pattern and the base path of one call together", async () => {
+    const args = await argsSeenByHandler("glob", { path: `${ROOT}/src`, pattern: `${ROOT}/src/**/*.go` });
+    expect(args.path).toBe("/src");
+    expect(args.pattern).toBe("/src/**/*.go");
+  });
+
+  it("rewrites a real-root prefix in glob's pattern only, never in grep's", async () => {
+    // grep's pattern is literal text to find, which may well be a path.
+    const args = await argsSeenByHandler("grep", { pattern: `${ROOT}/config` });
+    expect(args.pattern).toBe(`${ROOT}/config`);
+  });
+
   it("passes canonical virtual paths through byte-untouched", async () => {
     const args = await argsSeenByHandler("read_file", { file_path: "/etc/hosts" });
     expect(args.file_path).toBe("/etc/hosts");
@@ -164,3 +182,17 @@ describe("createPathNormalizationMiddleware", () => {
     expect(original.toolCall.args.file_path).toBe("notes.md");
   });
 });
+
+describe("normalizeGlobPattern", () => {
+  it("replaces a whole leading root, keeping every wildcard", () => {
+    expect(normalizeGlobPattern(`${ROOT}/**/*.md`, ROOT)).toBe("/**/*.md");
+    expect(normalizeGlobPattern(`${ROOT}/a/*.go`, `${ROOT}/`)).toBe("/a/*.go");
+  });
+
+  it("leaves a pattern that only resembles the root, or is the root itself", () => {
+    expect(normalizeGlobPattern("**/*.go", ROOT)).toBeUndefined();
+    expect(normalizeGlobPattern(`${ROOT}-other/*.go`, ROOT)).toBeUndefined();
+    expect(normalizeGlobPattern(`${ROOT}/`, ROOT)).toBeUndefined();
+    expect(normalizeGlobPattern(`/x${ROOT}/a`, ROOT)).toBeUndefined();
+  });
+});