@cabane/companion 0.6.36 → 0.6.37

package/dist/cli.js

@@ -2999,13 +2999,55 @@ var turnEventSchema = z5.discriminatedUnion("type", [
   })
 ]);
 
-// packages/agent-runtime/src/failure.ts
+// packages/agent-runtime/src/turn-diagnostics.ts
 import { z as z6 } from "zod";
-var turnFailureSchema = z6.discriminatedUnion("kind", [
+var turnResultReasonSchema = z6.discriminatedUnion("kind", [
   z6.object({ kind: z6.literal("usage_capped"), resetsAt: z6.string().optional() }),
   z6.object({ kind: z6.literal("rate_limited") }),
   z6.object({ kind: z6.literal("server_error") }),
-  z6.object({ kind: z6.literal("auth_expired") })
+  z6.object({ kind: z6.literal("auth_expired") }),
+  z6.object({ kind: z6.literal("no_result") }),
+  z6.object({ kind: z6.literal("empty_result") }),
+  z6.object({ kind: z6.literal("empty_result_unverified") }),
+  z6.object({ kind: z6.literal("timeout_idle") }),
+  z6.object({ kind: z6.literal("timeout_total") }),
+  z6.object({ kind: z6.literal("cancelled") }),
+  z6.object({ kind: z6.literal("skipped") }),
+  z6.object({ kind: z6.literal("runtime_error") })
+]);
+var turnOutcomes = ["success", "failure", "cancelled", "skipped"];
+var turnSessionModes = ["fresh", "resumed", "degraded"];
+var turnRuntimeResultKinds = ["success", "error", "no_terminal"];
+var turnFinalSources = [
+  "runtime_text",
+  "progress_promotion",
+  "host_fallback",
+  "marker",
+  "none"
+];
+var turnDiagnosticsSchema = z6.object({
+  outcome: z6.enum(turnOutcomes),
+  resultReason: turnResultReasonSchema.nullable(),
+  sessionMode: z6.enum(turnSessionModes),
+  sessionFingerprint: z6.string().regex(/^[a-f0-9]{16}$/).nullable(),
+  eventCounts: z6.object({
+    session: z6.number().int().nonnegative(),
+    text: z6.number().int().nonnegative(),
+    thinking: z6.number().int().nonnegative(),
+    tool: z6.number().int().nonnegative(),
+    result: z6.number().int().nonnegative()
+  }),
+  runtimeResultKind: z6.enum(turnRuntimeResultKinds).nullable(),
+  finalSource: z6.enum(turnFinalSources)
+});
+
+// packages/agent-runtime/src/failure.ts
+import { z as z7 } from "zod";
+var turnFailureSchema = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("usage_capped"), resetsAt: z7.string().optional() }),
+  z7.object({ kind: z7.literal("rate_limited") }),
+  z7.object({ kind: z7.literal("server_error") }),
+  z7.object({ kind: z7.literal("auth_expired") })
 ]);
 var USAGE_CAPPED = "usage_capped";
 var RATE_LIMITED = "rate_limited";
@@ -3110,64 +3152,89 @@ var NEGATED_CAP = /not (your|a) usage limit/g;
 var RATE_PATTERNS = [/rate[_ ]?limit/, /\b429\b/, /too many requests/];
 var BARE_LIMIT = /\blimit (reached|exceeded)\b/;
 
+// packages/agent-runtime/src/turn-diagnostics-normalize.ts
+function normalizeTurnResultReason(reason) {
+  const classified = decodeFailureReason(reason);
+  if (classified) return classified;
+  switch (reason) {
+    case "no_result":
+    case "no_terminal":
+      return { kind: "no_result" };
+    case "empty_result":
+      return { kind: "empty_result" };
+    case "empty_result_unverified":
+      return { kind: "empty_result_unverified" };
+    case "timeout_idle":
+      return { kind: "timeout_idle" };
+    case "timeout_total":
+      return { kind: "timeout_total" };
+    case "cancelled":
+      return { kind: "cancelled" };
+    case "skipped":
+      return { kind: "skipped" };
+    default:
+      return { kind: "runtime_error" };
+  }
+}
+
 // packages/agent-runtime/src/turn-request.ts
