@cabane/companion 0.6.52 → 0.6.54

package/dist/cli.js

@@ -232,6 +232,9 @@ function realAccountHome() {
   }
   return realHomeCache;
 }
+function agentCompanionHome() {
+  return join(cabaneDir(), "agent-home");
+}
 function cabaneDir() {
   const dir2 = join(process.env.CABANE_COMPANION_HOME || homedir(), ".cabane");
   if (process.env.VITEST) {
@@ -5530,6 +5533,7 @@ function readToolItem(item, eventType) {
   if (type === "mcp_tool_call") {
     const tool2 = str(item.tool) ?? "tool";
     const server = str(item.server);
+    const result = readMcpResult(item.result);
     return {
       id,
       // A cabane tool reads best as its bare verb (`read`); a non-cabane server's
@@ -5537,7 +5541,7 @@ function readToolItem(item, eventType) {
       name: server && server !== "cabane" ? `${server}.${tool2}` : tool2,
       input: item.arguments,
       status: toStatus(item.status),
-      ...item.status === "completed" ? { result: readMcpResult(item.result) } : item.status === "failed" ? { result: readMcpError(item.error) } : {}
+      ...item.status === "completed" ? { result } : item.status === "failed" ? { result: hasMcpReceipt(result) ? result : readMcpError(item.error) } : {}
     };
   }
   if (type === "web_search") {
@@ -5577,9 +5581,38 @@ function toStatus(v) {
 }
 function readMcpResult(result) {
   const rec2 = asRecord2(result);
-  if (rec2 && "content" in rec2) return rec2.content;
+  if (!rec2) return result;
+  if (hasOnlyNonTextContentBlocks(rec2.content)) return rec2.content;
+  if (rec2.structured_content !== void 0 && rec2.structured_content !== null) {
+    return rec2.structured_content;
+  }
+  if (rec2.structuredContent !== void 0 && rec2.structuredContent !== null) {
+    return rec2.structuredContent;
+  }
+  if ("content" in rec2) return rec2.content;
   return result;
 }
+function hasOnlyNonTextContentBlocks(content) {
+  if (!Array.isArray(content) || content.length === 0) return false;
+  let sawTypedBlock = false;
+  for (const raw of content) {
+    const block = asRecord2(raw);
+    const type = block && str(block.type);
+    if (!type) continue;
+    sawTypedBlock = true;
+    if (type === "text" && typeof block?.text === "string" && block.text.trim().length > 0) {
+      return false;
+    }
+  }
+  return sawTypedBlock;
+}
+function hasMcpReceipt(result) {
+  if (result === void 0 || result === null) return false;
+  if (typeof result === "string") return result.trim().length > 0;
+  if (Array.isArray(result)) return result.length > 0;
+  if (typeof result === "object") return Object.keys(result).length > 0;
+  return true;
+}
 function readMcpError(error) {
   const rec2 = asRecord2(error);
   return rec2 && str(rec2.message) || "error";
@@ -6103,6 +6136,25 @@ var errorItem = (id, message) => ({
   type: "item.completed",
   item: { id, type: "error", message }
 });
+var SDK_SUCCESS = { ok: true, result: { source: "native" }, logs: "", truncated: false };
+var SDK_FAILURE = {
+  ok: false,
+  result: null,
+  preview: '{"rows":[1,2,3]}',
+  logs: "",
+  truncated: false,
+  error: { kind: "output_too_large", bytes: 169167, limit: 65536 },
+  warnings: [],
+  committed: {
+    calls: [
+      {
+        method: "conversations.update",
+        args: { id: "conv-1", opts: { title: "Renamed before failure" } }
+      }
+    ]
+  },
+  inFlight: null
+};
 var sessionEvent3 = (threadId, cwd = DIR2, degraded = false, promptFingerprint = fingerprintPrompt(PROMPT)) => ({
   type: "session",
   state: encodeSession3({ threadId, cwd, promptFingerprint }),
@@ -6182,6 +6234,194 @@ var CODEX_CONFORMANCE_FIXTURES = [
       { type: "result", ok: true }
     ]
   },
+  {
+    // CT1211: recorded SDK success shape. Codex exposes the text compatibility
+    // copy and the native object together; normalization must keep the object.
+    name: "MCP success prefers native structured content",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.started", {
+        id: "sdk-success",
+        type: "mcp_tool_call",
+        server: "cabane",
+        tool: "sdk",
+        arguments: { code: 'return { source: "native" }' },
+        status: "in_progress"
+      }),
+      toolFrame("item.completed", {
+        id: "sdk-success",
+        type: "mcp_tool_call",
+        server: "cabane",
+        tool: "sdk",
+        arguments: { code: 'return { source: "native" }' },
+        status: "completed",
+        result: {
+          content: [{ type: "text", text: JSON.stringify(SDK_SUCCESS) }],
+          structured_content: SDK_SUCCESS
+        }
+      }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "sdk-success",
+        name: "sdk",
+        phase: "start",
+        summary: "",
+        input: { code: 'return { source: "native" }' }
+      },
+      {
+        type: "tool",
+        id: "sdk-success",
+        name: "sdk",
+        phase: "done",
+        summary: "",
+        input: { code: 'return { source: "native" }' },
+        result: SDK_SUCCESS
+      },
+      { type: "result", ok: true }
+    ]
+  },
+  {
+    // CT1211 incident shape: MCP `isError` keeps the failed phase, while the raw
+    // camel-case structured payload survives instead of the generic `error` token.
+    name: "failed SDK call preserves structured receipt while remaining error phase",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.started", {
+        id: "sdk-failed",
+        type: "mcp_tool_call",
+        server: "cabane",
+        tool: "sdk",
+        arguments: { code: "return largeResult" },
+        status: "in_progress"
+      }),
+      toolFrame("item.completed", {
+        id: "sdk-failed",
+        type: "mcp_tool_call",
+        server: "cabane",
+        tool: "sdk",
+        arguments: { code: "return largeResult" },
+        status: "failed",
+        result: {
+          content: [{ type: "text", text: JSON.stringify(SDK_FAILURE) }],
+          structuredContent: SDK_FAILURE,
+          isError: true
+        },
+        error: { message: "error" }
+      }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "sdk-failed",
+        name: "sdk",
+        phase: "start",
+        summary: "",
+        input: { code: "return largeResult" }
+      },
+      {
+        type: "tool",
+        id: "sdk-failed",
+        name: "sdk",
+        phase: "error",
+        summary: "",
+        input: { code: "return largeResult" },
+        result: SDK_FAILURE
+      },
+      { type: "result", ok: true }
+    ]
+  },
+  {
+    // A transport/tool failure has no MCP result payload and still uses the real
+    // adapter error message. CT1211 must not replace this fallback with `undefined`.
+    name: "failed MCP call without result keeps error message fallback",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.completed", {
+        id: "mcp-failed",
+        type: "mcp_tool_call",
+        server: "other",
+        tool: "lookup",
+        arguments: { q: "receipt" },
+        status: "failed",
+        result: { content: [], isError: true },
+        error: { message: "connection closed" }
+      }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "mcp-failed",
+        name: "other.lookup",
+        phase: "start",
+        summary: "receipt",
+        input: { q: "receipt" }
+      },
+      {
+        type: "tool",
+        id: "mcp-failed",
+        name: "other.lookup",
+        phase: "error",
+        summary: "receipt",
+        input: { q: "receipt" },
+        result: "connection closed"
+      },
+      { type: "result", ok: true }
+    ]
+  },
+  {
+    // CT1147 stays intact when a connector includes structured metadata beside an
+    // image-only MCP response: no image/base64 payload enters activity receipts.
+    name: "image-only MCP result remains empty despite structured metadata",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.completed", {
+        id: "mcp-image",
+        type: "mcp_tool_call",
+        server: "other",
+        tool: "render",
+        arguments: {},
+        status: "completed",
+        result: {
+          content: [{ type: "image", data: "base64-bytes", mimeType: "image/png" }],
+          structured_content: { image: "base64-bytes" }
+        }
+      }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "mcp-image",
+        name: "other.render",
+        phase: "start",
+        summary: "",
+        input: {}
+      },
+      {
+        type: "tool",
+        id: "mcp-image",
+        name: "other.render",
+        phase: "done",
+        summary: "",
+        input: {},
+        result: [{ type: "image", data: "base64-bytes", mimeType: "image/png" }]
+      },
+      { type: "result", ok: true }
+    ]
+  },
   {
     // A streaming tool whose args arrive on a later snapshot: `item.started` carries
     // empty args, `item.updated` fills them, `item.completed` finishes. The `start`
@@ -6738,6 +6978,7 @@ 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 MAX_ASK_ITEMS = 20;
 var SUB_AGENT_TOOL = "sub_agent";
 var SUB_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUB_AGENT_TOOL}`;
 var WAKE_ME_TOOL = "wake_me";
@@ -6809,7 +7050,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\u20135 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 summon/dispatch instead.`,
           {
             targetUserId: z13.string().uuid().describe(
               "The workspace member (human) to ask \u2014 a user id, from your turn context's roster."
@@ -6829,8 +7070,8 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
                 body: z13.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
                 options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
               })
