@cabane/companion 0.6.202 → 0.6.203

package/dist/runtime.js

@@ -1950,7 +1950,7 @@ var CabaneApi = class {
   //     text use (turnId, seq) within each kind for nonzero seq; tool activity
   //     uses (turnId, toolUseId). Legacy zero/missing seq bypasses row deduplication.
   //     Server fences and the outbox's discard/eviction bounds still apply.
-  async durableCommit(kind, path, body, turnId, seq, signal) {
+  async durableCommit(kind, path, body, turnId, seq, signal, trailPath) {
     try {
       await this.request("POST", path, body, {
         retry: true,
@@ -1961,7 +1961,16 @@ var CabaneApi = class {
       if (!outbox) throw err;
       if (signal?.aborted || isAbortError(err)) throw err;
       if (!isRetryable(err)) throw err;
-      outbox.persist({ enqueuedAt: Date.now(), turnId, seq, method: "POST", path, body, kind });
+      outbox.persist({
+        enqueuedAt: Date.now(),
+        turnId,
+        seq,
+        method: "POST",
+        path,
+        body,
+        kind,
+        ...trailPath ? { trailPath } : {}
+      });
       this.opts.log?.debug(
         { kind, turnId, seq, err: err instanceof Error ? err.message : String(err) },
         "companion: commit queued to outbox after transient failure (will drain when the API returns)"
@@ -1986,6 +1995,29 @@ var CabaneApi = class {
           progressed = true;
         } catch (err) {
           if (err instanceof ApiError && err.status >= 400 && err.status < 500) {
+            if (entry.kind === "message" && entry.trailPath && isAlreadyPublished(err)) {
+              try {
+                await this.request("POST", entry.trailPath, trailOf(entry.body), {
+                  retry: true
+                });
+              } catch (trailErr) {
+                if (!(trailErr instanceof ApiError && trailErr.status >= 400 && trailErr.status < 500)) {
+                  break;
+                }
+                this.opts.log?.warn(
+                  {
+                    kind: entry.kind,
+                    turnId: entry.turnId,
+                    seq: entry.seq,
+                    ...apiErrorLogFields(trailErr)
+                  },
+                  `Cabane rejected a postscript; it could not be filed. ${mayNeedUpdate()}`
+                );
+              }
+              outbox.remove(entry.turnId, entry.seq);
+              progressed = true;
+              continue;
+            }
             if (entry.kind === "active-run" && isTurnEndedRefusal(err)) {
               this.opts.log?.debug(
                 { kind: entry.kind, turnId: entry.turnId, ...apiErrorLogFields(err) },
@@ -2061,6 +2093,19 @@ var CabaneApi = class {
       (e) => e.turnId === turnId && e.kind === "message" && e.body?.kind !== "runtime_notice"
     );
   }
+  // The `seq` of this turn's SELECTED ANSWER still waiting in the outbox — the
+  // `declared` commit the server's `answerArmed` cannot see — or null when none
+  // is queued. A resumed run that re-armed over it would let a newer text
+  // consume the arm first; with the selection queued, the resumed run starts
+  // declared, its texts are trail, and the drain delivers the selection.
+  outboxDeclaredSeqForTurn(turnId) {
+    const outbox = this.opts.outbox;
+    if (!outbox) return null;
+    const queued = outbox.list().find(
+      (e) => e.turnId === turnId && e.kind === "message" && e.body?.declared === true
+    );
+    return queued ? queued.seq : null;
+  }
   // ADOPT a turn context's issuance as the execution source of its work, once,
   // before preparation emits or queues anything, so every row can name a source
   // the server durably recorded and will never reap. Adoption is idempotent, so
@@ -2234,15 +2279,36 @@ var CabaneApi = class {
   // seq also orders speech against the turn's tool/thinking/text trail.
   // Transport/5xx failures get bounded retries and optional outbox delivery;
   // terminal 4xx and cancellation stop delivery rather than proving no commit.
-  postTurnMessage(workspaceId, conversationId, body, signal) {
-    return this.durableCommit(
-      "message",
-      `/api/workspaces/${workspaceId}/conversations/${conversationId}/messages`,
-      body,
-      body.turnId,
-      body.seq ?? 0,
-      signal
-    );
+  //
+  // A turn's answer can be out before a later speech commit arrives — the
+  // declaration published it, or another host's selection drained first — and
+  // the server refuses the commit `409 already_published`. The text is a
+  // postscript then: with `trail` (the committing agent, which names the text
+  // route), it is filed as trail at the same seq, live here and from the outbox
+  // on a drain. Without `trail` (a runtime notice) the refusal is terminal.
+  async postTurnMessage(workspaceId, conversationId, body, signal, trail) {
+    const trailPath = trail ? `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${trail.agentId}/text` : void 0;
+    try {
+      await this.durableCommit(
+        "message",
+        `/api/workspaces/${workspaceId}/conversations/${conversationId}/messages`,
+        body,
+        body.turnId,
+        body.seq ?? 0,
+        signal,
+        trailPath
+      );
+    } catch (err) {
+      if (!trailPath || !isAlreadyPublished(err)) throw err;
+      await this.durableCommit(
+        "text",
+        trailPath,
+        trailOf(body),
+        body.turnId,
+        body.seq ?? 0,
+        signal
+      );
+    }
   }
   // Report a tool transition (start/done/error). The server checks span
   // ownership, upserts by (turnId, toolUseId), and publishes agent_activity SSE.
@@ -2288,6 +2354,18 @@ var CabaneApi = class {
     );
   }
 };
+function isAlreadyPublished(err) {
+  return err instanceof ApiError && err.status === 409 && apiErrorCode(err) === "already_published";
+}
+function trailOf(body) {
+  const b = body;
+  return {
+    turnId: b.turnId,
+    text: b.body,
+    ...b.seq !== void 0 ? { seq: b.seq } : {},
+    ...b.executionSourceId !== void 0 ? { executionSourceId: b.executionSourceId } : {}
+  };
+}
 function isRetryable(err) {
   if (err instanceof ApiError) return err.status >= 500;
   if (isAbortError(err)) return false;
@@ -2778,6 +2856,8 @@ var turnOutcomes = ["success", "failure", "cancelled", "skipped"];
 var turnSessionModes = ["fresh", "resumed", "degraded"];
 var turnRuntimeResultKinds = ["success", "error", "no_terminal"];
 var turnFinalSources = [
+  // The agent declared its answer with the `answer` turn act (CT1973).
+  "declared",
   "runtime_text",
   "progress_promotion",
   "host_fallback",
@@ -3063,11 +3143,6 @@ function truncate(s, max) {
   return `${s.slice(0, max)}\u2026[+${s.length - max} chars]`;
 }
 
-// packages/agent-runtime/src/claude-code/index.ts
-import {
-  query as defaultQuery
-} from "@anthropic-ai/claude-agent-sdk";
-
 // packages/agent-runtime/src/turn-control/descriptions.ts
 var MAX_ASK_QUESTION_BYTES = 400;
 var MAX_ASK_HEADLINE_BYTES = 120;
@@ -3078,7 +3153,9 @@ var MAX_ASK_OPTIONS = 4;
 var MAX_WAKE_NOTE_BYTES = 2e3;
 var MAX_WITHDRAW_REASON_BYTES = 400;
 var MAX_SKIP_REASON_BYTES = 500;
+var TURN_CONTROL_MCP_SERVER = "cabane_companion";
 var TURN_CONTROL_TOOLS = [
+  "answer",
   "ask",
   "cancel_wake",
   "skip_turn",
@@ -3086,6 +3163,7 @@ var TURN_CONTROL_TOOLS = [
   "withdraw_ask"
 ];
 var TURN_CONTROL_TOOL_DESCRIPTIONS = {
+  answer: `Call this just before you write your answer: the text you write next is what the conversation keeps as your message. Call it once.`,
   ask: `Ask a person a structured question you need answered to continue, then end your turn; don't wait for the reply. \`targetUserId\` is a person on your roster, by their \`@handle\`; to bring in an agent, name them with \`@handle\` in your reply.
 - Form: one question (\`headline\`, optional \`question\` body, \`options\`) or \`questions\`, 1\u2013${MAX_ASK_ITEMS} \`{ headline, body?, options? }\`; never both. Decisions that arise together go in ONE call, in the order you want them answered. A second \`ask\` is a separate item, never an edit; raise one only for a genuinely new question.
 - \`headline\`: one sentence ending in \`?\`. Body (\`question\` or each item's \`body\`): a sentence or two of framing, not a report; inline Markdown only, no lists or headings. \`options\`: ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} one-click answers (always for a yes/no go-ahead), each a distinct course of action you can carry out without asking back.
@@ -3100,6 +3178,7 @@ var TURN_CONTROL_TOOL_DESCRIPTIONS = {
   withdraw_ask: `Withdraw an open ask \u2014 yours or anyone's in this conversation \u2014 because the question is moot, was wrong, or has been overtaken. \`reason\` is required and is shown to the person and, if it wasn't your ask, to the agent who asked it. If there is a current question to put in its place, don't call this \u2014 call \`ask\` with \`replaces\` so the two land as one and the person never sees neither or both. Never withdraw to hurry an answer; to act on a deadline, arm a \`wake_me\` and decide then.`
 };
 var TURN_CONTROL_FIELD_DESCRIPTIONS = {
+  answer: {},
   ask: {
     targetUserId: "The person to ask: their `@handle` from your turn context's roster (preferred), or their user id.",
     question: `SINGLE-question form: a short body \u2014 one or two sentences of framing the headline can't hold. NOT a report (up to ${MAX_ASK_QUESTION_BYTES} characters, inline markdown only). Provide EITHER this or \`questions\`, not both. Put the crisp one-sentence question in \`headline\`.`,
@@ -3128,8 +3207,14 @@ var TURN_CONTROL_FIELD_DESCRIPTIONS = {
   }
 };
 
+// packages/agent-runtime/src/claude-code/index.ts
+import {
+  query as defaultQuery
+} from "@anthropic-ai/claude-agent-sdk";
+
 // packages/agent-runtime/src/turn-control/prompt-guidance.ts
 var MEANINGS = {
+  answer: "declare the text you write next as your answer",
   ask: "put a structured question to a person",
   cancel_wake: "cancel your own armed wake in this conversation",
   skip_turn: "end without posting a reply",
@@ -4527,6 +4612,15 @@ function deepestError(node) {
 }
 
 // packages/agent-runtime/src/opencode/loop.ts
+function opencodeMcpServerOf(tool2, servers) {
+  let best = null;
+  for (const server of servers ?? []) {
+    if (tool2.length > server.length + 1 && tool2.startsWith(`${server}_`)) {
+      if (best === null || server.length > best.length) best = server;
+    }
+  }
+  return best;
+}
 async function* decodeOpencodeStream(events, ctx) {
   let held = null;
   const pending = /* @__PURE__ */ new Map();
@@ -4553,12 +4647,14 @@ async function* decodeOpencodeStream(events, ctx) {
         if (sealed) yield sealed;
         const key = part.callID ?? part.id;
         const input = part.state.input;
+        const server = opencodeMcpServerOf(part.tool, ctx.mcpServers);
+        const origin = server ? { mcpServer: server } : {};
         if (!startedTools.has(key)) {
           const name = prettyToolName(part.tool);
           const summary = summarizeToolInput(input);
           pending.set(key, { name, summary, input });
           startedTools.add(key);
-          yield { type: "tool", id: key, name, phase: "start", summary, input };
+          yield { type: "tool", id: key, name, phase: "start", summary, input, ...origin };
         }
         const entry = pending.get(key);
         if (entry && hasToolInput(input)) {
@@ -4578,7 +4674,8 @@ async function* decodeOpencodeStream(events, ctx) {
             phase,
             summary: started?.summary ?? "",
             input: started?.input ?? input,
-            result
+            result,
+            ...origin
           };
         }
       } else {
@@ -4662,7 +4759,6 @@ function parseOpencodeModel(model) {
 
 // packages/agent-runtime/src/opencode/run-spec.ts
 var CABANE_MCP_SERVER2 = "cabane";
-var TURN_CONTROL_MCP_SERVER = "cabane_companion";
 var ACTIVE_CONVERSATION_HEADER2 = "x-cabane-active-conversation";
 function buildRunSpec(req, resumeSessionId) {
   const { config } = req;
@@ -5056,7 +5152,10 @@ function createOpencodeAdapter(deps = {}) {
       }
       yield* decodeOpencodeStream(result.events, {
         signal,
-        sessionId: result.sessionId
+        sessionId: result.sessionId,
+        // The keys the turn's servers were installed under: what the decoder
+        // splits a raw `<server>_<tool>` id on.
+        mcpServers: Object.keys(spec.mcp)
       });
     }
   };
@@ -5192,7 +5291,15 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
     expected: [
       sessionEvent2(NEW_SESSION_ID),
       // start: fires off the first (empty) snapshot — empty input + summary, by design.
-      { type: "tool", id: "call_1", name: "cabane_list", phase: "start", summary: "", input: {} },
+      {
+        type: "tool",
+        id: "call_1",
+        name: "cabane_list",
+        phase: "start",
+        summary: "",
+        input: {},
+        mcpServer: "cabane"
+      },
       // done: carries the full args captured from the later snapshot, and the
       // summary recomputed from them — NOT the first-seen `{}`.
       {
@@ -5202,11 +5309,63 @@ var OPENCODE_CONFORMANCE_FIXTURES = [
         phase: "done",
         summary: "/product/tasks",
         input: { path: "/product/tasks" },
-        result: "CT301.md"
+        result: "CT301.md",
+        mcpServer: "cabane"
       },
       { type: "result", ok: true }
     ]
   },
+  {
+    // The turn-control server's `answer` (CT1973). opencode names an MCP tool `<server>_<tool>`,
+    // so the installed keys split the raw id: `cabane_companion_answer` is the turn-control
+    // server's, never the workspace server's `companion_answer`. The pump binds on that.
+    name: "turn-control answer is read as the turn-control server\u2019s, not cabane\u2019s",
+    request: makeRequest2({
+      cabane: {
+        mcpUrl: "https://cabane.test/api/mcp",
+        turnControlUrl: "https://cabane.test/api/turn-control",
+        bearer: "tok",
+        activeConversationId: "conv"
+      }
+    }),
+    nativeStream: [
+      textPart("p1", "On it."),
+      toolPart("t1", "cabane_companion_answer", { status: "running", input: {} }, "call_1"),
+      toolPart(
+        "t1",
+        "cabane_companion_answer",
+        { status: "completed", input: {}, output: '{"ok":true,"kind":"answer"}' },
+        "call_1"
+      ),
+      textPart("p2", "The answer."),
+      idle()
+    ],
+    expected: [
+      sessionEvent2(NEW_SESSION_ID),
+      { type: "text", body: "On it.", terminal: false },
+      {
+        type: "tool",
+        id: "call_1",
+        name: "cabane_companion_answer",
+        phase: "start",
+        summary: "",
+        input: {},
+        mcpServer: "cabane_companion"
+      },
+      {
+        type: "tool",
+        id: "call_1",
+        name: "cabane_companion_answer",
+        phase: "done",
+        summary: "",
+        input: {},
+        result: '{"ok":true,"kind":"answer"}',
+        mcpServer: "cabane_companion"
+      },
+      { type: "text", body: "The answer.", terminal: true },
+      { type: "result", ok: true }
+    ]
+  },
   {
     // Highest risk: cancel mid-stream. The abort lands after the tool result; the adapter stops before
     // the closing reply — no final text, no `result` event (the server writes the stopped marker).
@@ -5561,6 +5720,7 @@ function readToolItem(item, eventType) {
       name: server && server !== "cabane" ? `${server}.${tool2}` : tool2,
       input: item.arguments,
       status: toStatus(item.status),
+      ...server ? { server } : {},
       ...item.status === "completed" ? { result } : item.status === "failed" ? { result: hasMcpReceipt(result) ? result : readMcpError(item.error) } : {}
     };
   }
@@ -5789,11 +5949,20 @@ async function* decodeCodexStream(events, ctx) {
       if (!tool2) continue;
       yield* flushInterim();
       const name = prettyToolName(tool2.name);
+      const origin = tool2.server ? { mcpServer: tool2.server } : {};
       if (!startedTools.has(tool2.id)) {
         const summary = summarizeToolInput(tool2.input);
         pending.set(tool2.id, { name, summary, input: tool2.input });
         startedTools.add(tool2.id);
-        yield { type: "tool", id: tool2.id, name, phase: "start", summary, input: tool2.input };
+        yield {
+          type: "tool",
+          id: tool2.id,
+          name,
+          phase: "start",
+          summary,
+          input: tool2.input,
+          ...origin
+        };
       }
       const entry = pending.get(tool2.id);
       if (entry && hasToolInput2(tool2.input)) {
@@ -5811,7 +5980,8 @@ async function* decodeCodexStream(events, ctx) {
           phase: tool2.status === "completed" ? "done" : "error",
           summary: started?.summary ?? "",
           input: started?.input ?? tool2.input,
-          result: tool2.result
+          result: tool2.result,
+          ...origin
         };
       }
       continue;
@@ -5902,7 +6072,6 @@ function parseCodexModel(model) {
 
 // packages/agent-runtime/src/codex/run-spec.ts
 var CABANE_MCP_SERVER3 = "cabane";
-var TURN_CONTROL_MCP_SERVER2 = "cabane_companion";
 var ACTIVE_CONVERSATION_HEADER3 = "x-cabane-active-conversation";
 var ENV_ENVELOPE_KEYS = [
   "CABANE_CONVERSATION_ID",
@@ -6031,7 +6200,7 @@ function buildConfig(req) {
     default_tools_approval_mode: "approve"
   };
   if (req.cabane.turnControlUrl) {
-    mcp_servers[TURN_CONTROL_MCP_SERVER2] = {
+    mcp_servers[TURN_CONTROL_MCP_SERVER] = {
       url: req.cabane.turnControlUrl,
       http_headers: {
         Authorization: `Bearer ${req.cabane.bearer}`,
@@ -6481,6 +6650,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "t1",
         name: "read",
+        mcpServer: "cabane",
         phase: "start",
         summary: "sleep.md",
         input: { path: "sleep.md" }
@@ -6489,6 +6659,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "t1",
         name: "read",
+        mcpServer: "cabane",
         phase: "done",
         summary: "sleep.md",
         input: { path: "sleep.md" },
@@ -6534,6 +6705,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "query-success",
         name: "query",
+        mcpServer: "cabane",
         phase: "start",
         summary: "",
         input: { op: "files.read", args: { path: "/ABOUT.md" } }
@@ -6542,6 +6714,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "query-success",
         name: "query",
+        mcpServer: "cabane",
         phase: "done",
         summary: "",
         input: { op: "files.read", args: { path: "/ABOUT.md" } },
@@ -6588,6 +6761,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "query-failed",
         name: "query",
+        mcpServer: "cabane",
         phase: "start",
         summary: "",
         input: { op: "files.read", args: { path: "/ABOUT.md" } }
@@ -6596,6 +6770,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "query-failed",
         name: "query",
+        mcpServer: "cabane",
         phase: "error",
         summary: "",
         input: { op: "files.read", args: { path: "/ABOUT.md" } },
@@ -6605,6 +6780,54 @@ var CODEX_CONFORMANCE_FIXTURES = [
       { type: "result", ok: true }
     ]
   },
+  {
+    // The turn-control server's `answer` (CT1973): the tool event carries the server Codex names
+    // beside the tool, which is what the pump binds the declaration to. A non-cabane server keeps
+    // its prefix on the card as before.
+    name: "turn-control answer carries its server",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      agentMessage("m1", "On it."),
+      toolFrame("item.completed", {
+        id: "answer-1",
+        type: "mcp_tool_call",
+        server: "cabane_companion",
+        tool: "answer",
+        arguments: {},
+        status: "completed",
+        result: { content: [{ type: "text", text: '{"ok":true,"kind":"answer"}' }] }
+      }),
+      agentMessage("m2", "The answer."),
+      turnCompleted()
+    ],
+    expected: [
+      startedSession(NEW_THREAD_ID),
+      { type: "text", body: "On it.", terminal: false },
+      {
+        type: "tool",
+        id: "answer-1",
+        name: "cabane_companion.answer",
+        mcpServer: "cabane_companion",
+        phase: "start",
+        summary: "",
+        input: {}
+      },
+      {
+        type: "tool",
+        id: "answer-1",
+        name: "cabane_companion.answer",
+        mcpServer: "cabane_companion",
+        phase: "done",
+        summary: "",
+        input: {},
+        result: [{ type: "text", text: '{"ok":true,"kind":"answer"}' }]
+      },
+      { type: "text", body: "The answer.", terminal: true },
+      closingSession(NEW_THREAD_ID),
+      { type: "result", ok: true }
+    ]
+  },
   {
     // A transport/tool failure with no MCP result payload still uses the real adapter error message,
     // never `undefined`.
@@ -6630,6 +6853,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "mcp-failed",
         name: "other.lookup",
+        mcpServer: "other",
         phase: "start",
         summary: "receipt",
         input: { q: "receipt" }
@@ -6638,6 +6862,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "mcp-failed",
         name: "other.lookup",
+        mcpServer: "other",
         phase: "error",
         summary: "receipt",
         input: { q: "receipt" },
@@ -6674,6 +6899,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "mcp-image",
         name: "other.render",
+        mcpServer: "other",
         phase: "start",
         summary: "",
         input: {}
@@ -6682,6 +6908,7 @@ var CODEX_CONFORMANCE_FIXTURES = [
         type: "tool",
         id: "mcp-image",
         name: "other.render",
+        mcpServer: "other",
         phase: "done",
         summary: "",
         input: {},
@@ -6729,11 +6956,20 @@ var CODEX_CONFORMANCE_FIXTURES = [
     ],
     expected: [
       startedSession(NEW_THREAD_ID),
-      { type: "tool", id: "t1", name: "list", phase: "start", summary: "", input: {} },
       {
         type: "tool",
         id: "t1",
         name: "list",
+        mcpServer: "cabane",
+        phase: "start",
+        summary: "",
+        input: {}
+      },
+      {
+        type: "tool",
+        id: "t1",
+        name: "list",
+        mcpServer: "cabane",
         phase: "done",
         summary: "/product/tasks",
         input: { path: "/product/tasks" },
@@ -8012,7 +8248,7 @@ import { join as join14 } from "path";
 // src/turn-control-tools.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { z as z16 } from "zod";
-var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
+var COMPANION_LOCAL_MCP_SERVER = TURN_CONTROL_MCP_SERVER;
 var COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
 var ASK_TOOL = "ask";
 var ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${ASK_TOOL}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.202",
+  "version": "0.6.203",
   "type": "module",
   "description": "The Cabane Companion (headless): connect an 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",