-import { z as z7 } from "zod";
-var contentBlockSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("text"), text: z7.string() }),
-  z7.object({
-    type: z7.literal("image"),
-    source: z7.object({ type: z7.literal("url"), url: z7.string() })
+import { z as z8 } from "zod";
+var contentBlockSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("text"), text: z8.string() }),
+  z8.object({
+    type: z8.literal("image"),
+    source: z8.object({ type: z8.literal("url"), url: z8.string() })
   }),
-  z7.object({
-    type: z7.literal("document"),
-    source: z7.object({ type: z7.literal("url"), url: z7.string() })
+  z8.object({
+    type: z8.literal("document"),
+    source: z8.object({ type: z8.literal("url"), url: z8.string() })
   })
 ]);
-var effortLevelSchema = z7.enum(["low", "medium", "high", "xhigh", "max"]);
-var resolvedRunConfigSchema = z7.object({
-  model: z7.string().nullable(),
+var effortLevelSchema = z8.enum(["low", "medium", "high", "xhigh", "max"]);
+var resolvedRunConfigSchema = z8.object({
+  model: z8.string().nullable(),
   effort: effortLevelSchema.optional(),
-  runtimeOptions: z7.record(z7.string(), z7.unknown()).optional()
+  runtimeOptions: z8.record(z8.string(), z8.unknown()).optional()
 });
-var resolvedMcpServerSchema = z7.union([
-  z7.object({
-    type: z7.literal("stdio").optional(),
-    command: z7.string(),
-    args: z7.array(z7.string()).optional(),
-    env: z7.record(z7.string(), z7.string()).optional()
+var resolvedMcpServerSchema = z8.union([
+  z8.object({
+    type: z8.literal("stdio").optional(),
+    command: z8.string(),
+    args: z8.array(z8.string()).optional(),
+    env: z8.record(z8.string(), z8.string()).optional()
   }),
-  z7.object({
-    type: z7.literal("http"),
-    url: z7.string(),
-    headers: z7.record(z7.string(), z7.string()).optional()
+  z8.object({
+    type: z8.literal("http"),
+    url: z8.string(),
+    headers: z8.record(z8.string(), z8.string()).optional()
   }),
-  z7.object({
-    type: z7.literal("sse"),
-    url: z7.string(),
-    headers: z7.record(z7.string(), z7.string()).optional()
+  z8.object({
+    type: z8.literal("sse"),
+    url: z8.string(),
+    headers: z8.record(z8.string(), z8.string()).optional()
   })
 ]);
-var resolvedMcpServersSchema = z7.record(z7.string(), resolvedMcpServerSchema);
-var hostInjectedServersSchema = z7.record(z7.string(), z7.unknown());
-var turnRequestSchema = z7.object({
+var resolvedMcpServersSchema = z8.record(z8.string(), resolvedMcpServerSchema);
+var hostInjectedServersSchema = z8.record(z8.string(), z8.unknown());
+var turnRequestSchema = z8.object({
   // Server-composed system prompt (core + capability prose + adapter addendum +
   // charter). One string to the adapter.
-  systemPrompt: z7.string(),
+  systemPrompt: z8.string(),
   // Server-composed per-turn user text (anchor reminder + the triggering message).
-  prompt: z7.string(),
+  prompt: z8.string(),
   // The multi-block user-message body (text + vision).
-  content: z7.array(contentBlockSchema),
+  content: z8.array(contentBlockSchema),
   // Portable-or-dialect run-config (above).
   config: resolvedRunConfigSchema,
   // Abstract capability grants; the adapter maps them to tool names.
   policy: hostPolicySchema,
   // Prior opaque session state, or null for a fresh session.
-  session: z7.string().nullable(),
+  session: z8.string().nullable(),
   // The cabane control-plane coordinates for this turn's MCP + post-back.
-  cabane: z7.object({
-    mcpUrl: z7.string(),
-    bearer: z7.string(),
-    activeConversationId: z7.string(),
+  cabane: z8.object({
+    mcpUrl: z8.string(),
+    bearer: z8.string(),
+    activeConversationId: z8.string(),
     // CT714: the scoped TURN-CONTROL MCP endpoint (`/api/turn-control`). The
     // EXTERNAL adapters (Codex / opencode) mount it by URL under the key
     // `cabane_companion` — using the same `bearer` (the turn token) and the same
@@ -3177,7 +3244,7 @@ var turnRequestSchema = z7.object({
     // claude-code ignores it (it mounts the in-process instance instead), and
     // every existing `cabane`-block fixture keeps parsing unchanged; the
     // companion always populates it (`build-options.ts`).
-    turnControlUrl: z7.string().optional(),
+    turnControlUrl: z8.string().optional(),
     // CT598: the workspace this turn runs in. The claude-code/opencode/codex
     // adapters never need it (they reach Cabane through the `cabane` MCP server,
     // which takes `workspaceId` as a per-tool arg the model supplies); the
@@ -3187,39 +3254,39 @@ var turnRequestSchema = z7.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: z7.string().optional(),
+    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: z7.enum(["code", "classic"]).optional()
+    workspaceToolSurface: z8.enum(["code", "classic"]).optional()
   }),
   // Machine-local resolution (host-filled): the checkout cwd, extra env from a
   // prepare hook, and the resolved user MCP servers.
-  local: z7.object({
-    cwd: z7.string().optional(),
-    env: z7.record(z7.string(), z7.string()).optional(),
+  local: z8.object({
+    cwd: z8.string().optional(),
+    env: z8.record(z8.string(), z8.string()).optional(),
     mcpServers: resolvedMcpServersSchema.optional(),
     // CT289: machine-local claude-code adapter knobs the operator sets on a
     // companion they run themselves — the auto-memory escape hatch. `autoMemory:
     // true` opts back into Claude Code's auto-memory (governed by the operator's
     // own `.claude/settings.json`); absent/false leaves the adapter's force-off
     // default in place (see `buildClaudeCodeOptions`).
-    claudeCode: z7.object({ autoMemory: z7.boolean().optional() }).optional()
+    claudeCode: z8.object({ autoMemory: z8.boolean().optional() }).optional()
   }),
   // Host-owned injected servers (host-filled) — e.g. the summon server.
-  extra: z7.object({
+  extra: z8.object({
     mcpServers: hostInjectedServersSchema
   })
 });
 
 // packages/agent-runtime/src/conformance.ts
-import { z as z8 } from "zod";
-var conformanceFixtureSchema = z8.object({
-  name: z8.string(),
+import { z as z9 } from "zod";
+var conformanceFixtureSchema = z9.object({
+  name: z9.string(),
   request: turnRequestSchema,
-  nativeStream: z8.array(z8.unknown()),
-  expected: z8.array(turnEventSchema)
+  nativeStream: z9.array(z9.unknown()),
+  expected: z9.array(turnEventSchema)
 });
 
 // packages/agent-runtime/src/transcript.ts
@@ -3439,6 +3506,7 @@ var TurnPump = class {
         if (evt.final) {
           this.emittedFinal = true;
           this.finalReplyBody = body;
+          this.emittedFinalSource = "runtime_text";
         } else {
           this.lastProgressBody = body;
         }
@@ -3477,6 +3545,7 @@ var TurnPump = class {
   lastProgressBody = null;
   // The turn's final reply text, captured for the dashboard feed / logging.
   finalReplyBody = null;
+  emittedFinalSource = "none";
   // CT11: each tool's persisted seq so the `done`/`error` frame republishes the
   // same seq the `start` row got (the host's upsert keeps the original seq).
   toolSeqByUseId = /* @__PURE__ */ new Map();
@@ -3499,6 +3568,7 @@ var TurnPump = class {
       await this.opts.commit.commitMessage({ body, kind: "final", seq });
       this.emittedFinal = true;
       this.finalReplyBody = body;
+      this.emittedFinalSource = this.lastProgressBody ? "progress_promotion" : "host_fallback";
     } catch (err) {
       this.opts.onError?.(err, "empty-final");
     }
@@ -3513,6 +3583,9 @@ var TurnPump = class {
   get replyBody() {
     return this.finalReplyBody;
   }
+  get finalSource() {
+    return this.emittedFinalSource;
+  }
 };
 
 // packages/agent-runtime/src/claude-code/index.ts
@@ -3534,7 +3607,7 @@ var CLAUDE_CODE_ADDENDUM = [
 ].join(" ");
 
 // packages/agent-runtime/src/claude-code/policy.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var HOST_FS_TOOLS = [
   // shell + local filesystem
   "Bash",
@@ -3584,18 +3657,18 @@ function withThinkingSummaries(thinking) {
   if (thinking.type === "disabled") return thinking;
   return { display: "summarized", ...thinking };
 }
-var claudeCodeDialectSchema = z9.object({
-  thinking: z9.discriminatedUnion("type", [
-    z9.object({
-      type: z9.literal("adaptive"),
-      display: z9.enum(["summarized", "omitted"]).optional()
+var claudeCodeDialectSchema = z10.object({
+  thinking: z10.discriminatedUnion("type", [
+    z10.object({
+      type: z10.literal("adaptive"),
+      display: z10.enum(["summarized", "omitted"]).optional()
     }),
-    z9.object({
-      type: z9.literal("enabled"),
-      budgetTokens: z9.number().int().positive().optional(),
-      display: z9.enum(["summarized", "omitted"]).optional()
+    z10.object({
+      type: z10.literal("enabled"),
+      budgetTokens: z10.number().int().positive().optional(),
+      display: z10.enum(["summarized", "omitted"]).optional()
     }),
-    z9.object({ type: z9.literal("disabled") })
+    z10.object({ type: z10.literal("disabled") })
   ]).optional()
 }).loose();
 function readThinking(runtimeOptions) {
@@ -4537,7 +4610,7 @@ function sealHeld(held, terminal) {
 }
 
 // packages/agent-runtime/src/opencode/policy.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var OPENCODE_HOST_TOOLS = [
   "bash",
   "edit",
@@ -4564,8 +4637,8 @@ function opencodeToolPolicy(policy) {
   deny(OPENCODE_UI_PROMPT_TOOLS);
   return { tools, allowAllHostTools: policy.hostFs };
 }
-var opencodeDialectSchema = z10.object({
-  agent: z10.string().min(1).optional()
+var opencodeDialectSchema = z11.object({
+  agent: z11.string().min(1).optional()
 }).loose();
 function readOpencodeDialect(runtimeOptions) {
   const parsed = opencodeDialectSchema.safeParse(runtimeOptions?.["opencode"] ?? {});
@@ -5575,7 +5648,7 @@ function sealHeld2(held, terminal) {
 }
 
 // packages/agent-runtime/src/codex/policy.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function codexToolPolicy(policy) {
   return policy.hostFs ? {
     sandboxMode: "danger-full-access",
@@ -5594,8 +5667,8 @@ function codexToolPolicy(policy) {
   };
 }
 var CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
-var codexDialectSchema = z11.object({
-  modelReasoningEffort: z11.enum(CODEX_REASONING_EFFORTS).optional()
+var codexDialectSchema = z12.object({
+  modelReasoningEffort: z12.enum(CODEX_REASONING_EFFORTS).optional()
 }).loose();
 function readCodexDialect(runtimeOptions) {
   const parsed = codexDialectSchema.safeParse(runtimeOptions?.["codex"] ?? {});
@@ -6524,12 +6597,12 @@ var ConnectorHealthStore = class {
 };
 
 // src/dispatcher.ts
-import { randomUUID } from "crypto";
+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
-import { z as z12 } from "zod";
+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}`;
@@ -6577,7 +6650,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
         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.",
         {
-          agentId: z12.string().uuid().describe(
+          agentId: z13.string().uuid().describe(
             "The peer agent to summon \u2014 a workspace agent id, from your turn context's roster."
           )
         },
@@ -6594,7 +6667,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           SKIP_TURN_TOOL,
           `End your current turn WITHOUT posting a reply. Call this when you've been dispatched but the message genuinely doesn't need a response from you \u2014 a thanks/aside, a question already answered, chatter outside your lane, or a pile-on where someone else has it. Your turn ends silently: no message bubble is posted. The \`reason\` is a short free-text note for telemetry (e.g. "already answered by cabane", "thanks, nothing to add"). Prefer this over posting a low-value "ok!"/"got it" reply. Don't also write a reply when you skip \u2014 skipping IS the whole turn.`,
           {
-            reason: z12.string().min(1).max(500).describe("Short reason you are declining \u2014 used for telemetry/debugging.")
+            reason: z13.string().min(1).max(500).describe("Short reason you are declining \u2014 used for telemetry/debugging.")
           },
           async (args) => {
             skipState.skipped = true;
@@ -6611,23 +6684,23 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           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.",
           {
-            targetUserId: z12.string().uuid().describe(
+            targetUserId: z13.string().uuid().describe(
               "The workspace member (human) to ask \u2014 a user id, from your turn context's roster."
             ),
-            question: z12.string().min(1).max(400).optional().describe(
+            question: z13.string().min(1).max(400).optional().describe(
               "SINGLE-question form: a short body \u2014 one or two sentences of framing the headline can't hold. NOT a report (capped, inline markdown only). Provide EITHER this or `questions`, not both. Put the crisp one-sentence question in `headline`."
             ),
-            headline: z12.string().min(1).max(120).optional().describe(
+            headline: z13.string().min(1).max(120).optional().describe(
               'SINGLE-question form: the question itself as ONE clear, capitalized sentence ending in `?` ("Do we go to prod?"). What the human reads first in the inbox and the chip \u2014 one scannable question, no elaboration (that goes in `question`). Strongly encouraged.'
             ),
-            options: z12.array(z12.string().min(1).max(200)).min(2).max(4).optional().describe("SINGLE-question form: optional 2\u20134 suggested one-click answers."),
-            questions: z12.array(
-              z12.object({
-                headline: z12.string().min(1).max(120).describe(
+            options: z13.array(z13.string().min(1).max(200)).min(2).max(4).optional().describe("SINGLE-question form: optional 2\u20134 suggested one-click answers."),
+            questions: z13.array(
+              z13.object({
+                headline: z13.string().min(1).max(120).describe(
                   'The one-sentence question ("Do we go to prod?") \u2014 required for each item.'
                 ),
-                body: z12.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
-                options: z12.array(z12.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
+                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."
@@ -6684,13 +6757,13 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           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.",
           {
-            prompt: z12.string().min(1).max(65536).describe(
+            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)."
             ),
-            agentId: z12.string().uuid().optional().describe(
+            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."
             ),
-            title: z12.string().max(200).optional().describe("Optional title for the child thread (result chips link it).")
+            title: z13.string().max(200).optional().describe("Optional title for the child thread (result chips link it).")
           },
           async (args) => {
             const result = await subAgentCreate(args);
@@ -6720,13 +6793,13 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           WAKE_ME_TOOL,
           "Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for \"wait until X\": when the thing you need hasn't happened yet (a PR isn't merged, a human hasn't answered), arm a wake, end your turn, and you're woken later to CHECK \u2014 read the workspace, and either act or re-arm. Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a known reset time. A speculative far-future check-in you invented yourself is the one thing not to arm: if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it \u2014 finish now, or raise an `ask`. Pass EXACTLY ONE of `afterSeconds` (a relative delay \u2014 `300` for five minutes) or `at` (an absolute ISO-8601 timestamp WITH a zone, e.g. `2026-07-16T09:00:00-07:00` \u2014 YOU compute it from a phrase like \"tomorrow morning\"; the system never parses natural-language time). `note` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check (\"check whether CT441 merged yet\"). The wake is armed when your turn SETTLES, not now, so the delay counts from the turn ending; one wake per turn (last call wins). This is the sanctioned way to schedule your own continuation \u2014 the ONLY one; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you'll be steered to raise an `ask` to the human instead. If a wake can't be armed you're re-dispatched with a note explaining why \u2014 never a silent drop.",
           {
-            afterSeconds: z12.number().int().positive().optional().describe(
+            afterSeconds: z13.number().int().positive().optional().describe(
               "Relative delay in seconds from when this turn ends (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side."
             ),
-            at: z12.string().datetime({ offset: true }).optional().describe(
+            at: z13.string().datetime({ offset: true }).optional().describe(
               "Absolute ISO-8601 timestamp WITH a zone (`Z` or `\xB1HH:MM`), e.g. `2026-07-16T09:00:00-07:00`. YOU compute it from a natural-language phrase using the current datetime in your turn context. Provide EITHER this or `afterSeconds`, not both."
             ),
-            note: z12.string().min(1).max(2e3).describe(
+            note: z13.string().min(1).max(2e3).describe(
               'A note to your future self \u2014 becomes the body of the wake message that re-dispatches you. Write the condition to re-check ("check whether the PR merged").'
             )
           },
@@ -6916,12 +6989,12 @@ function clearPrepared(workspaceId, conversationId, agentId) {
 // src/secrets.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 import { join as join12 } from "path";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
   return join12(cabaneDir(), "secrets.json");
 }
-var secretStoreSchema = z13.record(z13.string(), z13.string());
+var secretStoreSchema = z14.record(z14.string(), z14.string());
 function loadSecretStore() {
   const path = secretsPath();
   if (!existsSync9(path)) return makeStore({});
@@ -7005,12 +7078,13 @@ function resolveMcpSecrets(mcpServers, store) {
 }
 
 // src/transcript-writer.ts
-import { appendFileSync, chmodSync as chmodSync3, mkdirSync as mkdirSync9, readdirSync, rmSync as rmSync6 } from "fs";
-import { join as join13 } from "path";
+import { appendFileSync, chmodSync as chmodSync3, copyFileSync, mkdirSync as mkdirSync9, readdirSync, rmSync as rmSync6 } from "fs";
+import { basename, dirname as dirname5, join as join13 } from "path";
 function transcriptsDir() {
   return join13(cabaneDir(), "transcripts");
 }
 var RETAIN = 200;
+var ANOMALY_RETAIN = 50;
 var TranscriptWriter = class {
   path;
   broken = false;
@@ -7038,6 +7112,25 @@ var TranscriptWriter = class {
   close(outcome) {
     this.line({ type: "_outcome", ...outcome });
   }
+  // CT1145: keep an independent copy of an empty successful envelope after the
+  // footer has landed. The ordinary 200-file FIFO keeps rotating as before;
+  // this bucket retains the newest 50 anomalies regardless of ordinary traffic.
+  // Best-effort like every other transcript operation: observability can never
+  // fail the turn.
+  preserveAnomaly() {
+    if (this.broken) return;
+    try {
+      const dir2 = join13(dirname5(this.path), "anomalies");
+      mkdirSync9(dir2, { recursive: true, mode: 448 });
+      chmodSync3(dir2, 448);
+      const target = join13(dir2, basename(this.path));
+      copyFileSync(this.path, target);
+      chmodSync3(target, 384);
+      pruneOld(dir2, ANOMALY_RETAIN);
+    } catch (err) {
+      this.fail(err);
+    }
+  }
   line(obj) {
     if (this.broken) return;
     try {
@@ -7195,6 +7288,9 @@ var TurnCommitter = class {
   get replyBody() {
     return this.pump.replyBody;
   }
+  get finalSource() {
+    return this.pump.finalSource;
+  }
   // 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.
@@ -8058,6 +8154,16 @@ ${reason}`,
     let turnUsage;
     let turnResolvedModel;
     let turnResolvedConfig;
+    const eventCounts = {
+      session: 0,
+      text: 0,
+      thinking: 0,
+      tool: 0,
+      result: 0
+    };
+    let runtimeResultKind = null;
+    let latestSessionState = request.session;
+    let settledDiagnostics = null;
     const committer = new TurnCommitter({
       api: this.opts.api,
       workspaceId,
@@ -8153,6 +8259,7 @@ ${reason}`,
     try {
       for await (const event of adapter.runTurn(request, abortController.signal)) {
         transcript2?.write(event);
+        eventCounts[event.type] += 1;
         armIdle();
         if (abortController.signal.aborted) {
           turnLog.info("dispatcher: aborted mid-turn");
@@ -8161,6 +8268,7 @@ ${reason}`,
           break;
         }
         if (event.type === "session") {
+          latestSessionState = event.state;
           if (event.degraded) sessionDegraded = true;
           if (!sessionWritten) {
             sessionWritten = true;
@@ -8199,6 +8307,7 @@ ${reason}`,
           turnUsage = event.usage;
           turnResolvedModel = event.resolvedModel;
           turnResolvedConfig = event.resolvedConfig;
+          runtimeResultKind = event.ok ? "success" : event.reason === "no_terminal" ? "no_terminal" : "error";
         } else if (event.type === "text" && skipState.skipped) {
         } else {
           if (event.type === "text" && event.terminal) {
@@ -8321,6 +8430,34 @@ ${reason}`,
         body.sessionWriteRejected = true;
         this.sessionWriteNotified.add(key);
       }
+      const outcome = skipState.skipped ? "skipped" : userCancelled ? "cancelled" : okResult ? "success" : "failure";
+      const noContentEvents = eventCounts.text === 0 && eventCounts.thinking === 0 && eventCounts.tool === 0;
+      const emptySuccessfulEnvelope = outcome === "success" && eventCounts.result > 0 && noContentEvents;
+      const diagnosticReason = outcome === "skipped" ? { kind: "skipped" } : outcome === "cancelled" ? { kind: "cancelled" } : emptySuccessfulEnvelope ? turnUsage?.inputTokens === 0 && turnUsage.outputTokens === 0 ? { kind: "empty_result" } : { kind: "empty_result_unverified" } : outcome === "failure" ? normalizeTurnResultReason(resultReason) : null;
+      settledDiagnostics = {
+        outcome,
+        resultReason: diagnosticReason,
+        sessionMode: sessionDegraded ? "degraded" : request.session ? "resumed" : "fresh",
+        sessionFingerprint: fingerprintSessionState(latestSessionState),
+        eventCounts,
+        runtimeResultKind,
+        finalSource: outcome === "skipped" || outcome === "cancelled" ? "marker" : committer.finalSource
+      };
+      body.diagnostics = settledDiagnostics;
+      if (diagnosticReason && !["usage_capped", "rate_limited", "auth_expired", "cancelled", "skipped"].includes(
+        diagnosticReason.kind
+      )) {
+        turnLog.warn(
+          {
+            turnId,
+            conversationId: payload.conversationId,
+            agentId: payload.agentId,
+            runtime: turnRuntime,
+            diagnostics: settledDiagnostics
+          },
+          "dispatcher: anomalous turn settled"
+        );
+      }
       this.opts.connectorHealth?.recordSettle(turnRuntime, {
         ok: okResult,
         errorReason: body.errorReason ?? null
@@ -8353,6 +8490,9 @@ ${reason}`,
       if (!okResult && resultReason !== "cancelled") {
         turnLog.info(`turn failed \u2014 full transcript: ${transcript2.path}`);
       }
+      if (settledDiagnostics?.resultReason?.kind === "empty_result" || settledDiagnostics?.resultReason?.kind === "empty_result_unverified") {
+        transcript2.preserveAnomaly();
+      }
     }
     if (okResult) {
       turnLog.debug({ durationMs }, "dispatcher: turn end (ok)");
@@ -8390,6 +8530,17 @@ ${reason}`,
     return true;
   }
 };
+function fingerprintSessionState(state) {
+  if (!state) return null;
+  let opaqueId = state;
+  try {
+    const parsed = JSON.parse(state);
+    const candidate = parsed.sdkSessionId ?? parsed.threadId ?? parsed.sessionId;
+    if (typeof candidate === "string" && candidate.length > 0) opaqueId = candidate;
+  } catch {
+  }
+  return createHash2("sha256").update(opaqueId).digest("hex").slice(0, 16);
+}
 
 // src/opencode-models.ts
 var OPENCODE_RUNTIME = "opencode";
@@ -8574,43 +8725,43 @@ var Outbox = class {
 };
 
 // src/run-config.ts
-import { z as z14 } from "zod";
-var mcpStdioServerSchema = z14.object({
-  type: z14.literal("stdio").optional(),
-  command: z14.string().min(1),
-  args: z14.array(z14.string()).optional(),
-  env: z14.record(z14.string(), z14.string()).optional()
+import { z as z15 } from "zod";
+var mcpStdioServerSchema = z15.object({
+  type: z15.literal("stdio").optional(),
+  command: z15.string().min(1),
+  args: z15.array(z15.string()).optional(),
+  env: z15.record(z15.string(), z15.string()).optional()
 });
-var mcpHttpServerSchema = z14.object({
-  type: z14.literal("http"),
-  url: z14.string().url(),
-  headers: z14.record(z14.string(), z14.string()).optional()
+var mcpHttpServerSchema = z15.object({
+  type: z15.literal("http"),
+  url: z15.string().url(),
+  headers: z15.record(z15.string(), z15.string()).optional()
 });
-var mcpSseServerSchema = z14.object({
-  type: z14.literal("sse"),
-  url: z14.string().url(),
-  headers: z14.record(z14.string(), z14.string()).optional()
+var mcpSseServerSchema = z15.object({
+  type: z15.literal("sse"),
+  url: z15.string().url(),
+  headers: z15.record(z15.string(), z15.string()).optional()
 });
-var mcpServerDefSchema = z14.union([
+var mcpServerDefSchema = z15.union([
   mcpHttpServerSchema,
   mcpSseServerSchema,
   mcpStdioServerSchema
 ]);
-var thinkingConfigSchema = z14.discriminatedUnion("type", [
-  z14.object({ type: z14.literal("adaptive") }),
-  z14.object({ type: z14.literal("enabled"), budgetTokens: z14.number().int().positive().optional() }),
-  z14.object({ type: z14.literal("disabled") })
+var thinkingConfigSchema = z15.discriminatedUnion("type", [
+  z15.object({ type: z15.literal("adaptive") }),
+  z15.object({ type: z15.literal("enabled"), budgetTokens: z15.number().int().positive().optional() }),
+  z15.object({ type: z15.literal("disabled") })
 ]);
-var effortSchema = z14.enum(["low", "medium", "high", "xhigh", "max"]);
-var runConfigSchema = z14.object({
+var effortSchema = z15.enum(["low", "medium", "high", "xhigh", "max"]);
+var runConfigSchema = z15.object({
   // CT788: the host-access binary replaced the `assistant`/`coding`/`custom` mode
   // trio + its custom tool lists — `true` grants the host filesystem/shell, absent
   // is the locked surface. Kept in lockstep with `@cabane/shared`'s
   // `agentRunConfigSchema` (independent zod, forward-compatible: unknown keys are
   // stripped, so an older companion riding a newer server never rejects the config).
-  hostAccess: z14.boolean().optional(),
-  mcpServers: z14.record(z14.string(), mcpServerDefSchema).optional(),
-  model: z14.string().min(1).optional(),
+  hostAccess: z15.boolean().optional(),
+  mcpServers: z15.record(z15.string(), mcpServerDefSchema).optional(),
+  model: z15.string().min(1).optional(),
   thinking: thinkingConfigSchema.optional(),
   effort: effortSchema.optional()
 });