-            ).min(1).max(5).optional().describe(
-              "MULTI-question form: 1\u20135 questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or `question`/`headline`/`options`, not both."
+            ).min(1).max(MAX_ASK_ITEMS).optional().describe(
+              `MULTI-question form: 1\u2013${MAX_ASK_ITEMS} questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or \`question\`/\`headline\`/\`options\`, not both.`
             )
           },
           async (args) => {
@@ -8010,7 +8251,8 @@ ${reason}`,
     }
     const turnEnv = {
       ...hookEnv,
-      CABANE_HOST_ACCESS: turnContext.policy.hostFs ? "1" : "0"
+      CABANE_HOST_ACCESS: turnContext.policy.hostFs ? "1" : "0",
+      CABANE_COMPANION_HOME: agentCompanionHome()
     };
     const key = runKey(payload.conversationId, payload.agentId);
     const abortController = new AbortController();

package/dist/runtime.js

@@ -224,6 +224,9 @@ function realAccountHome() {
   }
   return realHomeCache;
 }
+function agentCompanionHome() {
+  return join(cabaneDir(), "agent-home");
+}
 function cabaneDir() {
   const dir2 = join(process.env.CABANE_COMPANION_HOME || homedir(), ".cabane");
   if (process.env.VITEST) {
@@ -5029,6 +5032,7 @@ function readToolItem(item, eventType) {
   if (type === "mcp_tool_call") {
     const tool2 = str(item.tool) ?? "tool";
     const server = str(item.server);
+    const result = readMcpResult(item.result);
     return {
       id,
       // A cabane tool reads best as its bare verb (`read`); a non-cabane server's
@@ -5036,7 +5040,7 @@ function readToolItem(item, eventType) {
       name: server && server !== "cabane" ? `${server}.${tool2}` : tool2,
       input: item.arguments,
       status: toStatus(item.status),
-      ...item.status === "completed" ? { result: readMcpResult(item.result) } : item.status === "failed" ? { result: readMcpError(item.error) } : {}
+      ...item.status === "completed" ? { result } : item.status === "failed" ? { result: hasMcpReceipt(result) ? result : readMcpError(item.error) } : {}
     };
   }
   if (type === "web_search") {
@@ -5076,9 +5080,38 @@ function toStatus(v) {
 }
 function readMcpResult(result) {
   const rec = asRecord2(result);
-  if (rec && "content" in rec) return rec.content;
+  if (!rec) return result;
+  if (hasOnlyNonTextContentBlocks(rec.content)) return rec.content;
+  if (rec.structured_content !== void 0 && rec.structured_content !== null) {
+    return rec.structured_content;
+  }
+  if (rec.structuredContent !== void 0 && rec.structuredContent !== null) {
+    return rec.structuredContent;
+  }
+  if ("content" in rec) return rec.content;
   return result;
 }
+function hasOnlyNonTextContentBlocks(content) {
+  if (!Array.isArray(content) || content.length === 0) return false;
+  let sawTypedBlock = false;
+  for (const raw of content) {
+    const block = asRecord2(raw);
+    const type = block && str(block.type);
+    if (!type) continue;
+    sawTypedBlock = true;
+    if (type === "text" && typeof block?.text === "string" && block.text.trim().length > 0) {
+      return false;
+    }
+  }
+  return sawTypedBlock;
+}
+function hasMcpReceipt(result) {
+  if (result === void 0 || result === null) return false;
+  if (typeof result === "string") return result.trim().length > 0;
+  if (Array.isArray(result)) return result.length > 0;
+  if (typeof result === "object") return Object.keys(result).length > 0;
+  return true;
+}
 function readMcpError(error) {
   const rec = asRecord2(error);
   return rec && str(rec.message) || "error";
@@ -5602,6 +5635,25 @@ var errorItem = (id, message) => ({
   type: "item.completed",
   item: { id, type: "error", message }
 });
+var SDK_SUCCESS = { ok: true, result: { source: "native" }, logs: "", truncated: false };
+var SDK_FAILURE = {
+  ok: false,
+  result: null,
+  preview: '{"rows":[1,2,3]}',
+  logs: "",
+  truncated: false,
+  error: { kind: "output_too_large", bytes: 169167, limit: 65536 },
+  warnings: [],
+  committed: {
+    calls: [
+      {
+        method: "conversations.update",
+        args: { id: "conv-1", opts: { title: "Renamed before failure" } }
+      }
+    ]
+  },
+  inFlight: null
+};
 var sessionEvent3 = (threadId, cwd = DIR2, degraded = false, promptFingerprint = fingerprintPrompt(PROMPT)) => ({
   type: "session",
   state: encodeSession3({ threadId, cwd, promptFingerprint }),
@@ -5681,6 +5733,194 @@ var CODEX_CONFORMANCE_FIXTURES = [
       { type: "result", ok: true }
     ]
   },
+  {
+    // CT1211: recorded SDK success shape. Codex exposes the text compatibility
+    // copy and the native object together; normalization must keep the object.
+    name: "MCP success prefers native structured content",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.started", {
+        id: "sdk-success",
+        type: "mcp_tool_call",
+        server: "cabane",
+        tool: "sdk",
+        arguments: { code: 'return { source: "native" }' },
+        status: "in_progress"
+      }),
+      toolFrame("item.completed", {
+        id: "sdk-success",
+        type: "mcp_tool_call",
+        server: "cabane",
+        tool: "sdk",
+        arguments: { code: 'return { source: "native" }' },
+        status: "completed",
+        result: {
+          content: [{ type: "text", text: JSON.stringify(SDK_SUCCESS) }],
+          structured_content: SDK_SUCCESS
+        }
+      }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "sdk-success",
+        name: "sdk",
+        phase: "start",
+        summary: "",
+        input: { code: 'return { source: "native" }' }
+      },
+      {
+        type: "tool",
+        id: "sdk-success",
+        name: "sdk",
+        phase: "done",
+        summary: "",
+        input: { code: 'return { source: "native" }' },
+        result: SDK_SUCCESS
+      },
+      { type: "result", ok: true }
+    ]
+  },
+  {
+    // CT1211 incident shape: MCP `isError` keeps the failed phase, while the raw
+    // camel-case structured payload survives instead of the generic `error` token.
+    name: "failed SDK call preserves structured receipt while remaining error phase",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.started", {
+        id: "sdk-failed",
+        type: "mcp_tool_call",
+        server: "cabane",
+        tool: "sdk",
+        arguments: { code: "return largeResult" },
+        status: "in_progress"
+      }),
+      toolFrame("item.completed", {
+        id: "sdk-failed",
+        type: "mcp_tool_call",
+        server: "cabane",
+        tool: "sdk",
+        arguments: { code: "return largeResult" },
+        status: "failed",
+        result: {
+          content: [{ type: "text", text: JSON.stringify(SDK_FAILURE) }],
+          structuredContent: SDK_FAILURE,
+          isError: true
+        },
+        error: { message: "error" }
+      }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "sdk-failed",
+        name: "sdk",
+        phase: "start",
+        summary: "",
+        input: { code: "return largeResult" }
+      },
+      {
+        type: "tool",
+        id: "sdk-failed",
+        name: "sdk",
+        phase: "error",
+        summary: "",
+        input: { code: "return largeResult" },
+        result: SDK_FAILURE
+      },
+      { type: "result", ok: true }
+    ]
+  },
+  {
+    // A transport/tool failure has no MCP result payload and still uses the real
+    // adapter error message. CT1211 must not replace this fallback with `undefined`.
+    name: "failed MCP call without result keeps error message fallback",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.completed", {
+        id: "mcp-failed",
+        type: "mcp_tool_call",
+        server: "other",
+        tool: "lookup",
+        arguments: { q: "receipt" },
+        status: "failed",
+        result: { content: [], isError: true },
+        error: { message: "connection closed" }
+      }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "mcp-failed",
+        name: "other.lookup",
+        phase: "start",
+        summary: "receipt",
+        input: { q: "receipt" }
+      },
+      {
+        type: "tool",
+        id: "mcp-failed",
+        name: "other.lookup",
+        phase: "error",
+        summary: "receipt",
+        input: { q: "receipt" },
+        result: "connection closed"
+      },
+      { type: "result", ok: true }
+    ]
+  },
+  {
+    // CT1147 stays intact when a connector includes structured metadata beside an
+    // image-only MCP response: no image/base64 payload enters activity receipts.
+    name: "image-only MCP result remains empty despite structured metadata",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.completed", {
+        id: "mcp-image",
+        type: "mcp_tool_call",
+        server: "other",
+        tool: "render",
+        arguments: {},
+        status: "completed",
+        result: {
+          content: [{ type: "image", data: "base64-bytes", mimeType: "image/png" }],
+          structured_content: { image: "base64-bytes" }
+        }
+      }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "mcp-image",
+        name: "other.render",
+        phase: "start",
+        summary: "",
+        input: {}
+      },
+      {
+        type: "tool",
+        id: "mcp-image",
+        name: "other.render",
+        phase: "done",
+        summary: "",
+        input: {},
+        result: [{ type: "image", data: "base64-bytes", mimeType: "image/png" }]
+      },
+      { type: "result", ok: true }
+    ]
+  },
   {
     // A streaming tool whose args arrive on a later snapshot: `item.started` carries
     // empty args, `item.updated` fills them, `item.completed` finishes. The `start`
@@ -6237,6 +6477,7 @@ 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 MAX_ASK_ITEMS = 20;
 var SUB_AGENT_TOOL = "sub_agent";
 var SUB_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUB_AGENT_TOOL}`;
 var WAKE_ME_TOOL = "wake_me";
@@ -6308,7 +6549,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\u20135 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 summon/dispatch instead.`,
           {
             targetUserId: z13.string().uuid().describe(
               "The workspace member (human) to ask \u2014 a user id, from your turn context's roster."
@@ -6328,8 +6569,8 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
                 body: z13.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
                 options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
               })
-            ).min(1).max(5).optional().describe(
-              "MULTI-question form: 1\u20135 questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or `question`/`headline`/`options`, not both."
+            ).min(1).max(MAX_ASK_ITEMS).optional().describe(
+              `MULTI-question form: 1\u2013${MAX_ASK_ITEMS} questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or \`question\`/\`headline\`/\`options\`, not both.`
             )
           },
           async (args) => {
@@ -7509,7 +7750,8 @@ ${reason}`,
     }
     const turnEnv = {
       ...hookEnv,
-      CABANE_HOST_ACCESS: turnContext.policy.hostFs ? "1" : "0"
+      CABANE_HOST_ACCESS: turnContext.policy.hostFs ? "1" : "0",
+      CABANE_COMPANION_HOME: agentCompanionHome()
     };
     const key = runKey(payload.conversationId, payload.agentId);
     const abortController = new AbortController();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.52",
+  "version": "0.6.54",
   "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",