@cabane/companion 0.6.61 → 0.6.63

package/dist/cli.js

@@ -3061,6 +3061,15 @@ var turnEventSchema = z5.discriminatedUnion("type", [
       effort: z5.string().optional(),
       thinking: z5.string().optional(),
       reasoningEffort: z5.string().optional()
+    }).optional(),
+    // CT1275: the harness-reported MCP inventory from this turn's init frame.
+    // This is deliberately diagnostic-only: names, statuses and a count, never
+    // server definitions, credentials or session ids. `initReceived:false`
+    // distinguishes a missing init frame from a real empty inventory.
+    mcpInventory: z5.object({
+      initReceived: z5.boolean(),
+      servers: z5.array(z5.object({ name: z5.string(), status: z5.string() })),
+      toolCount: z5.number().int().nonnegative()
     }).optional()
   })
 ]);
@@ -3079,6 +3088,7 @@ var turnResultReasonSchema = z6.discriminatedUnion("kind", [
   z6.object({ kind: z6.literal("timeout_total") }),
   z6.object({ kind: z6.literal("cancelled") }),
   z6.object({ kind: z6.literal("skipped") }),
+  z6.object({ kind: z6.literal("workspace_tools_missing") }),
   z6.object({ kind: z6.literal("runtime_error") })
 ]);
 var turnOutcomes = ["success", "failure", "cancelled", "skipped"];
@@ -3104,7 +3114,12 @@ var turnDiagnosticsSchema = z6.object({
     result: z6.number().int().nonnegative()
   }),
   runtimeResultKind: z6.enum(turnRuntimeResultKinds).nullable(),
-  finalSource: z6.enum(turnFinalSources)
+  finalSource: z6.enum(turnFinalSources),
+  mcpInventory: z6.object({
+    initReceived: z6.boolean(),
+    servers: z6.array(z6.object({ name: z6.string(), status: z6.string() })),
+    toolCount: z6.number().int().nonnegative()
+  }).optional()
 });
 
 // packages/agent-runtime/src/failure.ts
@@ -3238,6 +3253,8 @@ function normalizeTurnResultReason(reason) {
       return { kind: "cancelled" };
     case "skipped":
       return { kind: "skipped" };
+    case "workspace_tools_missing":
+      return { kind: "workspace_tools_missing" };
     default:
       return { kind: "runtime_error" };
   }
@@ -3342,12 +3359,7 @@ var turnRequestSchema = z8.object({
     // adapters' conformance fixtures, tests) keeps parsing unchanged — the companion
     // always populates it (`build-options.ts`), and the native adapter fails the
     // turn loudly when it is somehow absent rather than guessing.
-    workspaceId: z8.string().optional(),
-    // CT752: the server-resolved workspace surface this credential exposes.
-    // Readiness uses this explicit fact to require `sdk` for code mode and the
-    // granular floor for classic mode; inventory contents alone cannot infer it
-    // because `sdk` is intentionally also available on the classic surface.
-    workspaceToolSurface: z8.enum(["code", "classic"]).optional()
+    workspaceId: z8.string().optional()
   }),
   // Machine-local resolution (host-filled): the checkout cwd, extra env from a
   // prepare hook, and the resolved user MCP servers.
@@ -3932,6 +3944,8 @@ async function* decodeSdkStream(iter, ctx) {
     out.push(event);
   };
   let sessionEmitted = false;
+  let workspaceProven = false;
+  let mcpInventory = { initReceived: false, servers: [], toolCount: 0 };
   let ok = false;
   let resultReason;
   let sawResult = false;
