@cabane/companion 0.6.54 → 0.6.59

package/dist/cli.js

@@ -2423,7 +2423,7 @@ var CabaneApi = class {
     return this.request("GET", `/api/workspaces/${workspaceId}/conversations/${conversationId}`);
   }
   // CT339: spawn a sub-agent conversation — the public create-conversation
-  // endpoint (`POST /conversations/messages`) with `dispatch` + `dispatchReturn`,
+  // endpoint (`POST /conversations/messages`) with an addressed agent ask,
   // the machinery the `sub_agent` turn-control tool is sugar over. Two things make
   // it distinct from an ordinary `request` call, so it does its own `fetch`:
   //   - a PER-CALL bearer — the turn's OBO token when the API minted one, else the
@@ -2431,10 +2431,10 @@ var CabaneApi = class {
   //     cabane calls this turn (mirrors build-options' `turnToken ?? agentPat`);
   //   - the `x-cabane-active-conversation` header naming the caller's turn, which
   //     the server verifies against the live run to resolve the caller pair for the
-  //     return callout (the same origin that stamps `origin_conversation_id`).
+  //     immutable birth tether (the same origin that stamps provenance).
   // Single-shot (no outbox/retry): a `sub_agent` spawn is a live, user-visible
   // action, and its result is returned to the agent immediately. Returns
-  // `{ status, body }` un-thrown so the caller maps the callout cap / gating errors
+  // `{ status, body }` un-thrown so the caller maps validation errors
   // to a legible tool result rather than an exception.
   async createSubAgentConversation(workspaceId, activeConversationId, bearer, body) {
     const res = await fetch(`${this.base}/api/workspaces/${workspaceId}/conversations/messages`, {
@@ -2494,7 +2494,7 @@ var CabaneApi = class {
     const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "");
     return this.request("GET", `/api/agent/turn-context?${q}`);
   }
-  // CT714: read a turn's recorded turn-control intent (ask/wake/summon/skip). An
+  // CT714: read a turn's recorded turn-control intent (ask/wake/send/skip). An
   // EXTERNAL adapter (Codex / opencode) records its turn-control verbs into
   // `turn_intents` server-side (the URL MCP surface) rather than the dispatcher's
   // in-memory closures, so the dispatcher fetches this once at settle — by
@@ -3326,7 +3326,7 @@ var turnRequestSchema = z8.object({
     // EXTERNAL adapters (Codex / opencode) mount it by URL under the key
     // `cabane_companion` — using the same `bearer` (the turn token) and the same
     // active-conversation header they send to the `cabane` server — so their
-    // agents get `ask`/`wake_me`/`summon_agent`/`sub_agent`/`skip_turn`, the
+    // agents get `ask`/`wake_me`/`send`/`sub_agent`/`skip_turn`, the
     // verbs they can't get from the companion's in-process SDK server. Optional:
     // claude-code ignores it (it mounts the in-process instance instead), and
     // every existing `cabane`-block fixture keeps parsing unchanged; the
@@ -3361,7 +3361,7 @@ var turnRequestSchema = z8.object({
     // default in place (see `buildClaudeCodeOptions`).
     claudeCode: z8.object({ autoMemory: z8.boolean().optional() }).optional()
   }),
-  // Host-owned injected servers (host-filled) — e.g. the summon server.
+  // Host-owned injected servers (host-filled) — e.g. the send server.
   extra: z8.object({
     mcpServers: hostInjectedServersSchema
   })
@@ -3692,8 +3692,9 @@ var CLAUDE_CODE_ADDENDUM = [
   "`mcp__cabane__sdk`; the ancillary tools are `mcp__cabane__list_workspaces`,",
   "`mcp__cabane__read_binary`, `mcp__cabane__upload`, `mcp__cabane__begin_upload`,",
   "`mcp__cabane__finalize_upload`, and `mcp__cabane__mint_render_token`; the turn tools are",
-  "`mcp__cabane_companion__ask`, `mcp__cabane_companion__wake_me`,",
-  "`mcp__cabane_companion__summon_agent`, `mcp__cabane_companion__sub_agent`, and",
+  "`mcp__cabane_companion__ask`, `mcp__cabane_companion__reply_to`,",
+  "`mcp__cabane_companion__wake_me`,",
+  "`mcp__cabane_companion__send`, `mcp__cabane_companion__sub_agent`, and",
   "`mcp__cabane_companion__skip_turn`. Where this prompt names a tool by its bare verb, call",
   "the prefixed form from your tool list. Your harness's own tools (shell, local file",
   "read/edit) keep their ordinary names and act on the local machine only."
@@ -3806,8 +3807,19 @@ function decideResume(stored, currentCwd) {
 // packages/agent-runtime/src/claude-code/options.ts
 var CABANE_MCP_SERVER = "cabane";
 var ACTIVE_CONVERSATION_HEADER2 = "x-cabane-active-conversation";
-async function allowEverythingHook(input) {
+async function preToolUseHook(input) {
   const toolInput = "tool_input" in input && input.tool_input && typeof input.tool_input === "object" ? input.tool_input : {};
+  const toolName = "tool_name" in input ? input.tool_name : void 0;
+  if (typeof toolName === "string" && SUBAGENT_TOOLS.includes(toolName) && (toolInput.run_in_background !== false || toolInput.isolation === "remote")) {
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: "Background subagents don't survive a Cabane turn: they're children of this turn's process and are killed when it ends, so nothing will notify you. Re-run this with run_in_background: false to get the result inside this turn, or arm a wake and check back."
+      }
+    };
+  }
   return {
     continue: true,
     hookSpecificOutput: {
@@ -3892,7 +3904,7 @@ function buildClaudeCodeOptions(req, augment) {
       settingSources: ["project"],
       allowedTools,
       disallowedTools,
-      hooks: { PreToolUse: [{ hooks: [allowEverythingHook] }] }
+      hooks: { PreToolUse: [{ hooks: [preToolUseHook] }] }
     };
   } else {
     options = {
@@ -3968,6 +3980,8 @@ async function* decodeSdkStream(iter, ctx) {
         const err = msg.error;
         if (typeof err === "string" && err.length > 0) authError = err;
       } else if (msg.type === "result") {
+        const origin = msg.origin;
+        if (origin?.kind === "task-notification") continue;
         sawResult = true;
         usage = readSdkUsage(msg);
         if (usage) {
@@ -4160,6 +4174,10 @@ var resultSuccess = (sessionId) => ({
   subtype: "success",
   session_id: sessionId
 });
+var resultSuccessFull = (sessionId, extra) => ({
+  ...resultSuccess(sessionId),
+  ...extra
+});
 var resultError = (subtype) => ({
   type: "result",
   subtype,
@@ -4313,6 +4331,116 @@ var CLAUDE_CODE_CONFORMANCE_FIXTURES = [
     nativeStream: [init("s1"), resultSuccess("s1")],
     expected: [sessionEvent("s1"), { type: "result", ok: true }]
   },
+  {
+    // CT1220: on resume, a completed background task can emit a notification and
+    // its own zero-token result before the prompt's frames. That result is not the
+    // turn boundary; decoding continues through the prompt's reply and real usage.
+    name: "task-notification result does not end a resumed turn",
+    request: makeRequest({ session: encodeSession({ sdkSessionId: "s1", cwd: CWD }) }),
+    nativeStream: [
+      init("s1"),
+      {
+        type: "system",
+        subtype: "task_notification",
+        task_id: "task-1",
+        status: "completed",
+        output_file: "/tmp/task-1.output",
+        summary: "Background work completed.",
+        session_id: "s1"
+      },
+      resultSuccessFull("s1", {
+        is_error: false,
+        origin: { kind: "task-notification" },
+        usage: {
+          input_tokens: 0,
+          output_tokens: 0,
+          cache_read_input_tokens: 0,
+          cache_creation_input_tokens: 0
+        }
+      }),
+      assistantTextTool("Checking the returned work.", {
+        id: "tu1",
+        name: "mcp__cabane__cabane_read",
+        input: { path: "result.md" }
+      }),
+      toolResult("tu1", [{ type: "text", text: "ready" }]),
+      assistantText("The prompt completed normally."),
+      resultSuccessFull("s1", {
+        is_error: false,
+        usage: {
+          input_tokens: 120,
+          output_tokens: 30,
+          cache_read_input_tokens: 80,
+          cache_creation_input_tokens: 10
+        }
+      })
+    ],
+    expected: [
+      { type: "text", body: "Checking the returned work.", terminal: false },
+      {
+        type: "tool",
+        id: "tu1",
+        name: "cabane_read",
+        phase: "start",
+        summary: "result.md",
+        input: { path: "result.md" },
+        mcpServer: "cabane"
+      },
+      {
+        type: "tool",
+        id: "tu1",
+        name: "cabane_read",
+        phase: "done",
+        summary: "result.md",
+        input: { path: "result.md" },
+        result: [{ type: "text", text: "ready" }],
+        mcpServer: "cabane"
+      },
+      { type: "text", body: "The prompt completed normally.", terminal: true },
+      {
+        type: "result",
+        ok: true,
+        usage: {
+          inputTokens: 210,
+          outputTokens: 30,
+          cacheReadTokens: 80,
+          cacheCreationTokens: 10
+        }
+      }
+    ]
+  },
+  {
+    // CT1220: the filter is deliberately narrow. An origin-less zero-token result
+    // keeps today's break-on-first-result behavior, even if more frames follow.
+    name: "origin-less result still ends a resumed turn",
+    request: makeRequest({ session: encodeSession({ sdkSessionId: "s1", cwd: CWD }) }),
+    nativeStream: [
+      init("s1"),
+      resultSuccessFull("s1", {
+        is_error: false,
+        usage: {
+          input_tokens: 0,
+          output_tokens: 0,
+          cache_read_input_tokens: 0,
+          cache_creation_input_tokens: 0
+        }
+      }),
+      assistantText("This must not be emitted."),
+      resultSuccess("s1")
+    ],
+    expected: [
+      {
+        type: "result",
+        ok: true,
+        usage: {
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheCreationTokens: 0
+        }
+      }
+    ]
+  },
   {
     // Empty-final: a clean turn that ended on a tool call with no closing text.
     // The adapter emits NO final text — empty-final promotion is host/pump
@@ -4494,7 +4622,7 @@ function selectAdapter(registry, runtime) {
 // packages/agent-runtime/src/opencode/addendum.ts
 var OPENCODE_ADDENDUM = [
   "Every tool here goes by its plain name: the workspace tool is `sdk`; the turn tools are",
-  "`ask`, `wake_me`, `summon_agent`, `sub_agent`, `skip_turn`; the ancillary tools are",
+  "`ask`, `reply_to`, `wake_me`, `send`, `sub_agent`, `skip_turn`; the ancillary tools are",
   "`list_workspaces`, `read_binary`, `upload`, `begin_upload`, `finalize_upload`,",
   "`mint_render_token`; and the host tools are plain verbs too (`bash`, `read`, `edit`). Mind",
   "the collision: a bare `read` or `edit` is the HOST tool, acting on the local machine \u2014 a",
@@ -5470,8 +5598,9 @@ var CODEX_ADDENDUM = [
   "workspace tool is `mcp__cabane__sdk` \u2014 if it isn't in your visible tool list, locate it in",
   "the deferred-tool inventory and invoke that exact qualified name; never conclude the SDK is",
   "absent without attempting discovery and invocation, and if a call fails, report the recorded",
-  "error. The turn tools are `mcp__cabane_companion__ask` / `wake_me` / `summon_agent` /",
-  "`sub_agent` / `skip_turn`, and the ancillary tools `mcp__cabane__list_workspaces` /",
+  "error. The turn tools are `mcp__cabane_companion__ask` / `reply_to` / `wake_me` /",
+  "`send` / `sub_agent` / `skip_turn`, and the ancillary tools",
+  "`mcp__cabane__list_workspaces` /",
   "`read_binary` / `upload` / `begin_upload` / `finalize_upload` / `mint_render_token` \u2014 all",
   "possibly deferred too. There is no Cabane `read`/`write`/`search` tool \u2014 those are",
   "`cabane.*` calls inside your program. One more harness fact: you can interleave narration",
@@ -6969,15 +7098,17 @@ import { createHash as createHash2, randomUUID } from "crypto";
 import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync10, readdirSync as readdirSync2, statSync } from "fs";
 import { join as join14 } from "path";
 
-// src/summon.ts
+// src/turn-control-tools.ts
 import { z as z13 } from "zod";
 var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
-var SUMMON_AGENT_TOOL = "summon_agent";
-var SUMMON_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUMMON_AGENT_TOOL}`;
+var SEND_TOOL = "send";
+var SEND_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SEND_TOOL}`;
 var COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
 var SKIP_TURN_TOOL = "skip_turn";
 var ASK_TOOL = "ask";
 var ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${ASK_TOOL}`;
+var REPLY_TO_TOOL = "reply_to";
+var REPLY_TO_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${REPLY_TO_TOOL}`;
 var MAX_ASK_ITEMS = 20;
 var SUB_AGENT_TOOL = "sub_agent";
 var SUB_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUB_AGENT_TOOL}`;
@@ -6985,8 +7116,11 @@ var WAKE_ME_TOOL = "wake_me";
 var WAKE_ME_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WAKE_ME_TOOL}`;
 var CANCEL_WAKE_TOOL = "cancel_wake";
 var CANCEL_WAKE_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${CANCEL_WAKE_TOOL}`;
-function createSummonState() {
-  return { agentId: null };
+function createReplyState() {
+  return { answersMessageId: null };
+}
+function createSendState() {
+  return { agentId: null, message: null };
 }
 function createSkipState() {
   return { skipped: false, reason: null };
@@ -6997,6 +7131,19 @@ function createAskState() {
 function createWakeState() {
   return { afterSeconds: null, at: null, note: null, cancelled: false };
 }
+function resolveDeclaredReplyField(input) {
+  const explicit = input.replyState.answersMessageId;
+  if (explicit) return { answersMessageId: explicit };
+  if (input.kind !== "final") return {};
+  if (!input.owedReplyMessageId) return {};
+  const outwardSend = Boolean(
+    input.sendState.agentId && input.sendState.message && input.sendState.agentId !== input.agentId
+  );
+  const askRaised = Boolean(input.askState.targetUserId);
+  const wakeArmed = input.wakeState.afterSeconds !== null || input.wakeState.at !== null;
+  if (outwardSend || askRaised || wakeArmed || input.spawnedSubAgent) return {};
+  return { answersMessageId: input.owedReplyMessageId };
+}
 function wakeCommitField(state) {
   if (state.cancelled) return { wake: { cancel: true } };
   const { afterSeconds, at, note } = state;
@@ -7009,27 +7156,50 @@ function wakeCommitField(state) {
     }
   };
 }
-function createSummonMcpServer(summonState, skipState, askState, subAgentCreate, wakeState) {
+function createTurnControlMcpServer(sendState, skipState, askState, subAgentCreate, wakeState, replyState) {
   return createSdkMcpServer({
     name: COMPANION_LOCAL_MCP_SERVER,
     version: "0.0.0",
     tools: [
       tool(
-        SUMMON_AGENT_TOOL,
-        "Summon another agent into THIS conversation \u2014 dispatch a peer to reply here on your turn. Use it to hand part of the work to a teammate, or pull in an expert, without leaving the conversation. Pass the peer's `agentId` \u2014 every agent's handle and id is on the roster in your turn context. The peer is dispatched on your turn's final reply, so write the context/ask into that reply first \u2014 it receives your message + this conversation to work from. Writing `@handle` in your prose does NOT summon anyone (agent prose never dispatches); this tool is the only in-thread lever. Single target \u2014 the last call wins. Summoning yourself is a no-op. Reach for it when the human wants the peer's answer right HERE, in front of them \u2014 the reply lands in this thread, so there's no return to wire (a return is for work YOU consume, never a courtesy notification). A handoff to a DIFFERENT conversation is `cabane.conversations.create` / `cabane.conversations.post` with their `dispatch` field instead.",
+        SEND_TOOL,
+        "Send one addressed message to another agent in THIS conversation. Pass the peer's `agentId` and the complete `message` they should act on; the server writes it separately from your terminal reply. Writing `@handle` in prose dispatches nobody. Single target \u2014 the last call wins. Sending to yourself is a no-op. A handoff to a DIFFERENT conversation is `cabane.conversations.create` / `cabane.conversations.post` with their `dispatch` field instead. Never use send to hand an answer back to the requester \u2014 declare that with reply_to.",
         {
           agentId: z13.string().uuid().describe(
-            "The peer agent to summon \u2014 a workspace agent id, from your turn context's roster."
-          )
+            "The peer agent to address \u2014 a workspace agent id, from your turn context's roster."
+          ),
+          message: z13.string().min(1).max(65536).describe("The complete new request the peer should receive and act on.")
         },
         async (args) => {
-          summonState.agentId = args.agentId;
+          sendState.agentId = args.agentId;
+          sendState.message = args.message;
           return {
-            content: [{ type: "text", text: JSON.stringify({ summoned: args.agentId }) }]
+            content: [{ type: "text", text: JSON.stringify({ sent: args.agentId }) }]
           };
         },
         { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
       ),
+      ...replyState ? [
+        tool(
+          REPLY_TO_TOOL,
+          "Declare which addressed ask your final response answers. Pass the `messageId` shown as the owed reply id in your turn context, then finish your response normally. This records lineage only: it does not send another message. The server verifies that this agent owes that ask in this conversation; one reply per turn, last call wins.",
+          {
+            messageId: z13.string().uuid().describe("The owed ask message id from this turn context.")
+          },
+          async (args) => {
+            replyState.answersMessageId = args.messageId;
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({ answersMessageId: args.messageId })
+                }
+              ]
+            };
+          },
+          { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
+        )
+      ] : [],
       ...skipState ? [
         tool(
           SKIP_TURN_TOOL,
@@ -7050,7 +7220,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
       ...askState ? [
         tool(
           ASK_TOOL,
-          `Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass \`targetUserId\` (a workspace member's user id \u2014 every person's id is on the roster in your turn context). Two forms: a SINGLE question \u2014 a \`headline\` (the actual question as one clear, capitalized sentence ending in \`?\`, "Do we go to prod?") plus a short \`question\` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a \`questions\` array of 1\u2013${MAX_ASK_ITEMS} items, each \`{ headline, body?, options? }\`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence \`headline\`, a short \`body\` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 \`options\` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label or a whole sentence. Provide EITHER \`question\` (single) or \`questions\` (array), never both. The ask is a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use summon/dispatch instead.`,
+          `Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass \`targetUserId\` (a workspace member's user id \u2014 every person's id is on the roster in your turn context). Two forms: a SINGLE question \u2014 a \`headline\` (the actual question as one clear, capitalized sentence ending in \`?\`, "Do we go to prod?") plus a short \`question\` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a \`questions\` array of 1\u2013${MAX_ASK_ITEMS} items, each \`{ headline, body?, options? }\`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence \`headline\`, a short \`body\` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 \`options\` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label or a whole sentence. Provide EITHER \`question\` (single) or \`questions\` (array), never both. The ask is a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use send/dispatch instead.`,
           {
             targetUserId: z13.string().uuid().describe(
               "The workspace member (human) to ask \u2014 a user id, from your turn context's roster."
@@ -7123,10 +7293,10 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
       ...subAgentCreate ? [
         tool(
           SUB_AGENT_TOOL,
-          "Spawn a sub-agent \u2014 hand a piece of work to a private worker with a fresh context window, whose result comes back to you automatically. Modeled on the Task tool, with ONE deliberate difference: it does NOT return the result inline. A callee's turn can run for minutes and no turn may hold an unbounded wait, so the shape is spawn-now, results-on-wake \u2014 this returns immediately with the child's `conversationId`, and the outcome lands LATER as a message in THIS conversation; you're woken once every sub-agent you have out in this conversation has returned. So DON'T wait for it: after spawning, finish whatever else this turn can do and end your turn (never poll the child with reads in a loop \u2014 the wake is automatic). Parallel fan-out = call this N times in one turn (they run concurrently; ONE wake when all are in); series = one call per turn. `prompt` is the child's opening instruction \u2014 make it self-contained (the sub-agent starts fresh, with only this prompt + the thread it lands in). `agentId` (optional) dispatches a PEER instead of yourself \u2014 same mechanics, a different mind (use for capability/context you lack); default (self) is the pure sub-worker with a clean context window. `title` (optional) names the child thread (results link it, so a legible title helps). A single sub-agent has no wall-clock advantage (you idle either way) \u2014 it pays when the callee has capability/context you lack, or to isolate a big read from your own session; the real win is fan-out. Don't spawn one for a lookup you can do in-turn with your own tools. The result returns to YOU to act on \u2014 reach for it when you're the consumer of the output, not as a way to notify a human: if a person just wants to read the result, dispatch a plain (no-return) conversation and link it instead of spawning a sub-agent.",
+          "Ask into a child conversation \u2014 a bounded question or piece of work whose ANSWER returns to you automatically. This creates the child and dispatches its agent now, returning the child's `conversationId` immediately; the answer lands LATER as a message in THIS conversation, and you're woken once every child you asked this turn has answered. So DON'T wait: after asking, finish whatever else this turn can do and end your turn (never poll the child with reads in a loop \u2014 the wake is automatic and it carries the answer). Parallel fan-out = call this N times in one turn (they run concurrently; ONE wake carrying all the answers); series = one call per turn. `prompt` is the ask itself \u2014 write it as a request that expects an answer back, not a role you are assigning or a job description: self-contained (the child starts fresh, with only this prompt), and say what shape the answer should take. `agentId` (optional) asks a PEER instead of yourself \u2014 same mechanics, a different mind (use for capability/context you lack); default (self) is a fresh context window of you. `title` (optional) names the child thread (answers link it, so a legible title helps). A single child buys no wall-clock time (you idle either way) \u2014 it pays when the callee has capability/context you lack, or to isolate a big read from your own session; the real win is fan-out. Don't ask a child for a lookup you can do in-turn with your own tools. The answer returns to YOU to act on \u2014 reach for it when you're the consumer of the output, not as a way to notify a human: if a person just wants to read the result, dispatch a plain (no-return) conversation and link it instead.",
           {
             prompt: z13.string().min(1).max(65536).describe(
-              "The sub-agent's opening instruction \u2014 self-contained (it starts with a fresh context window; only this prompt + the thread it lands in)."
+              "The ask \u2014 a self-contained request that expects an answer back (the child starts fresh: only this prompt + the thread it lands in). Say what shape the answer should take."
             ),
             agentId: z13.string().uuid().optional().describe(
               "Optional peer to run the sub-agent as (a workspace agent id, from your turn context's roster); omit to spawn yourself with a fresh context window."
@@ -7147,7 +7317,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
                   type: "text",
                   text: JSON.stringify({
                     conversationId: result.conversationId,
-                    note: "Spawned. Don't wait for it \u2014 finish what else this turn can do, then end your turn; the result posts back here and you're woken once every sub-agent you have out in this conversation has returned."
+                    note: "Asked. Don't wait for it \u2014 finish what else this turn can do, then end your turn; the answer posts back here and you're woken once every child you asked this turn has answered."
                   })
                 }
               ]
@@ -7286,10 +7456,9 @@ function buildCompanionTurnRequest(params) {
       // CT289: the auto-memory escape hatch, when the operator set it.
       ...params.claudeCode ? { claudeCode: params.claudeCode } : {}
     },
-    // Host-injected: the companion-local summon server (for the subprocess adapters,
-    // under its own namespace).
+    // Host-injected turn-control tools, under their own namespace.
     extra: {
-      mcpServers: { [COMPANION_LOCAL_MCP_SERVER]: params.summonServer }
+      mcpServers: { [COMPANION_LOCAL_MCP_SERVER]: params.turnControlServer }
     }
   };
 }
@@ -7564,7 +7733,7 @@ var TurnCommitter = class {
             turnId: deps.turnId,
             seq,
             parentMessageId: deps.parentMessageId,
-            ...kind === "final" ? this.turnControlFields() : {}
+            ...kind === "final" ? this.turnControlFields("final") : {}
           },
           deps.signal
         );
@@ -7659,27 +7828,45 @@ var TurnCommitter = class {
     return this.pump.finalEmitted;
   }
   // A closing textual reply and a wordless terminal marker carry the same
-  // per-turn control state. Keep this one projection so ask/wake/summon cannot
-  // silently diverge when the agent ends without words.
-  turnControlFields() {
+  // per-turn control state. Keep this one projection so ask/wake/send cannot
+  // silently diverge when the agent ends without words. The KIND matters to
+  // exactly one field: the auto-declared reply binds only a textual `final` —
+  // a wordless turn has no answer to bind, and the server's mute-settle
+  // notice speaks for it.
+  turnControlFields(kind) {
     return {
-      ...this.summonField(),
+      ...this.answersField(kind),
+      ...this.sendField(),
       ...this.askField(),
       ...this.wakeField()
     };
   }
-  // CT183: resolve the in-thread summon into the `dispatch` field for a `final`
-  // commit. A self-target is stripped here (mirror of the in-app self-strip); the
-  // server strips it again and resolves / ignores an unknown id.
-  summonField() {
-    const target = this.deps.summonState.agentId;
-    if (!target || target === this.deps.agentId) return {};
-    return { dispatch: target };
+  // The declared reply: explicit `reply_to` first, else the runtime's own
+  // declaration for the turn that just answers — see
+  // `resolveDeclaredReplyField` for the whole rule and its reasons.
+  answersField(kind) {
+    return resolveDeclaredReplyField({
+      kind,
+      owedReplyMessageId: this.deps.owedReplyMessageId,
+      agentId: this.deps.agentId,
+      replyState: this.deps.replyState,
+      sendState: this.deps.sendState,
+      askState: this.deps.askState,
+      wakeState: this.deps.wakeState,
+      spawnedSubAgent: this.deps.spawnedSubAgent()
+    });
+  }
+  // Carry both halves of the addressed send. The server writes `dispatchBody`
+  // on a distinct message row; the turn row itself remains unaddressed speech.
+  sendField() {
+    const { agentId: target, message } = this.deps.sendState;
+    if (!target || !message || target === this.deps.agentId) return {};
+    return { dispatch: target, dispatchBody: message };
   }
   // CT326: resolve the per-turn ask into the `ask` field for a `final` commit.
   // The server validates the target (must be a workspace member/owner) and
   // creates the `asks` row; an absent/incomplete ask attaches nothing. Kept
-  // independent of `summonField` — a turn could conceivably summon AND ask.
+  // independent of `sendField` — a turn can send and ask independently.
   askField() {
     const { targetUserId, question, headline, options, questions } = this.deps.askState;
     if (!targetUserId) return {};
@@ -7709,7 +7896,7 @@ var TurnCommitter = class {
   // CT442: resolve the per-turn wake into the `wake` field for a `final` commit.
   // The tool guarantees exactly one of `afterSeconds`/`at` is set once armed (both
   // null = no wake this turn → attach nothing). The server computes `fire_at` and
-  // arms the CT441 schedule. Kept independent of summon/ask — a turn could
+  // arms the CT441 schedule. Kept independent of send/ask — a turn could
   // conceivably ask AND arm a wake.
   //
   // CT990: the field now carries three states, and the third can't be spelled by
@@ -7946,15 +8133,9 @@ function describeErrorBody(body) {
 function describeSubAgentError(status2, body) {
   const code = body && typeof body === "object" && "error" in body ? String(body.error) : void 0;
   switch (code) {
-    case "callout_cap_exceeded":
-      return "sub_agent: you already have the maximum open sub-agents for this thread. Wait for some to return \u2014 you're woken once they're all back \u2014 before spawning more.";
-    case "callout_depth_exceeded":
-      return "sub_agent: this would nest sub-agents too deep (max 3 levels). Have the current worker report back rather than spawning another layer.";
     case "dispatch_agent_not_found":
       return "sub_agent: no live agent in this workspace matches that `agentId`. Check the roster in your turn context, or omit `agentId` to spawn yourself.";
-    case "dispatch_return_requires_turn":
-    case "dispatch_return_requires_agent":
-    case "dispatch_return_requires_dispatch":
+    case "dispatch_ask_requires_dispatch":
       return `sub_agent: the spawn was rejected (${code}). This is a turn-context problem, not something to retry blindly \u2014 report it rather than looping.`;
     default:
       return `sub_agent: the spawn failed (${code ?? `HTTP ${status2}`}).`;
@@ -8120,7 +8301,12 @@ var Dispatcher = class {
     }
     let hookEnv;
     const triggerIsPrepareFailure = message.body.startsWith(PREPARE_FAILED_PREFIX);
-    const prepareFailureDispatch = turnContext.dispatchedByAgentId && !triggerIsPrepareFailure ? { dispatch: turnContext.dispatchedByAgentId } : {};
+    const prepareFailureDispatch = turnContext.dispatchedByAgentId && !triggerIsPrepareFailure ? {
+      dispatch: turnContext.dispatchedByAgentId,
+      dispatchBody: `${PREPARE_FAILED_PREFIX}
+
+The dispatched turn could not start. Re-dispatch it after repairing the preparation failure shown in this conversation.`
+    } : {};
     if (prepareHook) {
       let cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
       if (cached2 && !checkoutState(cached2.cwd).ok) {
@@ -8274,10 +8460,12 @@ ${reason}`,
         "dispatcher: active-run flag set failed terminally; proceeding"
       );
     }
-    const summonState = createSummonState();
+    const sendState = createSendState();
     const skipState = createSkipState();
     const askState = createAskState();
     const wakeState = createWakeState();
+    const replyState = createReplyState();
+    let spawnedSubAgent = false;
     const subAgentCreate = async (args) => {
       const dispatchTarget = args.agentId ?? payload.agentId;
       const projectId = turnContext.conversation.projectId;
@@ -8290,7 +8478,7 @@ ${reason}`,
           ...args.title ? { title: args.title } : {},
           body: args.prompt,
           dispatch: dispatchTarget,
-          dispatchReturn: true
+          dispatchAsk: true
         }
       );
       if (status2 >= 400) return { ok: false, error: describeSubAgentError(status2, body) };
@@ -8298,14 +8486,16 @@ ${reason}`,
       if (!conversationId) {
         return { ok: false, error: "sub_agent: the spawn returned no conversation id." };
       }
+      spawnedSubAgent = true;
       return { ok: true, conversationId };
     };
-    const summonServer = createSummonMcpServer(
-      summonState,
+    const turnControlServer = createTurnControlMcpServer(
+      sendState,
       skipState,
       askState,
       subAgentCreate,
-      wakeState
+      wakeState,
+      replyState
     );
     const request = buildCompanionTurnRequest({
       turnContext,
@@ -8319,7 +8509,7 @@ ${reason}`,
       // CT1103: the prepare-hook env plus the authoritative host-access token.
       env: turnEnv,
       mcpServers: resolvedMcpServers,
-      summonServer,
+      turnControlServer,
       // CT238: this turn's conversation, forwarded as the active-conversation
       // header so a cross-thread post/spawn stamps its origin.
       activeConversationId: payload.conversationId,
@@ -8568,15 +8758,20 @@ ${reason}`,
       signal: abortController.signal,
       log: turnLog,
       nextSeq,
-      // CT183: the committer reads this at commit to attach the in-thread summon
-      // onto the turn's `final` row.
-      summonState,
+      // The committer reads this at commit to attach the addressed send onto the
+      // turn's `final` row.
+      sendState,
       // CT326: likewise the ask payload — attached to the `final` row so the
       // server creates the `asks` row atomically with the message it rides on.
       askState,
       // CT442: likewise the wake payload — attached to the `final` row so the
       // server arms the wake schedule atomically with the reply it rode on.
-      wakeState
+      wakeState,
+      replyState,
+      // The ledger-derived owed reply, for the runtime's own declaration when
+      // the agent doesn't call `reply_to` (resolveDeclaredReplyField).
+      owedReplyMessageId: turnContext.owedReplyMessageId ?? null,
+      spawnedSubAgent: () => spawnedSubAgent
     });
     const usesHttpTurnControl = turnRuntime === "codex" || turnRuntime === "opencode";
     let turnControlIntentFetched = false;
@@ -8617,7 +8812,11 @@ ${reason}`,
             wakeState.note = intent.wake.note;
           }
         }
-        if (intent.summonAgentId) summonState.agentId = intent.summonAgentId;
+        if (intent.sendAgentId && intent.sendBody) {
+          sendState.agentId = intent.sendAgentId;
+          sendState.message = intent.sendBody;
+        }
+        if (intent.answersMessageId) replyState.answersMessageId = intent.answersMessageId;
         if (intent.skipped) {
           skipState.skipped = true;
           skipState.reason = intent.skipReason;
@@ -8755,10 +8954,10 @@ ${reason}`,
               turnId,
               seq: nextSeq(),
               parentMessageId: payload.messageId,
-              // ask, wake and summon must survive a wordless turn exactly as
+              // ask, wake and send must survive a wordless turn exactly as
               // they survive a textual final; dropping one can strand a person
               // or the next actor with no visible failure.
-              ...committer.turnControlFields()
+              ...committer.turnControlFields("silent")
             });
             silentMarkerEmitted = true;
           } catch (err) {

package/dist/runtime.js

@@ -1843,7 +1843,7 @@ var CabaneApi = class {
     return this.request("GET", `/api/workspaces/${workspaceId}/conversations/${conversationId}`);
   }
   // CT339: spawn a sub-agent conversation — the public create-conversation
-  // endpoint (`POST /conversations/messages`) with `dispatch` + `dispatchReturn`,
+  // endpoint (`POST /conversations/messages`) with an addressed agent ask,
   // the machinery the `sub_agent` turn-control tool is sugar over. Two things make
   // it distinct from an ordinary `request` call, so it does its own `fetch`:
   //   - a PER-CALL bearer — the turn's OBO token when the API minted one, else the
@@ -1851,10 +1851,10 @@ var CabaneApi = class {
   //     cabane calls this turn (mirrors build-options' `turnToken ?? agentPat`);
   //   - the `x-cabane-active-conversation` header naming the caller's turn, which
   //     the server verifies against the live run to resolve the caller pair for the
-  //     return callout (the same origin that stamps `origin_conversation_id`).
+  //     immutable birth tether (the same origin that stamps provenance).
   // Single-shot (no outbox/retry): a `sub_agent` spawn is a live, user-visible
   // action, and its result is returned to the agent immediately. Returns
-  // `{ status, body }` un-thrown so the caller maps the callout cap / gating errors
+  // `{ status, body }` un-thrown so the caller maps validation errors
   // to a legible tool result rather than an exception.
   async createSubAgentConversation(workspaceId, activeConversationId, bearer, body) {
     const res = await fetch(`${this.base}/api/workspaces/${workspaceId}/conversations/messages`, {
@@ -1914,7 +1914,7 @@ var CabaneApi = class {
     const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "");
     return this.request("GET", `/api/agent/turn-context?${q}`);
   }
-  // CT714: read a turn's recorded turn-control intent (ask/wake/summon/skip). An
+  // CT714: read a turn's recorded turn-control intent (ask/wake/send/skip). An
   // EXTERNAL adapter (Codex / opencode) records its turn-control verbs into
   // `turn_intents` server-side (the URL MCP surface) rather than the dispatcher's
   // in-memory closures, so the dispatcher fetches this once at settle — by
@@ -2825,7 +2825,7 @@ var turnRequestSchema = z8.object({
     // EXTERNAL adapters (Codex / opencode) mount it by URL under the key
     // `cabane_companion` — using the same `bearer` (the turn token) and the same
     // active-conversation header they send to the `cabane` server — so their
-    // agents get `ask`/`wake_me`/`summon_agent`/`sub_agent`/`skip_turn`, the
+    // agents get `ask`/`wake_me`/`send`/`sub_agent`/`skip_turn`, the
     // verbs they can't get from the companion's in-process SDK server. Optional:
     // claude-code ignores it (it mounts the in-process instance instead), and
     // every existing `cabane`-block fixture keeps parsing unchanged; the
@@ -2860,7 +2860,7 @@ var turnRequestSchema = z8.object({
     // default in place (see `buildClaudeCodeOptions`).
     claudeCode: z8.object({ autoMemory: z8.boolean().optional() }).optional()
   }),
-  // Host-owned injected servers (host-filled) — e.g. the summon server.
+  // Host-owned injected servers (host-filled) — e.g. the send server.
   extra: z8.object({
     mcpServers: hostInjectedServersSchema
   })
@@ -3191,8 +3191,9 @@ var CLAUDE_CODE_ADDENDUM = [
   "`mcp__cabane__sdk`; the ancillary tools are `mcp__cabane__list_workspaces`,",
   "`mcp__cabane__read_binary`, `mcp__cabane__upload`, `mcp__cabane__begin_upload`,",
   "`mcp__cabane__finalize_upload`, and `mcp__cabane__mint_render_token`; the turn tools are",
-  "`mcp__cabane_companion__ask`, `mcp__cabane_companion__wake_me`,",
-  "`mcp__cabane_companion__summon_agent`, `mcp__cabane_companion__sub_agent`, and",
+  "`mcp__cabane_companion__ask`, `mcp__cabane_companion__reply_to`,",
+  "`mcp__cabane_companion__wake_me`,",
+  "`mcp__cabane_companion__send`, `mcp__cabane_companion__sub_agent`, and",
   "`mcp__cabane_companion__skip_turn`. Where this prompt names a tool by its bare verb, call",
   "the prefixed form from your tool list. Your harness's own tools (shell, local file",
   "read/edit) keep their ordinary names and act on the local machine only."
@@ -3305,8 +3306,19 @@ function decideResume(stored, currentCwd) {
 // packages/agent-runtime/src/claude-code/options.ts
 var CABANE_MCP_SERVER = "cabane";
 var ACTIVE_CONVERSATION_HEADER2 = "x-cabane-active-conversation";
-async function allowEverythingHook(input) {
+async function preToolUseHook(input) {
   const toolInput = "tool_input" in input && input.tool_input && typeof input.tool_input === "object" ? input.tool_input : {};
+  const toolName = "tool_name" in input ? input.tool_name : void 0;
+  if (typeof toolName === "string" && SUBAGENT_TOOLS.includes(toolName) && (toolInput.run_in_background !== false || toolInput.isolation === "remote")) {
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: "Background subagents don't survive a Cabane turn: they're children of this turn's process and are killed when it ends, so nothing will notify you. Re-run this with run_in_background: false to get the result inside this turn, or arm a wake and check back."
+      }
+    };
+  }
   return {
     continue: true,
     hookSpecificOutput: {
@@ -3391,7 +3403,7 @@ function buildClaudeCodeOptions(req, augment) {
       settingSources: ["project"],
       allowedTools,
       disallowedTools,
-      hooks: { PreToolUse: [{ hooks: [allowEverythingHook] }] }
+      hooks: { PreToolUse: [{ hooks: [preToolUseHook] }] }
     };
   } else {
     options = {
@@ -3467,6 +3479,8 @@ async function* decodeSdkStream(iter, ctx) {
         const err = msg.error;
         if (typeof err === "string" && err.length > 0) authError = err;
       } else if (msg.type === "result") {
+        const origin = msg.origin;
+        if (origin?.kind === "task-notification") continue;
         sawResult = true;
         usage = readSdkUsage(msg);
         if (usage) {
@@ -3659,6 +3673,10 @@ var resultSuccess = (sessionId) => ({
   subtype: "success",
   session_id: sessionId
 });
+var resultSuccessFull = (sessionId, extra) => ({
+  ...resultSuccess(sessionId),
+  ...extra
+});
 var resultError = (subtype) => ({
   type: "result",
   subtype,
@@ -3812,6 +3830,116 @@ var CLAUDE_CODE_CONFORMANCE_FIXTURES = [
     nativeStream: [init("s1"), resultSuccess("s1")],
     expected: [sessionEvent("s1"), { type: "result", ok: true }]
   },
+  {
+    // CT1220: on resume, a completed background task can emit a notification and
+    // its own zero-token result before the prompt's frames. That result is not the
+    // turn boundary; decoding continues through the prompt's reply and real usage.
+    name: "task-notification result does not end a resumed turn",
+    request: makeRequest({ session: encodeSession({ sdkSessionId: "s1", cwd: CWD }) }),
+    nativeStream: [
+      init("s1"),
+      {
+        type: "system",
+        subtype: "task_notification",
+        task_id: "task-1",
+        status: "completed",
+        output_file: "/tmp/task-1.output",
+        summary: "Background work completed.",
+        session_id: "s1"
+      },
+      resultSuccessFull("s1", {
+        is_error: false,
+        origin: { kind: "task-notification" },
+        usage: {
+          input_tokens: 0,
+          output_tokens: 0,
+          cache_read_input_tokens: 0,
+          cache_creation_input_tokens: 0
+        }
+      }),
+      assistantTextTool("Checking the returned work.", {
+        id: "tu1",
+        name: "mcp__cabane__cabane_read",
+        input: { path: "result.md" }
+      }),
+      toolResult("tu1", [{ type: "text", text: "ready" }]),
+      assistantText("The prompt completed normally."),
+      resultSuccessFull("s1", {
+        is_error: false,
+        usage: {
+          input_tokens: 120,
+          output_tokens: 30,
+          cache_read_input_tokens: 80,
+          cache_creation_input_tokens: 10
+        }
+      })
+    ],
+    expected: [
+      { type: "text", body: "Checking the returned work.", terminal: false },
+      {
+        type: "tool",
+        id: "tu1",
+        name: "cabane_read",
+        phase: "start",
+        summary: "result.md",
+        input: { path: "result.md" },
+        mcpServer: "cabane"
+      },
+      {
+        type: "tool",
+        id: "tu1",
+        name: "cabane_read",
+        phase: "done",
+        summary: "result.md",
+        input: { path: "result.md" },
+        result: [{ type: "text", text: "ready" }],
+        mcpServer: "cabane"
+      },
+      { type: "text", body: "The prompt completed normally.", terminal: true },
+      {
+        type: "result",
+        ok: true,
+        usage: {
+          inputTokens: 210,
+          outputTokens: 30,
+          cacheReadTokens: 80,
+          cacheCreationTokens: 10
+        }
+      }
+    ]
+  },
+  {
+    // CT1220: the filter is deliberately narrow. An origin-less zero-token result
+    // keeps today's break-on-first-result behavior, even if more frames follow.
+    name: "origin-less result still ends a resumed turn",
+    request: makeRequest({ session: encodeSession({ sdkSessionId: "s1", cwd: CWD }) }),
+    nativeStream: [
+      init("s1"),
+      resultSuccessFull("s1", {
+        is_error: false,
+        usage: {
+          input_tokens: 0,
+          output_tokens: 0,
+          cache_read_input_tokens: 0,
+          cache_creation_input_tokens: 0
+        }
+      }),
+      assistantText("This must not be emitted."),
+      resultSuccess("s1")
+    ],
+    expected: [
+      {
+        type: "result",
+        ok: true,
+        usage: {
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheCreationTokens: 0
+        }
+      }
+    ]
+  },
   {
     // Empty-final: a clean turn that ended on a tool call with no closing text.
     // The adapter emits NO final text — empty-final promotion is host/pump
@@ -3993,7 +4121,7 @@ function selectAdapter(registry, runtime) {
 // packages/agent-runtime/src/opencode/addendum.ts
 var OPENCODE_ADDENDUM = [
   "Every tool here goes by its plain name: the workspace tool is `sdk`; the turn tools are",
-  "`ask`, `wake_me`, `summon_agent`, `sub_agent`, `skip_turn`; the ancillary tools are",
+  "`ask`, `reply_to`, `wake_me`, `send`, `sub_agent`, `skip_turn`; the ancillary tools are",
   "`list_workspaces`, `read_binary`, `upload`, `begin_upload`, `finalize_upload`,",
   "`mint_render_token`; and the host tools are plain verbs too (`bash`, `read`, `edit`). Mind",
   "the collision: a bare `read` or `edit` is the HOST tool, acting on the local machine \u2014 a",
@@ -4969,8 +5097,9 @@ var CODEX_ADDENDUM = [
   "workspace tool is `mcp__cabane__sdk` \u2014 if it isn't in your visible tool list, locate it in",
   "the deferred-tool inventory and invoke that exact qualified name; never conclude the SDK is",
   "absent without attempting discovery and invocation, and if a call fails, report the recorded",
-  "error. The turn tools are `mcp__cabane_companion__ask` / `wake_me` / `summon_agent` /",
-  "`sub_agent` / `skip_turn`, and the ancillary tools `mcp__cabane__list_workspaces` /",
+  "error. The turn tools are `mcp__cabane_companion__ask` / `reply_to` / `wake_me` /",
+  "`send` / `sub_agent` / `skip_turn`, and the ancillary tools",
+  "`mcp__cabane__list_workspaces` /",
   "`read_binary` / `upload` / `begin_upload` / `finalize_upload` / `mint_render_token` \u2014 all",
   "possibly deferred too. There is no Cabane `read`/`write`/`search` tool \u2014 those are",
   "`cabane.*` calls inside your program. One more harness fact: you can interleave narration",
@@ -6468,15 +6597,17 @@ import { createHash as createHash2, randomUUID } from "crypto";
 import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync10, readdirSync as readdirSync2, statSync } from "fs";
 import { join as join14 } from "path";
 
-// src/summon.ts
+// src/turn-control-tools.ts
 import { z as z13 } from "zod";
 var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
-var SUMMON_AGENT_TOOL = "summon_agent";
-var SUMMON_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUMMON_AGENT_TOOL}`;
+var SEND_TOOL = "send";
+var SEND_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SEND_TOOL}`;
 var COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
 var SKIP_TURN_TOOL = "skip_turn";
 var ASK_TOOL = "ask";
 var ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${ASK_TOOL}`;
+var REPLY_TO_TOOL = "reply_to";
+var REPLY_TO_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${REPLY_TO_TOOL}`;
 var MAX_ASK_ITEMS = 20;
 var SUB_AGENT_TOOL = "sub_agent";
 var SUB_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUB_AGENT_TOOL}`;
@@ -6484,8 +6615,11 @@ var WAKE_ME_TOOL = "wake_me";
 var WAKE_ME_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WAKE_ME_TOOL}`;
 var CANCEL_WAKE_TOOL = "cancel_wake";
 var CANCEL_WAKE_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${CANCEL_WAKE_TOOL}`;
-function createSummonState() {
-  return { agentId: null };
+function createReplyState() {
+  return { answersMessageId: null };
+}
+function createSendState() {
+  return { agentId: null, message: null };
 }
 function createSkipState() {
   return { skipped: false, reason: null };
@@ -6496,6 +6630,19 @@ function createAskState() {
 function createWakeState() {
   return { afterSeconds: null, at: null, note: null, cancelled: false };
 }
+function resolveDeclaredReplyField(input) {
+  const explicit = input.replyState.answersMessageId;
+  if (explicit) return { answersMessageId: explicit };
+  if (input.kind !== "final") return {};
+  if (!input.owedReplyMessageId) return {};
+  const outwardSend = Boolean(
+    input.sendState.agentId && input.sendState.message && input.sendState.agentId !== input.agentId
+  );
+  const askRaised = Boolean(input.askState.targetUserId);
+  const wakeArmed = input.wakeState.afterSeconds !== null || input.wakeState.at !== null;
+  if (outwardSend || askRaised || wakeArmed || input.spawnedSubAgent) return {};
+  return { answersMessageId: input.owedReplyMessageId };
+}
 function wakeCommitField(state) {
   if (state.cancelled) return { wake: { cancel: true } };
   const { afterSeconds, at, note } = state;
@@ -6508,27 +6655,50 @@ function wakeCommitField(state) {
     }
   };
 }
-function createSummonMcpServer(summonState, skipState, askState, subAgentCreate, wakeState) {
+function createTurnControlMcpServer(sendState, skipState, askState, subAgentCreate, wakeState, replyState) {
   return createSdkMcpServer({
     name: COMPANION_LOCAL_MCP_SERVER,
     version: "0.0.0",
     tools: [
       tool(
-        SUMMON_AGENT_TOOL,
-        "Summon another agent into THIS conversation \u2014 dispatch a peer to reply here on your turn. Use it to hand part of the work to a teammate, or pull in an expert, without leaving the conversation. Pass the peer's `agentId` \u2014 every agent's handle and id is on the roster in your turn context. The peer is dispatched on your turn's final reply, so write the context/ask into that reply first \u2014 it receives your message + this conversation to work from. Writing `@handle` in your prose does NOT summon anyone (agent prose never dispatches); this tool is the only in-thread lever. Single target \u2014 the last call wins. Summoning yourself is a no-op. Reach for it when the human wants the peer's answer right HERE, in front of them \u2014 the reply lands in this thread, so there's no return to wire (a return is for work YOU consume, never a courtesy notification). A handoff to a DIFFERENT conversation is `cabane.conversations.create` / `cabane.conversations.post` with their `dispatch` field instead.",
+        SEND_TOOL,
+        "Send one addressed message to another agent in THIS conversation. Pass the peer's `agentId` and the complete `message` they should act on; the server writes it separately from your terminal reply. Writing `@handle` in prose dispatches nobody. Single target \u2014 the last call wins. Sending to yourself is a no-op. A handoff to a DIFFERENT conversation is `cabane.conversations.create` / `cabane.conversations.post` with their `dispatch` field instead. Never use send to hand an answer back to the requester \u2014 declare that with reply_to.",
         {
           agentId: z13.string().uuid().describe(
-            "The peer agent to summon \u2014 a workspace agent id, from your turn context's roster."
-          )
+            "The peer agent to address \u2014 a workspace agent id, from your turn context's roster."
+          ),
+          message: z13.string().min(1).max(65536).describe("The complete new request the peer should receive and act on.")
         },
         async (args) => {
-          summonState.agentId = args.agentId;
+          sendState.agentId = args.agentId;
+          sendState.message = args.message;
           return {
-            content: [{ type: "text", text: JSON.stringify({ summoned: args.agentId }) }]
+            content: [{ type: "text", text: JSON.stringify({ sent: args.agentId }) }]
           };
         },
         { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
       ),
+      ...replyState ? [
+        tool(
+          REPLY_TO_TOOL,
+          "Declare which addressed ask your final response answers. Pass the `messageId` shown as the owed reply id in your turn context, then finish your response normally. This records lineage only: it does not send another message. The server verifies that this agent owes that ask in this conversation; one reply per turn, last call wins.",
+          {
+            messageId: z13.string().uuid().describe("The owed ask message id from this turn context.")
+          },
+          async (args) => {
+            replyState.answersMessageId = args.messageId;
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({ answersMessageId: args.messageId })
+                }
+              ]
+            };
+          },
+          { annotations: { readOnlyHint: true, openWorldHint: false }, alwaysLoad: true }
+        )
+      ] : [],
       ...skipState ? [
         tool(
           SKIP_TURN_TOOL,
@@ -6549,7 +6719,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
       ...askState ? [
         tool(
           ASK_TOOL,
-          `Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass \`targetUserId\` (a workspace member's user id \u2014 every person's id is on the roster in your turn context). Two forms: a SINGLE question \u2014 a \`headline\` (the actual question as one clear, capitalized sentence ending in \`?\`, "Do we go to prod?") plus a short \`question\` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a \`questions\` array of 1\u2013${MAX_ASK_ITEMS} items, each \`{ headline, body?, options? }\`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence \`headline\`, a short \`body\` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 \`options\` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label or a whole sentence. Provide EITHER \`question\` (single) or \`questions\` (array), never both. The ask is a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use summon/dispatch instead.`,
+          `Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact). Pass \`targetUserId\` (a workspace member's user id \u2014 every person's id is on the roster in your turn context). Two forms: a SINGLE question \u2014 a \`headline\` (the actual question as one clear, capitalized sentence ending in \`?\`, "Do we go to prod?") plus a short \`question\` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once, a \`questions\` array of 1\u2013${MAX_ASK_ITEMS} items, each \`{ headline, body?, options? }\`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence \`headline\`, a short \`body\` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 \`options\` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label or a whole sentence. Provide EITHER \`question\` (single) or \`questions\` (array), never both. The ask is a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use send/dispatch instead.`,
           {
             targetUserId: z13.string().uuid().describe(
               "The workspace member (human) to ask \u2014 a user id, from your turn context's roster."
@@ -6622,10 +6792,10 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
       ...subAgentCreate ? [
         tool(
           SUB_AGENT_TOOL,
-          "Spawn a sub-agent \u2014 hand a piece of work to a private worker with a fresh context window, whose result comes back to you automatically. Modeled on the Task tool, with ONE deliberate difference: it does NOT return the result inline. A callee's turn can run for minutes and no turn may hold an unbounded wait, so the shape is spawn-now, results-on-wake \u2014 this returns immediately with the child's `conversationId`, and the outcome lands LATER as a message in THIS conversation; you're woken once every sub-agent you have out in this conversation has returned. So DON'T wait for it: after spawning, finish whatever else this turn can do and end your turn (never poll the child with reads in a loop \u2014 the wake is automatic). Parallel fan-out = call this N times in one turn (they run concurrently; ONE wake when all are in); series = one call per turn. `prompt` is the child's opening instruction \u2014 make it self-contained (the sub-agent starts fresh, with only this prompt + the thread it lands in). `agentId` (optional) dispatches a PEER instead of yourself \u2014 same mechanics, a different mind (use for capability/context you lack); default (self) is the pure sub-worker with a clean context window. `title` (optional) names the child thread (results link it, so a legible title helps). A single sub-agent has no wall-clock advantage (you idle either way) \u2014 it pays when the callee has capability/context you lack, or to isolate a big read from your own session; the real win is fan-out. Don't spawn one for a lookup you can do in-turn with your own tools. The result returns to YOU to act on \u2014 reach for it when you're the consumer of the output, not as a way to notify a human: if a person just wants to read the result, dispatch a plain (no-return) conversation and link it instead of spawning a sub-agent.",
+          "Ask into a child conversation \u2014 a bounded question or piece of work whose ANSWER returns to you automatically. This creates the child and dispatches its agent now, returning the child's `conversationId` immediately; the answer lands LATER as a message in THIS conversation, and you're woken once every child you asked this turn has answered. So DON'T wait: after asking, finish whatever else this turn can do and end your turn (never poll the child with reads in a loop \u2014 the wake is automatic and it carries the answer). Parallel fan-out = call this N times in one turn (they run concurrently; ONE wake carrying all the answers); series = one call per turn. `prompt` is the ask itself \u2014 write it as a request that expects an answer back, not a role you are assigning or a job description: self-contained (the child starts fresh, with only this prompt), and say what shape the answer should take. `agentId` (optional) asks a PEER instead of yourself \u2014 same mechanics, a different mind (use for capability/context you lack); default (self) is a fresh context window of you. `title` (optional) names the child thread (answers link it, so a legible title helps). A single child buys no wall-clock time (you idle either way) \u2014 it pays when the callee has capability/context you lack, or to isolate a big read from your own session; the real win is fan-out. Don't ask a child for a lookup you can do in-turn with your own tools. The answer returns to YOU to act on \u2014 reach for it when you're the consumer of the output, not as a way to notify a human: if a person just wants to read the result, dispatch a plain (no-return) conversation and link it instead.",
           {
             prompt: z13.string().min(1).max(65536).describe(
-              "The sub-agent's opening instruction \u2014 self-contained (it starts with a fresh context window; only this prompt + the thread it lands in)."
+              "The ask \u2014 a self-contained request that expects an answer back (the child starts fresh: only this prompt + the thread it lands in). Say what shape the answer should take."
             ),
             agentId: z13.string().uuid().optional().describe(
               "Optional peer to run the sub-agent as (a workspace agent id, from your turn context's roster); omit to spawn yourself with a fresh context window."
@@ -6646,7 +6816,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
                   type: "text",
                   text: JSON.stringify({
                     conversationId: result.conversationId,
-                    note: "Spawned. Don't wait for it \u2014 finish what else this turn can do, then end your turn; the result posts back here and you're woken once every sub-agent you have out in this conversation has returned."
+                    note: "Asked. Don't wait for it \u2014 finish what else this turn can do, then end your turn; the answer posts back here and you're woken once every child you asked this turn has answered."
                   })
                 }
               ]
@@ -6785,10 +6955,9 @@ function buildCompanionTurnRequest(params) {
       // CT289: the auto-memory escape hatch, when the operator set it.
       ...params.claudeCode ? { claudeCode: params.claudeCode } : {}
     },
-    // Host-injected: the companion-local summon server (for the subprocess adapters,
-    // under its own namespace).
+    // Host-injected turn-control tools, under their own namespace.
     extra: {
-      mcpServers: { [COMPANION_LOCAL_MCP_SERVER]: params.summonServer }
+      mcpServers: { [COMPANION_LOCAL_MCP_SERVER]: params.turnControlServer }
     }
   };
 }
@@ -7063,7 +7232,7 @@ var TurnCommitter = class {
             turnId: deps.turnId,
             seq,
             parentMessageId: deps.parentMessageId,
-            ...kind === "final" ? this.turnControlFields() : {}
+            ...kind === "final" ? this.turnControlFields("final") : {}
           },
           deps.signal
         );
@@ -7158,27 +7327,45 @@ var TurnCommitter = class {
     return this.pump.finalEmitted;
   }
   // A closing textual reply and a wordless terminal marker carry the same
-  // per-turn control state. Keep this one projection so ask/wake/summon cannot
-  // silently diverge when the agent ends without words.
-  turnControlFields() {
+  // per-turn control state. Keep this one projection so ask/wake/send cannot
+  // silently diverge when the agent ends without words. The KIND matters to
+  // exactly one field: the auto-declared reply binds only a textual `final` —
+  // a wordless turn has no answer to bind, and the server's mute-settle
+  // notice speaks for it.
+  turnControlFields(kind) {
     return {
-      ...this.summonField(),
+      ...this.answersField(kind),
+      ...this.sendField(),
       ...this.askField(),
       ...this.wakeField()
     };
   }
-  // CT183: resolve the in-thread summon into the `dispatch` field for a `final`
-  // commit. A self-target is stripped here (mirror of the in-app self-strip); the
-  // server strips it again and resolves / ignores an unknown id.
-  summonField() {
-    const target = this.deps.summonState.agentId;
-    if (!target || target === this.deps.agentId) return {};
-    return { dispatch: target };
+  // The declared reply: explicit `reply_to` first, else the runtime's own
+  // declaration for the turn that just answers — see
+  // `resolveDeclaredReplyField` for the whole rule and its reasons.
+  answersField(kind) {
+    return resolveDeclaredReplyField({
+      kind,
+      owedReplyMessageId: this.deps.owedReplyMessageId,
+      agentId: this.deps.agentId,
+      replyState: this.deps.replyState,
+      sendState: this.deps.sendState,
+      askState: this.deps.askState,
+      wakeState: this.deps.wakeState,
+      spawnedSubAgent: this.deps.spawnedSubAgent()
+    });
+  }
+  // Carry both halves of the addressed send. The server writes `dispatchBody`
+  // on a distinct message row; the turn row itself remains unaddressed speech.
+  sendField() {
+    const { agentId: target, message } = this.deps.sendState;
+    if (!target || !message || target === this.deps.agentId) return {};
+    return { dispatch: target, dispatchBody: message };
   }
   // CT326: resolve the per-turn ask into the `ask` field for a `final` commit.
   // The server validates the target (must be a workspace member/owner) and
   // creates the `asks` row; an absent/incomplete ask attaches nothing. Kept
-  // independent of `summonField` — a turn could conceivably summon AND ask.
+  // independent of `sendField` — a turn can send and ask independently.
   askField() {
     const { targetUserId, question, headline, options, questions } = this.deps.askState;
     if (!targetUserId) return {};
@@ -7208,7 +7395,7 @@ var TurnCommitter = class {
   // CT442: resolve the per-turn wake into the `wake` field for a `final` commit.
   // The tool guarantees exactly one of `afterSeconds`/`at` is set once armed (both
   // null = no wake this turn → attach nothing). The server computes `fire_at` and
-  // arms the CT441 schedule. Kept independent of summon/ask — a turn could
+  // arms the CT441 schedule. Kept independent of send/ask — a turn could
   // conceivably ask AND arm a wake.
   //
   // CT990: the field now carries three states, and the third can't be spelled by
@@ -7445,15 +7632,9 @@ function describeErrorBody(body) {
 function describeSubAgentError(status, body) {
   const code = body && typeof body === "object" && "error" in body ? String(body.error) : void 0;
   switch (code) {
-    case "callout_cap_exceeded":
-      return "sub_agent: you already have the maximum open sub-agents for this thread. Wait for some to return \u2014 you're woken once they're all back \u2014 before spawning more.";
-    case "callout_depth_exceeded":
-      return "sub_agent: this would nest sub-agents too deep (max 3 levels). Have the current worker report back rather than spawning another layer.";
     case "dispatch_agent_not_found":
       return "sub_agent: no live agent in this workspace matches that `agentId`. Check the roster in your turn context, or omit `agentId` to spawn yourself.";
-    case "dispatch_return_requires_turn":
-    case "dispatch_return_requires_agent":
-    case "dispatch_return_requires_dispatch":
+    case "dispatch_ask_requires_dispatch":
       return `sub_agent: the spawn was rejected (${code}). This is a turn-context problem, not something to retry blindly \u2014 report it rather than looping.`;
     default:
       return `sub_agent: the spawn failed (${code ?? `HTTP ${status}`}).`;
@@ -7619,7 +7800,12 @@ var Dispatcher = class {
     }
     let hookEnv;
     const triggerIsPrepareFailure = message.body.startsWith(PREPARE_FAILED_PREFIX);
-    const prepareFailureDispatch = turnContext.dispatchedByAgentId && !triggerIsPrepareFailure ? { dispatch: turnContext.dispatchedByAgentId } : {};
+    const prepareFailureDispatch = turnContext.dispatchedByAgentId && !triggerIsPrepareFailure ? {
+      dispatch: turnContext.dispatchedByAgentId,
+      dispatchBody: `${PREPARE_FAILED_PREFIX}
+
+The dispatched turn could not start. Re-dispatch it after repairing the preparation failure shown in this conversation.`
+    } : {};
     if (prepareHook) {
       let cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
       if (cached2 && !checkoutState(cached2.cwd).ok) {
@@ -7773,10 +7959,12 @@ ${reason}`,
         "dispatcher: active-run flag set failed terminally; proceeding"
       );
     }
-    const summonState = createSummonState();
+    const sendState = createSendState();
     const skipState = createSkipState();
     const askState = createAskState();
     const wakeState = createWakeState();
+    const replyState = createReplyState();
+    let spawnedSubAgent = false;
     const subAgentCreate = async (args) => {
       const dispatchTarget = args.agentId ?? payload.agentId;
       const projectId = turnContext.conversation.projectId;
@@ -7789,7 +7977,7 @@ ${reason}`,
           ...args.title ? { title: args.title } : {},
           body: args.prompt,
           dispatch: dispatchTarget,
-          dispatchReturn: true
+          dispatchAsk: true
         }
       );
       if (status >= 400) return { ok: false, error: describeSubAgentError(status, body) };
@@ -7797,14 +7985,16 @@ ${reason}`,
       if (!conversationId) {
         return { ok: false, error: "sub_agent: the spawn returned no conversation id." };
       }
+      spawnedSubAgent = true;
       return { ok: true, conversationId };
     };
-    const summonServer = createSummonMcpServer(
-      summonState,
+    const turnControlServer = createTurnControlMcpServer(
+      sendState,
       skipState,
       askState,
       subAgentCreate,
-      wakeState
+      wakeState,
+      replyState
     );
     const request = buildCompanionTurnRequest({
       turnContext,
@@ -7818,7 +8008,7 @@ ${reason}`,
       // CT1103: the prepare-hook env plus the authoritative host-access token.
       env: turnEnv,
       mcpServers: resolvedMcpServers,
-      summonServer,
+      turnControlServer,
       // CT238: this turn's conversation, forwarded as the active-conversation
       // header so a cross-thread post/spawn stamps its origin.
       activeConversationId: payload.conversationId,
@@ -8067,15 +8257,20 @@ ${reason}`,
       signal: abortController.signal,
       log: turnLog,
       nextSeq,
-      // CT183: the committer reads this at commit to attach the in-thread summon
-      // onto the turn's `final` row.
-      summonState,
+      // The committer reads this at commit to attach the addressed send onto the
+      // turn's `final` row.
+      sendState,
       // CT326: likewise the ask payload — attached to the `final` row so the
       // server creates the `asks` row atomically with the message it rides on.
       askState,
       // CT442: likewise the wake payload — attached to the `final` row so the
       // server arms the wake schedule atomically with the reply it rode on.
-      wakeState
+      wakeState,
+      replyState,
+      // The ledger-derived owed reply, for the runtime's own declaration when
+      // the agent doesn't call `reply_to` (resolveDeclaredReplyField).
+      owedReplyMessageId: turnContext.owedReplyMessageId ?? null,
+      spawnedSubAgent: () => spawnedSubAgent
     });
     const usesHttpTurnControl = turnRuntime === "codex" || turnRuntime === "opencode";
     let turnControlIntentFetched = false;
@@ -8116,7 +8311,11 @@ ${reason}`,
             wakeState.note = intent.wake.note;
           }
         }
-        if (intent.summonAgentId) summonState.agentId = intent.summonAgentId;
+        if (intent.sendAgentId && intent.sendBody) {
+          sendState.agentId = intent.sendAgentId;
+          sendState.message = intent.sendBody;
+        }
+        if (intent.answersMessageId) replyState.answersMessageId = intent.answersMessageId;
         if (intent.skipped) {
           skipState.skipped = true;
           skipState.reason = intent.skipReason;
@@ -8254,10 +8453,10 @@ ${reason}`,
               turnId,
               seq: nextSeq(),
               parentMessageId: payload.messageId,
-              // ask, wake and summon must survive a wordless turn exactly as
+              // ask, wake and send must survive a wordless turn exactly as
               // they survive a textual final; dropping one can strand a person
               // or the next actor with no visible failure.
-              ...committer.turnControlFields()
+              ...committer.turnControlFields("silent")
             });
             silentMarkerEmitted = true;
           } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.54",
+  "version": "0.6.59",
   "type": "module",
   "description": "The Cabane Companion (headless): connect a coding agent on your machine to your Cabane workspace as a responder — drive work against your own codebase, files, and MCP servers without putting any of it in Cabane.",
   "license": "UNLICENSED",