@@ -3949,6 +3963,12 @@ async function* decodeSdkStream(iter, ctx) {
       if (msg.type === "system" && msg.subtype === "init") {
         const initModel = msg.model;
         if (typeof initModel === "string" && initModel.length > 0) resolvedModel = initModel;
+        mcpInventory = readMcpInventory(msg);
+        workspaceProven = provesWorkspaceTools(msg);
+        if (!workspaceProven) {
+          resultReason = "workspace_tools_missing";
+          break;
+        }
         const sdkSessionId = msg.session_id;
         if (!sessionEmitted && sdkSessionId && sdkSessionId !== ctx.resumedSessionId) {
           sessionEmitted = true;
@@ -3958,6 +3978,9 @@ async function* decodeSdkStream(iter, ctx) {
             ...ctx.degraded ? { degraded: true } : {}
           };
         }
+      } else if (!workspaceProven && (msg.type === "assistant" || msg.type === "user" || msg.type === "result")) {
+        resultReason = "workspace_tools_missing";
+        break;
       } else if (msg.type === "assistant") {
         const assistantErr = msg.error;
         if (typeof assistantErr === "string" && assistantErr.length > 0) {
@@ -4021,6 +4044,10 @@ async function* decodeSdkStream(iter, ctx) {
     sawResult = true;
   }
   if (ctx.signal.aborted) return;
+  if (!workspaceProven) {
+    ok = false;
+    resultReason ??= "workspace_tools_missing";
+  }
   await flushHeldText(buffer, emit, ok);
   yield* drain(out);
   if (!ok && !resultReason && !sawResult) resultReason = "no_result";
@@ -4029,9 +4056,25 @@ async function* decodeSdkStream(iter, ctx) {
     ok,
     ...resultReason ? { reason: resultReason } : {},
     ...usage ? { usage } : {},
-    ...resolvedModel ? { resolvedModel } : {}
+    ...resolvedModel ? { resolvedModel } : {},
+    mcpInventory
   };
 }
+function readMcpInventory(msg) {
+  const frame = msg;
+  const servers = Array.isArray(frame.mcp_servers) ? frame.mcp_servers.flatMap(
+    (server) => typeof server?.name === "string" && typeof server.status === "string" ? [{ name: server.name, status: server.status }] : []
+  ) : [];
+  return {
+    initReceived: true,
+    servers,
+    toolCount: Array.isArray(frame.tools) ? frame.tools.length : 0
+  };
+}
+function provesWorkspaceTools(msg) {
+  const tools = msg.tools;
+  return Array.isArray(tools) && tools.includes("mcp__cabane__sdk");
+}
 function isSubscriptionWindow(value) {
   return value === "five_hour" || value === "seven_day" || value === "seven_day_opus" || value === "seven_day_sonnet" || value === "overage";
 }
@@ -4130,6 +4173,11 @@ var CABANE_POLICY = {
   uiPrompts: "never"
 };
 var CWD = "/env/here";
+var HEALTHY_MCP_INVENTORY = {
+  initReceived: true,
+  servers: [{ name: "cabane", status: "connected" }],
+  toolCount: 1
+};
 function makeRequest(overrides = {}) {
   return {
     systemPrompt: "system",
@@ -4150,7 +4198,8 @@ var init = (sessionId, model) => ({
   type: "system",
   subtype: "init",
   session_id: sessionId,
-  mcp_servers: [],
+  mcp_servers: HEALTHY_MCP_INVENTORY.servers,
+  tools: ["mcp__cabane__sdk"],
   ...model ? { model } : {}
 });
 var assistantText = (text) => ({
@@ -4211,7 +4260,7 @@ var sessionEvent = (sdkSessionId, cwd = CWD, degraded = false) => ({
   state: encodeSession({ sdkSessionId, cwd }),
   ...degraded ? { degraded: true } : {}
 });
-var CLAUDE_CODE_CONFORMANCE_FIXTURES = [
+var BASE_CLAUDE_CODE_CONFORMANCE_FIXTURES = [
   {
     // A plain text reply: the held text-only block flushes as the terminal final.
     name: "clean turn",
@@ -4591,6 +4640,12 @@ var CLAUDE_CODE_CONFORMANCE_FIXTURES = [
     ]
   }
 ];
+var CLAUDE_CODE_CONFORMANCE_FIXTURES = BASE_CLAUDE_CODE_CONFORMANCE_FIXTURES.map((fixture) => ({
+  ...fixture,
+  expected: fixture.expected.map(
+    (event) => event.type === "result" ? { ...event, mcpInventory: HEALTHY_MCP_INVENTORY } : event
+  )
+}));
 
 // packages/agent-runtime/src/registry.ts
 function createAdapterRegistry(adapters) {
@@ -7096,7 +7151,7 @@ var ConnectorHealthStore = class {
 
 // src/dispatcher.ts
 import { createHash as createHash2, randomUUID } from "crypto";
-import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync10, readdirSync as readdirSync2, statSync } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync2, statSync } from "fs";
 import { join as join14 } from "path";
 
 // src/turn-control-tools.ts
@@ -7118,16 +7173,32 @@ 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 createReplyState() {
-  return { answersMessageId: null };
+  return { answersMessageId: null, order: null };
 }
 function createSendState() {
-  return { agentId: null, message: null };
+  return { agentId: null, message: null, order: null };
+}
+function createTurnControlOrder() {
+  let calls = 0;
+  return {
+    next: () => {
+      calls += 1;
+      return calls;
+    }
+  };
 }
 function createSkipState() {
   return { skipped: false, reason: null };
 }
 function createAskState() {
-  return { targetUserId: null, question: null, headline: null, options: null, questions: null };
+  return {
+    targetUserId: null,
+    question: null,
+    headline: null,
+    options: null,
+    questions: null,
+    order: null
+  };
 }
 function createWakeState() {
   return { afterSeconds: null, at: null, note: null, cancelled: false };
@@ -7157,7 +7228,7 @@ function wakeCommitField(state) {
     }
   };
 }
-function createTurnControlMcpServer(sendState, skipState, askState, subAgentCreate, wakeState, replyState) {
+function createTurnControlMcpServer(sendState, skipState, askState, subAgentCreate, wakeState, replyState, controlOrder) {
   return createSdkMcpServer({
     name: COMPANION_LOCAL_MCP_SERVER,
     version: "0.0.0",
@@ -7174,6 +7245,7 @@ function createTurnControlMcpServer(sendState, skipState, askState, subAgentCrea
         async (args) => {
           sendState.agentId = args.agentId;
           sendState.message = args.message;
+          sendState.order = controlOrder?.next() ?? null;
           return {
             content: [{ type: "text", text: JSON.stringify({ sent: args.agentId }) }]
           };
@@ -7189,6 +7261,7 @@ function createTurnControlMcpServer(sendState, skipState, askState, subAgentCrea
           },
           async (args) => {
             replyState.answersMessageId = args.messageId;
+            replyState.order = controlOrder?.next() ?? null;
             return {
               content: [
                 {
@@ -7271,6 +7344,7 @@ function createTurnControlMcpServer(sendState, skipState, askState, subAgentCrea
               };
             }
             askState.targetUserId = args.targetUserId;
+            askState.order = controlOrder?.next() ?? null;
             if (hasArray) {
               askState.questions = args.questions;
               askState.question = null;
@@ -7433,7 +7507,6 @@ function buildCompanionTurnRequest(params) {
       bearer: params.turnToken ?? params.agentPat,
       activeConversationId: params.activeConversationId,
       workspaceId: params.workspaceId,
-      ...t.workspaceToolSurface ? { workspaceToolSurface: t.workspaceToolSurface } : {},
       // CT714: mount the turn-control surface ONLY when a real turn token backs
       // this turn — the surface admits `turn_token` auth exclusively, so a
       // PAT-fallback bearer would be rejected there. Absent it, external adapters
@@ -7835,12 +7908,31 @@ var TurnCommitter = class {
   // a wordless turn has no answer to bind, and the server's mute-settle
   // notice speaks for it.
   turnControlFields(kind) {
-    return {
+    const fields = {
       ...this.answersField(kind),
       ...this.sendField(),
       ...this.askField(),
       ...this.wakeField()
     };
+    return { ...fields, ...this.orderField(fields) };
+  }
+  // CT1281: the order the control tools were CALLED, for the addressed rows the
+  // server writes from this one commit. It reports a position only for an intent
+  // that actually made it into the commit — an ask whose payload was incomplete,
+  // or a self-send the committer stripped, contributes no row and so has no place
+  // in the line. An intent with no recorded call (the runtime's auto-declared
+  // reply) is deliberately absent: the server sorts it last, which is what it is.
+  orderField(fields) {
+    const order = {};
+    const replyOrder = this.deps.replyState.order;
+    if (fields.answersMessageId !== void 0 && replyOrder !== null) order.reply = replyOrder;
+    if (fields.dispatch !== void 0 && this.deps.sendState.order !== null) {
+      order.send = this.deps.sendState.order;
+    }
+    if (fields.ask !== void 0 && this.deps.askState.order !== null) {
+      order.ask = this.deps.askState.order;
+    }
+    return Object.keys(order).length > 0 ? { turnControlOrder: order } : {};
   }
   // The declared reply: explicit `reply_to` first, else the runtime's own
   // declaration for the turn that just answers — see
@@ -7909,173 +8001,6 @@ var TurnCommitter = class {
   }
 };
 
-// src/workspace-readiness.ts
-var CLASSIC_REQUIRED = ["read", "list", "search", "write", "edit"];
-var INITIALIZE_RETRY_DELAYS_MS = [250, 750, 1500];
-var INITIALIZE_ATTEMPT_TIMEOUT_MS = 4e3;
-var INITIALIZE_RETRY_BUDGET_MS = 1e4;
-async function proveWorkspaceTools(req, runtime, opts = {}) {
-  const base = {
-    ok: false,
-    proofType: "authenticated_mcp_tools_list",
-    runtime,
-    harnessFingerprint: opts.harnessFingerprint ?? runtime,
-    endpoint: safeEndpoint(req.cabane.mcpUrl),
-    initialized: false,
-    authenticated: false,
-    discoveredTools: [],
-    requiredTools: [],
-    acceptedNames: ["sdk", "mcp__cabane__sdk"],
-    failedCapability: null,
-    detail: null
-  };
-  if (!req.cabane.mcpUrl) return fail(base, "server_not_configured", "Cabane MCP URL absent");
-  if (!req.cabane.bearer) return fail(base, "authentication_failed", "Cabane bearer absent");
-  const fetchImpl = opts.fetchImpl ?? fetch;
-  const headers = {
-    authorization: `Bearer ${req.cabane.bearer}`,
-    accept: "application/json, text/event-stream",
-    "content-type": "application/json",
-    "x-cabane-active-conversation": req.cabane.activeConversationId
-  };
-  try {
-    const initialized = await initializeWithRetry(
-      fetchImpl,
-      req.cabane.mcpUrl,
-      headers,
-      {
-        jsonrpc: "2.0",
-        id: 1,
-        method: "initialize",
-        params: {
-          protocolVersion: "2025-03-26",
-          capabilities: {},
-          clientInfo: { name: "cabane-companion-readiness", version: "1" }
-        }
-      },
-      opts.retryDelaysMs ?? INITIALIZE_RETRY_DELAYS_MS
-    );
-    if (initialized.status === 401 || initialized.status === 403)
-      return fail(base, "authentication_failed", `initialize returned HTTP ${initialized.status}`);
-    if (initialized.transient)
-      return fail(base, "workspace_endpoint_unreachable", initialized.detail);
-    if (!initialized.ok) return fail(base, "initialization_failed", initialized.detail);
-    base.initialized = true;
-    base.authenticated = true;
-    if (initialized.sessionId) headers["mcp-session-id"] = initialized.sessionId;
-    const listed = await rpc(fetchImpl, req.cabane.mcpUrl, headers, {
-      jsonrpc: "2.0",
-      id: 2,
-      method: "tools/list",
-      params: {}
-    });
-    if (listed.status === 401 || listed.status === 403)
-      return fail(base, "authentication_failed", `tools/list returned HTTP ${listed.status}`);
-    if (!listed.ok) return fail(base, "tool_discovery_failed", listed.detail);
-    const result = asRecord3(asRecord3(listed.value)?.result);
-    const tools = Array.isArray(result?.tools) ? result.tools : null;
-    if (!tools) return fail(base, "tool_discovery_failed", "tools/list returned no tool inventory");
-    base.discoveredTools = tools.map(
-      (tool2) => tool2 && typeof tool2 === "object" && typeof tool2.name === "string" ? tool2.name : null
-    ).filter((name) => name !== null).sort();
-    if (!req.cabane.workspaceToolSurface)
-      return fail(base, "required_tool_missing", "resolved workspace tool surface absent");
-    base.requiredTools = req.cabane.workspaceToolSurface === "code" ? ["sdk"] : CLASSIC_REQUIRED;
-    const missing = base.requiredTools.filter((name) => !base.discoveredTools.includes(name));
-    if (missing.length > 0)
-      return fail(
-        base,
-        "required_tool_missing",
-        `missing initialized tools: ${missing.join(", ")}`
-      );
-    base.ok = true;
-    return base;
-  } catch (error) {
-    return fail(
-      base,
-      "workspace_endpoint_unreachable",
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-}
-async function initializeWithRetry(fetchImpl, url, headers, body, retryDelaysMs) {
-  let lastFailure = null;
-  const deadline = Date.now() + INITIALIZE_RETRY_BUDGET_MS;
-  for (let attempt = 0; attempt <= retryDelaysMs.length; attempt += 1) {
-    try {
-      const remainingMs = deadline - Date.now();
-      if (remainingMs <= 0) break;
-      const result = await rpc(
-        fetchImpl,
-        url,
-        headers,
-        body,
-        Math.min(INITIALIZE_ATTEMPT_TIMEOUT_MS, remainingMs)
-      );
-      if (result.status === 401 || result.status === 403 || result.ok) return result;
-      if (result.status < 500) return result;
-      lastFailure = { ...result, transient: true };
-    } catch (error) {
-      lastFailure = {
-        ok: false,
-        status: 0,
-        sessionId: null,
-        value: null,
-        detail: error instanceof Error ? error.message : String(error),
-        transient: true
-      };
-    }
-    const retryDelayMs = retryDelaysMs[attempt];
-    if (retryDelayMs === void 0 || Date.now() + retryDelayMs >= deadline) break;
-    await delay(retryDelayMs);
-  }
-  return lastFailure;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function fail(proof, capability, detail) {
-  proof.failedCapability = capability;
-  proof.detail = detail.slice(0, 300);
-  return proof;
-}
-function safeEndpoint(value) {
-  try {
-    const url = new URL(value);
-    return `${url.origin}${url.pathname}`;
-  } catch {
-    return null;
-  }
-}
-async function rpc(fetchImpl, url, headers, body, timeoutMs) {
-  const response = await fetchImpl(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-    ...timeoutMs ? { signal: AbortSignal.timeout(timeoutMs) } : {}
-  });
-  const text = await response.text();
-  const value = parseRpcBody(text);
-  return {
-    ok: response.ok && !!value && !value.error,
-    status: response.status,
-    sessionId: response.headers.get("mcp-session-id"),
-    value,
-    detail: typeof asRecord3(value?.error)?.message === "string" ? String(asRecord3(value?.error)?.message) : `HTTP ${response.status}`
-  };
-}
-function parseRpcBody(text) {
-  const trimmed = text.trim();
-  if (trimmed.startsWith("{")) return JSON.parse(trimmed);
-  for (const line of trimmed.split("\n")) {
-    if (line.startsWith("data:")) return JSON.parse(line.slice(5).trim());
-  }
-  return null;
-}
-function asRecord3(value) {
-  return value !== null && typeof value === "object" ? value : null;
-}
-
 // src/dispatcher.ts
 var PREPARING_TOOL_NAME = "preparing";
 var PREPARE_FAILED_PREFIX = "**Couldn't prepare your environment.** I wasn't able to provision a working directory for this conversation, so I can't run this turn. The provisioning command reported:";
@@ -8466,6 +8391,7 @@ ${reason}`,
     const askState = createAskState();
     const wakeState = createWakeState();
     const replyState = createReplyState();
+    const controlOrder = createTurnControlOrder();
     let spawnedSubAgent = false;
     const subAgentCreate = async (args) => {
       const dispatchTarget = args.agentId ?? payload.agentId;
@@ -8497,7 +8423,8 @@ ${reason}`,
       askState,
       subAgentCreate,
       wakeState,
-      replyState
+      replyState,
+      controlOrder
     );
     const request = buildCompanionTurnRequest({
       turnContext,
@@ -8568,152 +8495,7 @@ ${reason}`,
         `runtime_unavailable:${err.runtime}`
       );
     }
-    let turnReceiptPath = null;
     const totalTimeoutMs = this.opts.totalTimeoutMs ?? DEFAULT_AGENT_TOTAL_TIMEOUT_MS;
-    const closeTurnReceipt = (ok, reason) => {
-      if (!turnReceiptPath) return;
-      const target = turnReceiptPath;
-      turnReceiptPath = null;
-      try {
-        appendFileSync2(
-          target,
-          `${JSON.stringify({
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            event: "settled",
-            turnId,
-            agentId: payload.agentId,
-            conversationId: payload.conversationId,
-            ok,
-            reason
-          })}
-`,
-          { mode: 384 }
-        );
-      } catch (error) {
-        turnLog.warn(
-          { err: error instanceof Error ? error.message : String(error) },
-          "dispatcher: turn-settled diagnostic write failed"
-        );
-      }
-    };
-    if (prepareHook && hookEnv?.CABANE_TASK_ID) {
-      const checkout = checkoutState(effectiveCwd);
-      if (!effectiveCwd || !checkout.ok) {
-        const reason = `checkout_missing: ${checkout.reason}; task=${hookEnv.CABANE_TASK_ID}; recovery=re-dispatch this conversation (the prepare hook re-provisions the environment)`;
-        turnLog.error({ checkout: effectiveCwd ?? null, checkoutState: checkout }, reason);
-        try {
-          await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
-            body: `**Couldn't prepare your environment.** ${reason}`,
-            kind: "final",
-            turnId,
-            parentMessageId: payload.messageId
-          });
-        } catch (postErr) {
-          turnLog.warn(
-            { err: postErr instanceof Error ? postErr.message : String(postErr) },
-            "dispatcher: checkout-missing notice post failed"
-          );
-        }
-        return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
-      }
-      const receiptPath = join14(effectiveCwd, ".git", "cabane", "readiness.jsonl");
-      const receiptLine = (fields) => `${JSON.stringify({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        taskId: hookEnv.CABANE_TASK_ID,
-        binding: hookEnv.CABANE_TASK_BINDING ?? null,
-        checkout: effectiveCwd,
-        // CT1022: the two fields the environment reaper reads — which turn this
-        // is (so its settle can be matched among interleaved agents) and how long
-        // it may legitimately run (so an unclosed receipt expires on this turn's
-        // real deadline, not the reaper's guess).
-        turnId,
-        totalTimeoutMs,
-        // CT1062: WHOSE turn. A task env is shared — between agents, and between
-        // an agent's own sequential conversations — so a reader asking "is a turn
-        // of THIS agent, other than mine, running here?" (the host's run-lock
-        // does, before it lets a second conversation into the tree) can only
-        // answer it if the line says who. An unattributed open line has to count
-        // for everyone, which refuses work that should have been admitted.
-        agentId: payload.agentId,
-        conversationId: payload.conversationId,
-        ...fields
-      })}
-`;
-      try {
-        mkdirSync10(join14(effectiveCwd, ".git", "cabane"), { recursive: true });
-        appendFileSync2(
-          receiptPath,
-          // `starting` is the honest classification before the proof has run. The
-          // line the proof appends below carries the same `turnId`, so a reader
-          // replaying the file sees one turn, not two.
-          receiptLine({ classification: "starting" }),
-          { mode: 384 }
-        );
-        turnReceiptPath = receiptPath;
-      } catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        const reason = `turn_receipt_unwritable: ${detail}; task=${hookEnv.CABANE_TASK_ID}; checkout=${effectiveCwd}; recovery=restore write access to the checkout's .git/cabane, then re-dispatch`;
-        turnLog.error({ err: detail, receiptPath }, reason);
-        try {
-          await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
-            body: `**Couldn't prepare your environment.** ${reason}`,
-            kind: "final",
-            turnId,
-            parentMessageId: payload.messageId
-          });
-        } catch (postErr) {
-          turnLog.warn(
-            { err: postErr instanceof Error ? postErr.message : String(postErr) },
-            "dispatcher: turn-receipt failure notice post failed"
-          );
-        }
-        return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
-      }
-      const proof = await proveWorkspaceTools(request, adapter.name, {
-        ...this.opts.workspaceProofFetch ? { fetchImpl: this.opts.workspaceProofFetch } : {},
-        ...this.opts.workspaceProofRetryDelaysMs ? { retryDelaysMs: this.opts.workspaceProofRetryDelaysMs } : {},
-        harnessFingerprint: turnContext.runtime
-      });
-      turnLog[proof.ok ? "info" : "error"](
-        { workspaceProof: proof, checkout: effectiveCwd },
-        `dispatcher: workspace tool proof ${proof.ok ? "passed" : "failed"}, checkout usable`
-      );
-      try {
-        appendFileSync2(
-          receiptPath,
-          receiptLine({
-            classification: proof.ok ? "ready" : "workspace_tools_missing",
-            failedCapability: proof.failedCapability,
-            workspaceTools: proof
-          }),
-          { mode: 384 }
-        );
-      } catch (error) {
-        turnLog.warn(
-          { err: error instanceof Error ? error.message : String(error) },
-          "dispatcher: workspace-proof diagnostic write failed (the turn receipt is open)"
-        );
-      }
-      if (!proof.ok) {
-        const recovery = proof.failedCapability === "workspace_endpoint_unreachable" ? "the Cabane workspace endpoint was unreachable; retry this dispatch" : "restart the connector after restoring the Cabane workspace tool mount";
-        const reason = `workspace_tools_missing: ${proof.failedCapability}; checkout=${effectiveCwd}; runtime=${adapter.name}; recovery=${recovery}`;
-        closeTurnReceipt(false, reason);
-        try {
-          await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
-            body: `**Couldn't prepare your environment.** ${reason}`,
-            kind: "final",
-            turnId,
-            parentMessageId: payload.messageId
-          });
-        } catch (postErr) {
-          turnLog.warn(
-            { err: postErr instanceof Error ? postErr.message : String(postErr) },
-            "dispatcher: workspace-proof failure notice post failed"
-          );
-        }
-        return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
-      }
-    }
     const transcript2 = this.opts.transcriptDir ? new TranscriptWriter(
       this.opts.transcriptDir,
       {
@@ -8736,6 +8518,7 @@ ${reason}`,
     let turnUsage;
     let turnResolvedModel;
     let turnResolvedConfig;
+    let turnMcpInventory;
     const eventCounts = {
       session: 0,
       text: 0,
@@ -8760,11 +8543,12 @@ ${reason}`,
       signal: abortController.signal,
       log: turnLog,
       nextSeq,
-      // The committer reads this at commit to attach the addressed send onto the
-      // turn's `final` row.
+      // The committer reads this at commit to carry the addressed send on the
+      // terminal row; the server writes the send itself as a distinct message.
       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.
+      // CT326: likewise the ask payload. CT1281: the server writes the ask as its
+      // own addressed message to the human — which ENQUEUES like any other send —
+      // and creates the `asks` row against that carrier, not against turn speech.
       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.
@@ -8789,6 +8573,7 @@ ${reason}`,
         );
         if (intent.ask) {
           askState.targetUserId = intent.ask.targetUserId;
+          askState.order = intent.askOrder ?? null;
           if (intent.ask.questions && intent.ask.questions.length > 0) {
             askState.questions = intent.ask.questions;
             askState.question = null;
@@ -8817,8 +8602,12 @@ ${reason}`,
         if (intent.sendAgentId && intent.sendBody) {
           sendState.agentId = intent.sendAgentId;
           sendState.message = intent.sendBody;
+          sendState.order = intent.sendOrder ?? null;
+        }
+        if (intent.answersMessageId) {
+          replyState.answersMessageId = intent.answersMessageId;
+          replyState.order = intent.replyOrder ?? null;
         }
-        if (intent.answersMessageId) replyState.answersMessageId = intent.answersMessageId;
         if (intent.skipped) {
           skipState.skipped = true;
           skipState.reason = intent.skipReason;
@@ -8901,6 +8690,7 @@ ${reason}`,
           turnUsage = event.usage;
           turnResolvedModel = event.resolvedModel;
           turnResolvedConfig = event.resolvedConfig;
+          turnMcpInventory = event.mcpInventory;
           runtimeResultKind = event.ok ? "success" : event.reason === "no_terminal" ? "no_terminal" : "error";
         } else if (event.type === "text" && skipState.skipped) {
         } else {
@@ -8977,7 +8767,6 @@ ${reason}`,
     } finally {
       if (idleTimer) clearTimeout(idleTimer);
       clearTimeout(totalTimer);
-      closeTurnReceipt(okResult, resultReason ?? null);
       const userCancelled = abortController.signal.aborted && timeoutReason === null;
       if (timeoutReason !== null) {
         resultReason = timeoutReason;
@@ -9059,6 +8848,7 @@ ${reason}`,
         sessionFingerprint: fingerprintSessionState(latestSessionState),
         eventCounts,
         runtimeResultKind,
+        ...turnMcpInventory ? { mcpInventory: turnMcpInventory } : {},
         finalSource: outcome === "skipped" || outcome === "cancelled" || silentMarkerEmitted ? "marker" : committer.finalSource
       };
       body.diagnostics = settledDiagnostics;
@@ -9208,7 +8998,7 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
 // src/outbox.ts
 import {
   existsSync as existsSync11,
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync10,
   readdirSync as readdirSync3,
   readFileSync as readFileSync8,
   renameSync as renameSync3,
@@ -9238,7 +9028,7 @@ var Outbox = class {
   // per-workspace bounds.
   persist(entry) {
     const dir2 = this.dir();
-    mkdirSync11(dir2, { recursive: true });
+    mkdirSync10(dir2, { recursive: true });
     const target = this.fileFor(entry.turnId, entry.seq);
     const tmp = `${target}.${process.pid}.tmp`;
     try {
@@ -10509,14 +10299,14 @@ function handleUncaught(log, err, origin) {
 }
 
 // src/crash-marker.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync12, readFileSync as readFileSync9, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync9, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
 import { join as join16 } from "path";
 function crashMarkerPath() {
   return join16(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
-    mkdirSync12(cabaneDir(), { recursive: true });
+    mkdirSync11(cabaneDir(), { recursive: true });
     writeFileSync8(crashMarkerPath(), JSON.stringify(rec2, null, 2) + "\n");
   } catch {
   }
@@ -10696,7 +10486,7 @@ async function closeSurfaces(control, dashboard) {
 
 // src/commands/daemon.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync as closeSync3, mkdirSync as mkdirSync13, openSync as openSync3 } from "fs";
+import { closeSync as closeSync3, mkdirSync as mkdirSync12, openSync as openSync3 } from "fs";
 
 // src/cli-entry.ts
 import { existsSync as existsSync13 } from "fs";
@@ -10799,7 +10589,7 @@ Stop:    cabane-companion stop
 }
 function defaultSpawnDetached(args) {
   const cliPath = companionCliEntry();
-  mkdirSync13(cabaneDir(), { recursive: true });
+  mkdirSync12(cabaneDir(), { recursive: true });
   const logFd = openSync3(companionLogPath(), "a");
   try {
     return spawn4(process.execPath, [cliPath, ...args], {
@@ -11439,12 +11229,12 @@ function renderTranscript(jsonlLines) {
       case "system":
         if (str2(obj.subtype) === "init") {
           out.push(`[session ${str2(obj.session_id) || "?"} \xB7 model ${str2(obj.model) || "?"}]`);
-          const servers = Array.isArray(obj.mcp_servers) ? obj.mcp_servers.map((s) => {
-            const r = rec(s);
-            return r ? `${str2(r.name) || "?"}${str2(r.status) ? `(${str2(r.status)})` : ""}` : "";
-          }).filter(Boolean).join(", ") : "";
-          if (servers) out.push(`  MCP servers: ${servers}`);
-          if (Array.isArray(obj.tools)) out.push(`  tools: ${obj.tools.length} available`);
+          out.push(
+            ...mcpInventoryLines(
+              obj.mcp_servers,
+              Array.isArray(obj.tools) ? obj.tools.length : void 0
+            )
+          );
           out.push("");
         }
         break;
@@ -11477,11 +11267,24 @@ function renderTranscript(jsonlLines) {
         break;
       }
       case "result": {
-        const isErr = obj.is_error === true || str2(obj.subtype) !== "success";
+        const isErr = typeof obj.ok === "boolean" ? obj.ok !== true : obj.is_error === true || str2(obj.subtype) !== "success";
         const dur = typeof obj.duration_ms === "number" ? ` \xB7 ${obj.duration_ms}ms` : "";
         out.push(
           `[result ${isErr ? "error" : "ok"}${str2(obj.subtype) ? ` \xB7 ${str2(obj.subtype)}` : ""}${dur}]`
         );
+        const inventory = rec(obj.mcpInventory);
+        if (inventory) {
+          if (inventory.initReceived === false) {
+            out.push("  MCP init: missing");
+          } else {
+            out.push(
+              ...mcpInventoryLines(
+                inventory.servers,
+                typeof inventory.toolCount === "number" ? inventory.toolCount : void 0
+              )
+            );
+          }
+        }
         if (isErr && str2(obj.result).trim()) out.push(`  ${indent(str2(obj.result))}`);
         break;
       }
@@ -11496,6 +11299,16 @@ function renderTranscript(jsonlLines) {
   }
   return out.join("\n");
 }
+function mcpInventoryLines(serversValue, toolCount) {
+  const servers = Array.isArray(serversValue) ? serversValue.map((server) => {
+    const value = rec(server);
+    return value ? `${str2(value.name) || "?"}${str2(value.status) ? `(${str2(value.status)})` : ""}` : "";
+  }).filter(Boolean).join(", ") : "";
+  return [
+    ...servers ? [`  MCP servers: ${servers}`] : [],
+    ...typeof toolCount === "number" ? [`  tools: ${toolCount} available`] : []
+  ];
+}
 function safeParse(s) {
   try {
     return JSON.parse(s);