zelari-code 1.41.0 → 1.43.0

package/dist/cli/main.bundled.js

@@ -1468,27 +1468,27 @@ function readStore() {
   }
   return { providers: {} };
 }
-function writeStore(store3) {
+function writeStore(store4) {
   const file2 = getKeyStorePath();
   mkdirSync2(path3.dirname(file2), { recursive: true });
-  writeFileSync2(file2, JSON.stringify(store3, null, 2), { encoding: "utf-8", mode: 384 });
+  writeFileSync2(file2, JSON.stringify(store4, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function setApiKey(providerId, key) {
-  const store3 = readStore();
-  store3.providers[providerId] = { apiKey: key };
-  writeStore(store3);
+  const store4 = readStore();
+  store4.providers[providerId] = { apiKey: key };
+  writeStore(store4);
 }
 function clearApiKey(providerId) {
-  const store3 = readStore();
-  delete store3.providers[providerId];
-  writeStore(store3);
+  const store4 = readStore();
+  delete store4.providers[providerId];
+  writeStore(store4);
 }
 function getStoredApiKey(providerId) {
-  const store3 = readStore();
-  return store3.providers[providerId]?.apiKey ?? null;
+  const store4 = readStore();
+  return store4.providers[providerId]?.apiKey ?? null;
 }
 function setOAuthToken(providerId, token) {
-  const store3 = readStore();
+  const store4 = readStore();
   const entry = { apiKey: token.apiKey };
   if (typeof token.expiresAt === "number" && Number.isFinite(token.expiresAt)) {
     entry.expiresAt = token.expiresAt;
@@ -1502,12 +1502,12 @@ function setOAuthToken(providerId, token) {
   if (typeof token.idToken === "string" && token.idToken.length > 0) {
     entry.idToken = token.idToken;
   }
-  store3.providers[providerId] = entry;
-  writeStore(store3);
+  store4.providers[providerId] = entry;
+  writeStore(store4);
 }
 function getOAuthToken(providerId) {
-  const store3 = readStore();
-  return store3.providers[providerId] ?? null;
+  const store4 = readStore();
+  return store4.providers[providerId] ?? null;
 }
 function resolveApiKey(providerId) {
   const spec = getProviderSpec(providerId);
@@ -1566,8 +1566,8 @@ async function forceRefreshOAuth(providerId, options = {}) {
 function readStoreDirect() {
   return readStore();
 }
-function writeStoreDirect(store3) {
-  writeStore(store3);
+function writeStoreDirect(store4) {
+  writeStore(store4);
 }
 function maskKey(key) {
   if (key.length <= 12) return "****";
@@ -21063,6 +21063,12 @@ function isBrainMemberCostEvent(e) {
 function isBrainCouncilModeEvent(e) {
   return e.type === "council_mode";
 }
+function isBrainTaskUpdateEvent(e) {
+  return e.type === "task_update";
+}
+function isBrainTaskSnapshotEvent(e) {
+  return e.type === "task_snapshot";
+}
 function createBrainEvent(type, sessionId, data) {
   return {
     type,
@@ -21214,6 +21220,79 @@ var init_types = __esm({
   }
 });
 
+// packages/core/dist/core/requestSnapshot.js
+import { createHash as createHash2 } from "node:crypto";
+function stableStringify(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) {
+    const items = value.map((v) => stableStringify(v));
+    return `[${items.join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+  const parts = keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+  return `{${parts.join(",")}}`;
+}
+function sha256Hex(input) {
+  return createHash2("sha256").update(input, "utf8").digest("hex").slice(0, 32);
+}
+function cloneMessages(messages) {
+  return structuredClone(messages);
+}
+function canonicalTools(tools) {
+  return [...tools].sort((a, b) => a.name.localeCompare(b.name));
+}
+function createRoutedRequestSnapshot(params) {
+  let split = 0;
+  while (split < params.messages.length && params.messages[split].role === "system") {
+    split++;
+  }
+  const systemMessages = cloneMessages(params.messages.slice(0, split));
+  const conversation = cloneMessages(params.messages.slice(split));
+  const tools = canonicalTools(params.tools).map((t) => structuredClone(t));
+  const header = stableStringify({
+    provider: params.provider,
+    model: params.model,
+    systemMessages,
+    tools
+  });
+  const request = stableStringify({
+    provider: params.provider,
+    model: params.model,
+    systemMessages,
+    tools,
+    conversation
+  });
+  return {
+    provider: params.provider,
+    model: params.model,
+    systemMessages,
+    conversation,
+    tools,
+    headerFingerprint: sha256Hex(header),
+    requestFingerprint: sha256Hex(request),
+    createdAt: Date.now()
+  };
+}
+function compareReplayPrefix(snapshot, messages) {
+  const base = snapshot.conversation;
+  const n = Math.min(base.length, messages.length);
+  let matching = 0;
+  for (let i = 0; i < n; i++) {
+    if (stableStringify(base[i]) !== stableStringify(messages[i])) {
+      return { exact: false, matchingMessages: matching, mismatchIndex: i };
+    }
+    matching++;
+  }
+  return { exact: true, matchingMessages: matching };
+}
+var init_requestSnapshot = __esm({
+  "packages/core/dist/core/requestSnapshot.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/core/textLoopDetect.js
 function isStatusTheaterUnit(unit) {
   const u = normalizeLoopUnit(unit).toLowerCase();
@@ -21412,10 +21491,10 @@ var init_textLoopDetect = __esm({
 
 // packages/core/dist/core/AgentHarness.js
 function hashToolCall(toolName, args) {
-  const canonical = stableStringify(args);
+  const canonical = stableStringify2(args);
   return `${toolName}::${canonical}`;
 }
-function stableStringify(value) {
+function stableStringify2(value) {
   return JSON.stringify(value, (_k, v) => {
     if (v && typeof v === "object" && !Array.isArray(v)) {
       const sorted = {};
@@ -21648,6 +21727,7 @@ var init_AgentHarness = __esm({
   "packages/core/dist/core/AgentHarness.js"() {
     "use strict";
     init_events();
+    init_requestSnapshot();
     init_textLoopDetect();
     init_textLoopDetect();
     AgentHarness = class {
@@ -22084,6 +22164,23 @@ ${shared2.content}`,
         yield agentEnd;
         this.activeController = null;
       }
+      /**
+       * v1.36.0: capture a deterministic snapshot of the routed request just
+       * before it goes out. Never throws into the request path.
+       */
+      emitSnapshot(tools, generation) {
+        if (!this.config.onRequestSnapshot)
+          return;
+        try {
+          this.config.onRequestSnapshot(createRoutedRequestSnapshot({
+            messages: this.config.messages,
+            model: this.config.model,
+            provider: this.config.provider,
+            tools
+          }), generation);
+        } catch {
+        }
+      }
       /**
        * Run a single provider turn for the current message buffer.
        * Streams from the provider, dispatches deltas to events, executes
@@ -22101,6 +22198,7 @@ ${shared2.content}`,
        */
       async *runSingleTurn(messageId, finishRef, usageRef) {
         try {
+          this.emitSnapshot(this.config.tools);
           const stream = this.config.providerStream({
             messages: this.config.messages,
             model: this.config.model,
@@ -22391,6 +22489,7 @@ ${cached2}`
         const finishRef = { value: "stop" };
         const usageRef = { value: null };
         try {
+          this.emitSnapshot([]);
           const stream = this.config.providerStream({
             messages: this.config.messages,
             model: this.config.model,
@@ -22971,7 +23070,10 @@ __export(harness_exports, {
   SessionJsonlWriter: () => SessionJsonlWriter,
   TEXT_LOOP_RECOVERY_SYSTEM: () => TEXT_LOOP_RECOVERY_SYSTEM,
   TEXT_LOOP_RECOVERY_USER_PROMPT: () => TEXT_LOOP_RECOVERY_USER_PROMPT,
+  canonicalTools: () => canonicalTools,
   collapseLoopedAssistantText: () => collapseLoopedAssistantText,
+  compareReplayPrefix: () => compareReplayPrefix,
+  createRoutedRequestSnapshot: () => createRoutedRequestSnapshot,
   detectAssistantTextLoop: () => detectAssistantTextLoop,
   detectAssistantTextLoopWindow: () => detectAssistantTextLoopWindow,
   hashToolCall: () => hashToolCall,
@@ -22983,6 +23085,8 @@ __export(harness_exports, {
   parseMinimaxStyleToolCalls: () => parseMinimaxStyleToolCalls,
   parseTextToolCalls: () => parseTextToolCalls,
   readSession: () => readSession,
+  sha256Hex: () => sha256Hex,
+  stableStringify: () => stableStringify,
   toolMatches: () => toolMatches,
   wrapLegacyStream: () => wrapLegacyStream
 });
@@ -22991,6 +23095,7 @@ var init_harness = __esm({
     "use strict";
     init_AgentHarness();
     init_providerStream();
+    init_requestSnapshot();
     init_sessionJsonl();
     init_hooks();
   }
@@ -27902,6 +28007,7 @@ __export(dist_exports, {
   buildSystemPrompt: () => buildSystemPrompt,
   buildSystemPromptSplit: () => buildSystemPromptSplit,
   canRunParallel: () => canRunParallel,
+  canonicalTools: () => canonicalTools,
   captureFailure: () => captureFailure,
   checkImplementationCompletion: () => checkImplementationCompletion,
   checkImplementationDelivery: () => checkImplementationDelivery,
@@ -27913,6 +28019,7 @@ __export(dist_exports, {
   clearCustomTools: () => clearCustomTools,
   cliToolToEnhanced: () => cliToolToEnhanced,
   collapseLoopedAssistantText: () => collapseLoopedAssistantText,
+  compareReplayPrefix: () => compareReplayPrefix,
   computeAgentSkills: () => computeAgentSkills,
   computeAgentTools: () => computeAgentTools,
   councilModeBanner: () => councilModeBanner,
@@ -27922,6 +28029,7 @@ __export(dist_exports, {
   createBrainEvent: () => createBrainEvent,
   createDefaultSystemPromptConfig: () => createDefaultSystemPromptConfig,
   createGraph: () => createGraph,
+  createRoutedRequestSnapshot: () => createRoutedRequestSnapshot,
   defaultPersonaParse: () => defaultPersonaParse,
   detectAssistantTextLoop: () => detectAssistantTextLoop,
   detectAssistantTextLoopWindow: () => detectAssistantTextLoopWindow,
@@ -27971,6 +28079,8 @@ __export(dist_exports, {
   isBrainMessageStartEvent: () => isBrainMessageStartEvent,
   isBrainQueueUpdateEvent: () => isBrainQueueUpdateEvent,
   isBrainSessionCompactedEvent: () => isBrainSessionCompactedEvent,
+  isBrainTaskSnapshotEvent: () => isBrainTaskSnapshotEvent,
+  isBrainTaskUpdateEvent: () => isBrainTaskUpdateEvent,
   isBrainThinkingDeltaEvent: () => isBrainThinkingDeltaEvent,
   isBrainToolExecutionEndEvent: () => isBrainToolExecutionEndEvent,
   isBrainToolExecutionStartEvent: () => isBrainToolExecutionStartEvent,
@@ -28038,9 +28148,11 @@ __export(dist_exports, {
   scrubProprietaryLeak: () => scrubProprietaryLeak,
   selectParallelWave: () => selectParallelWave,
   setWorkspaceStubs: () => setWorkspaceStubs,
+  sha256Hex: () => sha256Hex,
   shouldRetryMember: () => shouldRetryMember,
   slugify: () => slugify2,
   specificityFromAssumptions: () => specificityFromAssumptions,
+  stableStringify: () => stableStringify,
   stripClarificationProtocol: () => stripClarificationProtocol,
   swapMembers: () => swapMembers,
   systemMessagesFromSplit: () => systemMessagesFromSplit,
@@ -28403,6 +28515,7 @@ function openaiCompatibleProvider(config2) {
       if (cacheable) messageMappingCache.set(m, mapped);
       return mapped;
     });
+    const generation = params.generation;
     const body = {
       // Use `params.model` (per-call override from AgentHarness, e.g. for
       // `agentModels` config) rather than the closed-over `config.model`
@@ -28410,7 +28523,7 @@ function openaiCompatibleProvider(config2) {
       model: params.model,
       messages,
       stream: true,
-      temperature: 0.7,
+      temperature: generation?.temperature ?? 0.7,
       // Task G.4.2 — request the provider to send real token usage in
       // the final chunk (gated by `stream_options.include_usage` on the
       // OpenAI-compatible API). Providers that don't honor this (some
@@ -28418,6 +28531,9 @@ function openaiCompatibleProvider(config2) {
       // the harness will fall back to the ~4-char/token approximation.
       stream_options: { include_usage: true }
     };
+    if (typeof generation?.maxTokens === "number" && generation.maxTokens > 0) {
+      body.max_tokens = generation.maxTokens;
+    }
     const thinkingSpec = config2.thinking ?? "auto";
     if (config2.providerId === "deepseek" && thinkingSpec === "auto") {
       const thinking = resolveDeepSeekThinking();
@@ -29312,7 +29428,7 @@ var init_resolveStream = __esm({
 });
 
 // packages/core/dist/core/tools/toolOutputSpill.js
-import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync11 } from "node:fs";
 import { homedir as homedir3, tmpdir } from "node:os";
 import { join as join11 } from "node:path";
@@ -29342,7 +29458,7 @@ function spillToolOutput(fullText, meta3) {
     if (!existsSync12(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
-    const hash3 = createHash2("sha256").update(fullText).digest("hex").slice(0, 12);
+    const hash3 = createHash3("sha256").update(fullText).digest("hex").slice(0, 12);
     const stamp = Date.now().toString(36);
     const rnd = randomBytes2(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
@@ -30918,6 +31034,771 @@ var init_todoTools = __esm({
   }
 });
 
+// src/cli/workspace/paths.ts
+import {
+  mkdirSync as mkdirSync10,
+  writeFileSync as writeFileSync12,
+  existsSync as existsSync17,
+  accessSync,
+  constants,
+  realpathSync
+} from "node:fs";
+import { join as join13, basename } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { createHash as createHash4 } from "node:crypto";
+function resolveWorkspaceRoot(projectRoot = process.cwd()) {
+  const candidates = [
+    join13(projectRoot, ".zelari"),
+    join13(homedir5(), ".zelari-code", "workspace", hashProject(projectRoot))
+  ];
+  for (const candidate of candidates) {
+    if (isWritableDir(projectRoot) || candidate !== candidates[0]) {
+      ensureWorkspaceDir(candidate);
+      return candidate;
+    }
+  }
+  ensureWorkspaceDir(candidates[0]);
+  return candidates[0];
+}
+function hashProject(projectPath) {
+  return createHash4("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+}
+function isWritableDir(dir) {
+  try {
+    if (!existsSync17(dir)) return false;
+    accessSync(dir, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureWorkspaceDir(workspaceDir) {
+  mkdirSync10(workspaceDir, { recursive: true });
+  if (workspaceDir.endsWith("/.zelari") && existsSync17(join13(workspaceDir, "..", ".git"))) {
+    const gitignorePath = join13(workspaceDir, ".gitignore");
+    if (!existsSync17(gitignorePath)) {
+      writeFileSync12(gitignorePath, "*\n!.gitignore\n");
+    }
+  }
+}
+function workspaceFile(rootDir, kind) {
+  switch (kind) {
+    case "plan":
+      return join13(rootDir, "plan.md");
+    case "risks":
+      return join13(rootDir, "risks.md");
+    case "index":
+      return join13(rootDir, "workspace.json");
+  }
+}
+function workspaceArtifact(rootDir, subdir, slug) {
+  return join13(rootDir, subdir, `${slug}.md`);
+}
+function projectName(projectRoot = process.cwd()) {
+  return basename(realpathSync(projectRoot));
+}
+var init_paths2 = __esm({
+  "src/cli/workspace/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/workspace/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  Storage: () => Storage,
+  parseFrontmatter: () => parseFrontmatter,
+  parseYaml: () => parseYaml,
+  serializeFrontmatter: () => serializeFrontmatter,
+  serializeYaml: () => serializeYaml,
+  workspaceMutex: () => workspaceMutex
+});
+import {
+  readFileSync as readFileSync16,
+  writeFileSync as writeFileSync13,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync11,
+  readdirSync as readdirSync4,
+  renameSync as renameSync2
+} from "node:fs";
+import { dirname as dirname2, join as join14 } from "node:path";
+function parseFrontmatter(md) {
+  const m = FRONTMATTER_RE.exec(md);
+  if (!m) return { meta: {}, body: md };
+  const meta3 = parseYaml(m[1]);
+  const body = m[2];
+  return { meta: meta3, body };
+}
+function serializeFrontmatter(meta3, body) {
+  const yamlStr = serializeYaml(meta3);
+  return `---
+${yamlStr}
+---
+${body}`;
+}
+function parseYaml(input) {
+  const lines = input.split(/\r?\n/);
+  const ctx = { lines, i: 0 };
+  return parseNode(ctx, 0);
+}
+function parseNode(ctx, indent) {
+  while (ctx.i < ctx.lines.length) {
+    const line2 = ctx.lines[ctx.i];
+    if (line2.trim() === "" || line2.trim().startsWith("#")) {
+      ctx.i++;
+      continue;
+    }
+    break;
+  }
+  if (ctx.i >= ctx.lines.length) return null;
+  const line = ctx.lines[ctx.i];
+  const lineIndent = countIndent(line);
+  if (/^\s*-\s+/.test(line)) {
+    return parseBlockSequence(ctx, indent);
+  }
+  if (/^\s*\[.*\]\s*$/.test(line)) {
+    const flow = line.trim().replace(/^\[/, "").replace(/\]$/, "");
+    return parseFlowSequence(flow);
+  }
+  if (/^\s*\{.*\}\s*$/.test(line)) {
+    const flow = line.trim().replace(/^\{/, "").replace(/\}$/, "");
+    return parseFlowMap(flow);
+  }
+  return parseBlockMap(ctx, indent);
+}
+function parseBlockMap(ctx, indent) {
+  const out = {};
+  while (ctx.i < ctx.lines.length) {
+    const line = ctx.lines[ctx.i];
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      ctx.i++;
+      continue;
+    }
+    const lineIndent = countIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) {
+      ctx.i++;
+      continue;
+    }
+    const m = /^([^:]+):\s*(.*)$/.exec(line);
+    if (!m) {
+      ctx.i++;
+      continue;
+    }
+    const key = m[1].trim();
+    const valuePart = m[2].trim();
+    if (valuePart === "" || valuePart === "|" || valuePart === ">") {
+      ctx.i++;
+      const nested = parseNode(ctx, indent + 2);
+      out[key] = nested;
+    } else {
+      if (valuePart.startsWith("[")) {
+        out[key] = parseFlowSequence(stripFlow(valuePart, "[", "]"));
+      } else if (valuePart.startsWith("{")) {
+        out[key] = parseFlowMap(stripFlow(valuePart, "{", "}"));
+      } else {
+        out[key] = parseScalar(valuePart);
+      }
+      ctx.i++;
+    }
+  }
+  return out;
+}
+function parseBlockSequence(ctx, indent) {
+  const out = [];
+  while (ctx.i < ctx.lines.length) {
+    const line = ctx.lines[ctx.i];
+    if (line.trim() === "") {
+      ctx.i++;
+      continue;
+    }
+    const lineIndent = countIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) break;
+    const m = /^-\s*(.*)$/.exec(line);
+    if (!m) break;
+    const rest = m[1];
+    if (rest === "") {
+      ctx.i++;
+      out.push(parseNode(ctx, indent + 2));
+    } else if (rest.startsWith("[") || rest.startsWith("{")) {
+      let buffer = rest;
+      let depthSq = (buffer.match(/\[/g) || []).length - (buffer.match(/\]/g) || []).length;
+      let depthCu = (buffer.match(/\{/g) || []).length - (buffer.match(/\}/g) || []).length;
+      while ((depthSq > 0 || depthCu > 0) && ctx.i + 1 < ctx.lines.length) {
+        ctx.i++;
+        const next = ctx.lines[ctx.i].trim();
+        buffer += " " + next;
+        depthSq = (buffer.match(/\[/g) || []).length - (buffer.match(/\]/g) || []).length;
+        depthCu = (buffer.match(/\{/g) || []).length - (buffer.match(/\}/g) || []).length;
+      }
+      if (buffer.startsWith("[")) {
+        out.push(parseFlowSequence(buffer.slice(1).replace(/\]$/, "")));
+      } else {
+        out.push(parseFlowMap(buffer.slice(1).replace(/\}$/, "")));
+      }
+      ctx.i++;
+    } else if (rest.includes(":")) {
+      ctx.i++;
+      const mapCtx = { lines: [" ".repeat(indent + 2) + rest, ...ctx.lines.slice(ctx.i)], i: 0 };
+      const val = parseBlockMap(mapCtx, indent + 2);
+      ctx.i += mapCtx.i - 1;
+      out.push(val);
+    } else {
+      out.push(parseScalar(rest));
+      ctx.i++;
+    }
+  }
+  return out;
+}
+function parseFlowSequence(input) {
+  const parts = splitFlow(input);
+  return parts.map((p3) => {
+    const trimmed = p3.trim();
+    if (trimmed.startsWith("{")) {
+      return parseFlowMap(stripFlow(trimmed, "{", "}"));
+    }
+    return parseScalar(trimmed);
+  });
+}
+function stripFlow(s, open, close) {
+  let out = s.trim();
+  if (out.startsWith(open)) out = out.slice(1);
+  if (out.endsWith(close)) out = out.slice(0, -1);
+  return out;
+}
+function parseFlowMap(input) {
+  const parts = splitFlow(input);
+  const out = {};
+  for (const p3 of parts) {
+    const colonIdx = p3.indexOf(":");
+    if (colonIdx < 0) continue;
+    const key = p3.slice(0, colonIdx).trim();
+    const value = p3.slice(colonIdx + 1).trim();
+    out[key] = parseScalar(value);
+  }
+  return out;
+}
+function splitFlow(input) {
+  const out = [];
+  let depthSq = 0, depthCu = 0, depthQu = 0;
+  let buffer = "";
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (c === '"' || c === "'") {
+      depthQu = depthQu === 0 ? depthQu + 1 : 0;
+      buffer += c;
+    } else if (depthQu === 0) {
+      if (c === "[") depthSq++;
+      else if (c === "]") depthSq--;
+      else if (c === "{") depthCu++;
+      else if (c === "}") depthCu--;
+      else if (c === "," && depthSq === 0 && depthCu === 0) {
+        out.push(buffer);
+        buffer = "";
+        continue;
+      }
+      buffer += c;
+    } else {
+      buffer += c;
+    }
+  }
+  if (buffer.trim()) out.push(buffer);
+  return out;
+}
+function parseScalar(s) {
+  if (s === "" || s === "null" || s === "~") return null;
+  if (VALID_SCALARS.test(s)) return s.toLowerCase() === "true";
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function serializeYaml(value, indent = 0) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") {
+    if (/[:#\n\[\]\{\},&*!|>'"%@`]/.test(value)) {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (value.every((v) => v === null || typeof v !== "object")) {
+      return `[${value.map(serializeScalarInline).join(", ")}]`;
+    }
+    return `[${value.map((v) => "{" + serializeInlineObject(v) + "}").join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+    return entries.map(([k, v]) => {
+      if (v === null || v === void 0) return `${k}:`;
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+        return `${k}: ${serializeScalarInline(v)}`;
+      }
+      if (Array.isArray(v)) {
+        if (v.length === 0) return `${k}: []`;
+        if (v.every((x) => x === null || typeof x !== "object")) {
+          return `${k}: [${v.map(serializeScalarInline).join(", ")}]`;
+        }
+        return `${k}: [${v.map((x) => "{" + serializeInlineObject(x) + "}").join(", ")}]`;
+      }
+      return `${k}:
+${serializeYaml(v, indent + 2)}`;
+    }).map((line) => `${" ".repeat(indent)}${line}`).join("\n");
+  }
+  return String(value);
+}
+function serializeScalarInline(v) {
+  if (typeof v === "string" && /[:#\n\[\]\{\},&*!|>'"%@`]/.test(v)) return JSON.stringify(v);
+  return String(v);
+}
+function serializeInlineObject(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) {
+    return serializeScalarInline(v);
+  }
+  const entries = Object.entries(v).filter(([, val]) => val !== void 0);
+  return entries.map(([k, val]) => `${k}: ${serializeYaml(val)}`).join(", ");
+}
+function countIndent(line) {
+  let i = 0;
+  while (i < line.length && line[i] === " ") i++;
+  return i;
+}
+var FRONTMATTER_RE, VALID_SCALARS, Storage, KeyedMutex, workspaceMutex;
+var init_storage = __esm({
+  "src/cli/workspace/storage.ts"() {
+    "use strict";
+    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+    VALID_SCALARS = /^(true|false|null|~)$/i;
+    Storage = class {
+      /** Read a Markdown file with frontmatter. Throws if not found. */
+      read(path53) {
+        if (!existsSync18(path53)) {
+          throw new Error(`File not found: ${path53}`);
+        }
+        const md = readFileSync16(path53, "utf8");
+        return parseFrontmatter(md);
+      }
+      /** Read a Markdown file; returns null if not found. */
+      readIfExists(path53) {
+        if (!existsSync18(path53)) return null;
+        return this.read(path53);
+      }
+      /**
+       * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
+       * The meta object is serialized as YAML frontmatter; body as Markdown.
+       */
+      write(path53, meta3, body) {
+        mkdirSync11(dirname2(path53), { recursive: true });
+        const tmp = path53 + ".tmp-" + process.pid;
+        const md = serializeFrontmatter(meta3, body);
+        writeFileSync13(tmp, md, "utf8");
+        renameSync2(tmp, path53);
+      }
+      /** List all .md files in a directory (non-recursive). */
+      listMarkdown(dir) {
+        if (!existsSync18(dir)) return [];
+        return readdirSync4(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join14(dir, f));
+      }
+    };
+    KeyedMutex = class {
+      chains = /* @__PURE__ */ new Map();
+      async run(key, fn) {
+        const prev2 = this.chains.get(key) ?? Promise.resolve();
+        let release = () => {
+        };
+        const next = new Promise((resolve3) => {
+          release = resolve3;
+        });
+        const chained = prev2.then(() => next);
+        this.chains.set(key, chained);
+        await prev2;
+        try {
+          return await fn();
+        } finally {
+          release();
+          if (this.chains.get(key) === chained) {
+            this.chains.delete(key);
+          }
+        }
+      }
+    };
+    workspaceMutex = new KeyedMutex();
+  }
+});
+
+// src/cli/workspace/planStore.ts
+import {
+  copyFileSync,
+  existsSync as existsSync19,
+  mkdirSync as mkdirSync12,
+  readFileSync as readFileSync17,
+  renameSync as renameSync3,
+  writeFileSync as writeFileSync14
+} from "node:fs";
+import { dirname as dirname3, join as join15 } from "node:path";
+async function withPlanStore(projectRoot, fn) {
+  const rootDir = resolveWorkspaceRoot(projectRoot);
+  return workspaceMutex.run(`${rootDir}:plan`, () => {
+    const handle = loadHandle(rootDir);
+    const out = fn(handle);
+    saveHandle(rootDir, handle);
+    return out;
+  });
+}
+function nextPlanTaskId(store4) {
+  const maxExisting = store4.tasks.reduce((max, t) => {
+    const m = /^t(\d+)$/.exec(t.id);
+    return m ? Math.max(max, parseInt(m[1], 10)) : max;
+  }, 0);
+  store4.counter = Math.max(store4.counter, maxExisting) + 1;
+  return `t${store4.counter}`;
+}
+function writePlanTaskArtifact(rootDir, task) {
+  const path53 = join15(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync12(dirname3(path53), { recursive: true });
+  const meta3 = {
+    kind: "task",
+    id: task.id,
+    name: task.title,
+    phaseId: task.phaseId,
+    status: task.status,
+    priority: task.priority ?? "medium",
+    updatedAt: task.updatedAt
+  };
+  const body = [
+    `# Task ${task.id}: ${task.title}`,
+    "",
+    `- Status: **${task.status}**`,
+    `- Priority: ${task.priority ?? "medium"}`,
+    task.phaseId ? `- Phase: ${task.phaseId}` : null,
+    task.agent ? `- Agent: ${task.agent}` : null,
+    "",
+    task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
+    ""
+  ].filter((l) => l !== null).join("\n");
+  new Storage().write(path53, meta3, body);
+}
+function loadHandle(rootDir) {
+  const jsonPath = join15(rootDir, "plan.json");
+  if (!existsSync19(jsonPath)) {
+    return { rootDir, tasks: [], counter: 0, rootFields: {} };
+  }
+  let parsed;
+  try {
+    const raw = JSON.parse(readFileSync17(jsonPath, "utf8"));
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      throw new Error("root is not a JSON object");
+    }
+    parsed = raw;
+  } catch {
+    throw new PlanStoreError(
+      `PLAN_CORRUPT: ${jsonPath} is not valid JSON \u2014 refusing to overwrite a possibly hand-edited or crashed write. Fix or remove the file (a .bak may exist), then retry.`,
+      "PLAN_CORRUPT"
+    );
+  }
+  const {
+    tasks: rawTasks,
+    counter,
+    schemaVersion: _schemaVersion,
+    ...rootFields
+  } = parsed;
+  const tasks = (Array.isArray(rawTasks) ? rawTasks : []).map(normalizeTask).filter((t) => typeof t.id === "string" && t.id.length > 0);
+  const numericCounter = typeof counter === "number" && Number.isFinite(counter) && counter >= 0 ? Math.floor(counter) : 0;
+  return { rootDir, tasks, counter: numericCounter, rootFields };
+}
+function saveHandle(rootDir, handle) {
+  if (handle.tasks.length > PLAN_MAX_TASKS) {
+    throw new PlanStoreError(
+      `PLAN_TOO_MANY_TASKS: plan.json would exceed ${PLAN_MAX_TASKS} tasks (${handle.tasks.length}) \u2014 cancel or complete tasks first.`,
+      "PLAN_TOO_MANY_TASKS"
+    );
+  }
+  const jsonPath = join15(rootDir, "plan.json");
+  mkdirSync12(rootDir, { recursive: true });
+  if (existsSync19(jsonPath)) {
+    copyFileSync(jsonPath, `${jsonPath}.bak`);
+  }
+  const file2 = {
+    ...handle.rootFields,
+    schemaVersion: PLAN_SCHEMA_VERSION,
+    counter: handle.counter,
+    tasks: handle.tasks
+  };
+  const tmp = `${jsonPath}.tmp-${process.pid}`;
+  writeFileSync14(tmp, JSON.stringify(file2, null, 2) + "\n", "utf8");
+  renameSync3(tmp, jsonPath);
+}
+function normalizeTask(raw) {
+  const t = raw !== null && typeof raw === "object" ? { ...raw } : {};
+  if (typeof t.id === "string") {
+    t.id = t.id.trim().slice(0, 64);
+  }
+  const titleSource = firstString(t.title) ?? firstString(t.name) ?? firstString(t.description) ?? "";
+  t.title = titleSource.slice(0, PLAN_TITLE_MAX);
+  if (t.title && !firstString(t.name)) {
+    t.name = t.title;
+  }
+  t.status = normalizeStatus(t.status);
+  if (typeof t.notes === "string") {
+    t.notes = t.notes.slice(0, PLAN_NOTES_MAX);
+  }
+  if (typeof t.phaseId === "string") {
+    t.phaseId = t.phaseId.slice(0, PLAN_TAG_MAX);
+  }
+  if (typeof t.agent === "string") {
+    t.agent = t.agent.slice(0, PLAN_TAG_MAX);
+  }
+  return t;
+}
+function normalizeStatus(raw) {
+  const s = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+  switch (s) {
+    case "in_progress":
+    case "in-progress":
+    case "doing":
+    case "started":
+    case "active":
+      return "in_progress";
+    case "completed":
+    case "complete":
+    case "done":
+    case "finished":
+      return "completed";
+    case "cancelled":
+    case "canceled":
+    case "closed":
+      return "cancelled";
+    case "blocked":
+    case "on-hold":
+    case "on hold":
+      return "blocked";
+    default:
+      return "pending";
+  }
+}
+function firstString(v) {
+  return typeof v === "string" && v.trim().length > 0 ? v : null;
+}
+var PLAN_SCHEMA_VERSION, PLAN_MAX_TASKS, PLAN_TITLE_MAX, PLAN_NOTES_MAX, PLAN_TAG_MAX, PlanStoreError;
+var init_planStore = __esm({
+  "src/cli/workspace/planStore.ts"() {
+    "use strict";
+    init_paths2();
+    init_storage();
+    PLAN_SCHEMA_VERSION = 1;
+    PLAN_MAX_TASKS = 100;
+    PLAN_TITLE_MAX = 200;
+    PLAN_NOTES_MAX = 2e3;
+    PLAN_TAG_MAX = 64;
+    PlanStoreError = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "PlanStoreError";
+      }
+    };
+  }
+});
+
+// src/cli/tools/planTaskTools.ts
+function taskSummaryLine(t) {
+  return `- ${t.id}: ${t.title} (${t.status}${t.priority ? `, ${t.priority}` : ""})`;
+}
+function toTaskPayload(t) {
+  return {
+    id: t.id,
+    title: t.title,
+    status: t.status,
+    phaseId: t.phaseId,
+    priority: t.priority
+  };
+}
+function safeEmit(sink, event) {
+  if (!sink) return;
+  try {
+    sink(event);
+  } catch {
+  }
+}
+function createPlanTaskTools(opts) {
+  const projectRoot = opts.projectRoot;
+  const onTaskEvent = opts.onTaskEvent;
+  const taskCreate = {
+    name: "task_create",
+    description: "Create a durable workspace task in .zelari/plan.json (multi-session, shared with the Desktop Live Tasks panel). Use for project work that must survive this session. For volatile per-session tracking use todo_write instead. Returns the assigned id (t<N>).",
+    permissions: ["write"],
+    timeoutMs: 5e3,
+    inputSchema: CreateSchema,
+    execute: async (input) => {
+      try {
+        const res = await withPlanStore(projectRoot, (store4) => {
+          if (store4.tasks.length >= PLAN_MAX_TASKS) {
+            return typedErr(
+              `PLAN_TOO_MANY_TASKS: plan.json already holds ${store4.tasks.length} tasks (max ${PLAN_MAX_TASKS}).`
+            );
+          }
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const id = nextPlanTaskId(store4);
+          const task = {
+            id,
+            title: input.title.trim().slice(0, PLAN_TITLE_MAX),
+            // council readers (buildPlanSummary) render `name` — keep the
+            // alias in sync from creation, not just on reload.
+            name: input.title.trim().slice(0, PLAN_TITLE_MAX),
+            status: "pending",
+            priority: input.priority,
+            phaseId: input.phaseId?.trim().slice(0, 64),
+            notes: input.notes?.trim().slice(0, PLAN_NOTES_MAX),
+            createdAt: now,
+            updatedAt: now
+          };
+          store4.tasks.push(task);
+          writePlanTaskArtifact(store4.rootDir, task);
+          return typedOk({ id, task });
+        });
+        if (res.ok) {
+          safeEmit(onTaskEvent, {
+            type: "task_update",
+            source: "workspace_plan",
+            task: toTaskPayload(res.value.task)
+          });
+        }
+        return res;
+      } catch (err) {
+        return typedErr(planStoreErrorMessage(err, "task_create"));
+      }
+    }
+  };
+  const taskUpdate = {
+    name: "task_update",
+    description: "Update a durable workspace task in .zelari/plan.json (status, title, priority, phaseId, notes, or appendNote). Accepts council-created ids too (task_list shows them). Errors with PLAN_TASK_NOT_FOUND on unknown ids.",
+    permissions: ["write"],
+    timeoutMs: 5e3,
+    inputSchema: UpdateSchema,
+    execute: async (input) => {
+      try {
+        const res = await withPlanStore(projectRoot, (store4) => {
+          const task = store4.tasks.find((t) => t.id === input.id);
+          if (!task) {
+            return typedErr(
+              `PLAN_TASK_NOT_FOUND: no task with id "${input.id}" in .zelari/plan.json (call task_list for current ids).`
+            );
+          }
+          if (input.title !== void 0) {
+            task.title = input.title.trim().slice(0, PLAN_TITLE_MAX);
+            task.name = task.title;
+          }
+          if (input.status !== void 0) task.status = input.status;
+          if (input.priority !== void 0) task.priority = input.priority;
+          if (input.phaseId !== void 0) task.phaseId = input.phaseId.slice(0, 64);
+          if (input.notes !== void 0) {
+            task.notes = input.notes.slice(0, PLAN_NOTES_MAX);
+          }
+          if (input.appendNote !== void 0) {
+            const prev2 = typeof task.notes === "string" ? task.notes : "";
+            const merged = prev2 ? `${prev2}
+${input.appendNote}` : input.appendNote;
+            task.notes = merged.slice(-PLAN_NOTES_MAX);
+          }
+          task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          writePlanTaskArtifact(store4.rootDir, task);
+          return typedOk({ task });
+        });
+        if (res.ok) {
+          safeEmit(onTaskEvent, {
+            type: "task_update",
+            source: "workspace_plan",
+            task: toTaskPayload(res.value.task)
+          });
+        }
+        return res;
+      } catch (err) {
+        return typedErr(planStoreErrorMessage(err, "task_update"));
+      }
+    }
+  };
+  const taskList = {
+    name: "task_list",
+    description: "List durable workspace tasks from .zelari/plan.json (both t<N> agent tasks and council-created plan tasks). Optional status/phaseId filters. Use before task_update to discover ids.",
+    permissions: ["read"],
+    timeoutMs: 5e3,
+    inputSchema: ListSchema,
+    execute: async (input) => {
+      try {
+        let allPayloads = [];
+        const res = await withPlanStore(projectRoot, (store4) => {
+          allPayloads = store4.tasks.map(toTaskPayload);
+          const filtered = store4.tasks.filter(
+            (t) => (input.status === void 0 || t.status === input.status) && (input.phaseId === void 0 || t.phaseId === input.phaseId)
+          );
+          const done = store4.tasks.filter(
+            (t) => t.status === "completed" || t.status === "cancelled"
+          ).length;
+          const formatted = filtered.length === 0 ? "(no matching workspace tasks)" : filtered.map(taskSummaryLine).join("\n");
+          return typedOk({
+            tasks: filtered,
+            total: store4.tasks.length,
+            done,
+            formatted: `${formatted}
+(done/total: ${done}/${store4.tasks.length})`
+          });
+        });
+        if (res.ok) {
+          safeEmit(onTaskEvent, {
+            type: "task_snapshot",
+            source: "workspace_plan",
+            tasks: allPayloads
+          });
+        }
+        return res;
+      } catch (err) {
+        return typedErr(planStoreErrorMessage(err, "task_list"));
+      }
+    }
+  };
+  return [taskCreate, taskUpdate, taskList];
+}
+function planStoreErrorMessage(err, tool) {
+  if (err instanceof PlanStoreError) return err.message;
+  return `[${tool}] ${err instanceof Error ? err.message : String(err)}`;
+}
+var StatusSchema2, PrioritySchema, CreateSchema, UpdateSchema, ListSchema;
+var init_planTaskTools = __esm({
+  "src/cli/tools/planTaskTools.ts"() {
+    "use strict";
+    init_zod();
+    init_toolTypes();
+    init_planStore();
+    StatusSchema2 = external_exports.enum(["pending", "in_progress", "completed", "cancelled", "blocked"]).describe(
+      "blocked exists only here (session todos have no blocked); no rigid FSM \u2014 corrections like completed \u2192 in_progress are allowed"
+    );
+    PrioritySchema = external_exports.enum(["low", "medium", "high", "critical"]);
+    CreateSchema = external_exports.object({
+      title: external_exports.string().min(1).max(PLAN_TITLE_MAX).describe("Short task description"),
+      priority: PrioritySchema.optional().describe("Default medium"),
+      phaseId: external_exports.string().min(1).max(64).optional().describe("Existing plan phase id (see .zelari/plan.json phases)"),
+      notes: external_exports.string().max(PLAN_NOTES_MAX).optional().describe("Optional context/acceptance notes")
+    });
+    UpdateSchema = external_exports.object({
+      id: external_exports.string().min(1).max(64).describe("Task id from task_create/task_list"),
+      status: StatusSchema2.optional(),
+      title: external_exports.string().min(1).max(PLAN_TITLE_MAX).optional(),
+      priority: PrioritySchema.optional(),
+      phaseId: external_exports.string().min(1).max(64).optional(),
+      notes: external_exports.string().max(PLAN_NOTES_MAX).optional(),
+      appendNote: external_exports.string().max(PLAN_NOTES_MAX).optional().describe("Append to existing notes (kept within the size cap)")
+    }).describe("At least one field besides id must be present");
+    ListSchema = external_exports.object({
+      status: StatusSchema2.optional().describe("Filter by status"),
+      phaseId: external_exports.string().min(1).max(64).optional().describe("Filter by phase")
+    });
+  }
+});
+
 // src/cli/lsp/protocol.ts
 function encodeMessage(message) {
   const json2 = JSON.stringify(message);
@@ -31221,7 +32102,7 @@ var init_servers = __esm({
 
 // src/cli/lsp/manager.ts
 import { spawn as spawn4 } from "node:child_process";
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 function processTransport(child) {
   return {
     send: (data) => {
@@ -31424,7 +32305,7 @@ var init_manager = __esm({
         const uri = pathToUri(file2);
         let text;
         try {
-          text = readFileSync16(file2, "utf8");
+          text = readFileSync18(file2, "utf8");
         } catch {
           text = "";
         }
@@ -31746,13 +32627,13 @@ var init_store = __esm({
 });
 
 // src/cli/semantic/index.ts
-import { promises as fs12, existsSync as existsSync17, readFileSync as readFileSync17 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { promises as fs12, existsSync as existsSync20, readFileSync as readFileSync19 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
 import path23 from "node:path";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function getIndexPath(root) {
-  const hash3 = createHash3("sha1").update(path23.resolve(root)).digest("hex").slice(0, 16);
-  return process.env.ZELARI_SEMANTIC_FILE ?? path23.join(homedir5(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
+  const hash3 = createHash5("sha1").update(path23.resolve(root)).digest("hex").slice(0, 16);
+  return process.env.ZELARI_SEMANTIC_FILE ?? path23.join(homedir6(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
   const out = [];
@@ -31830,9 +32711,9 @@ async function saveIndex(root, data) {
 }
 function loadIndex(root) {
   const file2 = getIndexPath(root);
-  if (!existsSync17(file2)) return null;
+  if (!existsSync20(file2)) return null;
   try {
-    const parsed = JSON.parse(readFileSync17(file2, "utf8"));
+    const parsed = JSON.parse(readFileSync19(file2, "utf8"));
     if (parsed && Array.isArray(parsed.chunks)) return parsed;
   } catch {
   }
@@ -32362,19 +33243,19 @@ __export(targets_exports, {
 });
 import {
   chmodSync,
-  existsSync as existsSync18,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync18,
-  writeFileSync as writeFileSync12
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync20,
+  writeFileSync as writeFileSync15
 } from "node:fs";
-import { dirname as dirname2, join as join13 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { dirname as dirname4, join as join16 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 import { spawn as spawn5 } from "node:child_process";
 function getSshTargetsPath() {
-  return join13(homedir6(), ".zelari-code", "ssh-targets.json");
+  return join16(homedir7(), ".zelari-code", "ssh-targets.json");
 }
 function getSshSecretsPath() {
-  return join13(homedir6(), ".zelari-code", "ssh-secrets.json");
+  return join16(homedir7(), ".zelari-code", "ssh-secrets.json");
 }
 function normalizeAuth(auth) {
   if (auth === "keyPath") return "keyPath";
@@ -32383,17 +33264,17 @@ function normalizeAuth(auth) {
 }
 function readSecrets() {
   const path53 = getSshSecretsPath();
-  if (!existsSync18(path53)) return {};
+  if (!existsSync21(path53)) return {};
   try {
-    return JSON.parse(readFileSync18(path53, "utf8"));
+    return JSON.parse(readFileSync20(path53, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
   const path53 = getSshSecretsPath();
-  mkdirSync10(dirname2(path53), { recursive: true });
-  writeFileSync12(path53, `${JSON.stringify(data, null, 2)}
+  mkdirSync13(dirname4(path53), { recursive: true });
+  writeFileSync15(path53, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
     chmodSync(path53, 384);
@@ -32426,9 +33307,9 @@ function deleteSshPassword(id) {
 }
 function readStore2() {
   const path53 = getSshTargetsPath();
-  if (!existsSync18(path53)) return [];
+  if (!existsSync21(path53)) return [];
   try {
-    const parsed = JSON.parse(readFileSync18(path53, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path53, "utf8"));
     const list = Array.isArray(parsed.targets) ? parsed.targets : [];
     return list.filter(
       (t) => t && typeof t.id === "string" && typeof t.host === "string" && typeof t.user === "string"
@@ -32444,9 +33325,9 @@ function readStore2() {
 }
 function writeStore2(targets) {
   const path53 = getSshTargetsPath();
-  mkdirSync10(dirname2(path53), { recursive: true });
+  mkdirSync13(dirname4(path53), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
-  writeFileSync12(
+  writeFileSync15(
     path53,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
@@ -32547,17 +33428,17 @@ function buildSshBaseArgs(target) {
   return args;
 }
 function ensureAskpassHelper() {
-  const dir = join13(homedir6(), ".zelari-code", "ssh-helpers");
-  mkdirSync10(dir, { recursive: true });
-  const cjs = join13(dir, "askpass.cjs");
-  writeFileSync12(
+  const dir = join16(homedir7(), ".zelari-code", "ssh-helpers");
+  mkdirSync13(dir, { recursive: true });
+  const cjs = join16(dir, "askpass.cjs");
+  writeFileSync15(
     cjs,
     "process.stdout.write(process.env.ZELARI_SSH_ASKPASS_PASS || '');\n",
     "utf8"
   );
   if (process.platform === "win32") {
-    const cmd = join13(dir, "askpass.cmd");
-    writeFileSync12(
+    const cmd = join16(dir, "askpass.cmd");
+    writeFileSync15(
       cmd,
       `@echo off\r
 node "%~dp0askpass.cjs"\r
@@ -32566,8 +33447,8 @@ node "%~dp0askpass.cjs"\r
     );
     return cmd;
   }
-  const sh = join13(dir, "askpass.sh");
-  writeFileSync12(
+  const sh = join16(dir, "askpass.sh");
+  writeFileSync15(
     sh,
     `#!/bin/sh
 exec node "$(dirname "$0")/askpass.cjs"
@@ -32640,9 +33521,9 @@ function readSshPublicKey(keyOrPubPath) {
   if (!raw) return { ok: false, error: "Empty path" };
   const candidates = raw.endsWith(".pub") ? [raw] : [`${raw}.pub`, raw];
   for (const p3 of candidates) {
-    if (!existsSync18(p3)) continue;
+    if (!existsSync21(p3)) continue;
     try {
-      const content = readFileSync18(p3, "utf8").trim();
+      const content = readFileSync20(p3, "utf8").trim();
       if (!content) continue;
       if (/BEGIN .*PRIVATE KEY/i.test(content)) {
         return {
@@ -33212,11 +34093,11 @@ __export(folderTrust_exports, {
   trustFolder: () => trustFolder,
   untrustFolder: () => untrustFolder
 });
-import { homedir as homedir7 } from "node:os";
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync21, writeFileSync as writeFileSync16 } from "node:fs";
 import path28 from "node:path";
 function trustStorePath() {
-  return _overrideStorePath ?? path28.join(homedir7(), ".zelari-code", "trust.json");
+  return _overrideStorePath ?? path28.join(homedir8(), ".zelari-code", "trust.json");
 }
 function normalize(p3) {
   const resolved = path28.resolve(p3);
@@ -33224,7 +34105,7 @@ function normalize(p3) {
 }
 function readStore3() {
   try {
-    const raw = readFileSync19(trustStorePath(), "utf8");
+    const raw = readFileSync21(trustStorePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && Array.isArray(parsed.folders)) return parsed;
     return DEFAULT_STORE;
@@ -33232,11 +34113,11 @@ function readStore3() {
     return DEFAULT_STORE;
   }
 }
-function writeStore3(store3) {
+function writeStore3(store4) {
   const p3 = trustStorePath();
   try {
-    mkdirSync11(path28.dirname(p3), { recursive: true });
-    writeFileSync13(p3, JSON.stringify(store3, null, 2), "utf8");
+    mkdirSync14(path28.dirname(p3), { recursive: true });
+    writeFileSync16(p3, JSON.stringify(store4, null, 2), "utf8");
   } catch (err) {
     throw new Error(
       `failed to persist trust store ${p3}: ${err instanceof Error ? err.message : String(err)}`
@@ -33260,21 +34141,21 @@ function isFolderTrusted(folderPath) {
   return readStore3().folders.some((f) => normalize(f.path) === target);
 }
 function trustFolder(folderPath) {
-  const store3 = readStore3();
+  const store4 = readStore3();
   const normalized = path28.resolve(folderPath);
-  if (!store3.folders.some((f) => normalize(f.path) === normalize(normalized))) {
-    store3.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
-    writeStore3(store3);
+  if (!store4.folders.some((f) => normalize(f.path) === normalize(normalized))) {
+    store4.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    writeStore3(store4);
   }
   return { ok: true, path: normalized };
 }
 function untrustFolder(folderPath) {
-  const store3 = readStore3();
+  const store4 = readStore3();
   const target = normalize(folderPath);
-  const before = store3.folders.length;
-  store3.folders = store3.folders.filter((f) => normalize(f.path) !== target);
-  if (store3.folders.length === before) return { ok: true, removed: false };
-  writeStore3(store3);
+  const before = store4.folders.length;
+  store4.folders = store4.folders.filter((f) => normalize(f.path) !== target);
+  if (store4.folders.length === before) return { ok: true, removed: false };
+  writeStore3(store4);
   return { ok: true, removed: true };
 }
 function listTrustedFolders() {
@@ -33291,7 +34172,7 @@ function getTrustStorePath() {
   return trustStorePath();
 }
 function hasTrustStore() {
-  return existsSync19(trustStorePath());
+  return existsSync22(trustStorePath());
 }
 function _setTrustStorePathForTests(p3) {
   _overrideStorePath = p3;
@@ -33306,21 +34187,21 @@ var init_folderTrust = __esm({
 });
 
 // src/cli/safety/lifecycleHooks.ts
-import { homedir as homedir8 } from "node:os";
-import { join as join14 } from "node:path";
-import { readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join17 } from "node:path";
+import { readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
 function globalHooksDir() {
-  return join14(homedir8(), ".zelari-code", "hooks");
+  return join17(homedir9(), ".zelari-code", "hooks");
 }
 function projectHooksDir(projectRoot) {
-  return join14(projectRoot, ".zelari", "hooks");
+  return join17(projectRoot, ".zelari", "hooks");
 }
 function fingerprintHookDirs(dirs) {
   const parts = [];
   for (const dir of dirs) {
     let names;
     try {
-      names = readdirSync4(dir).filter((f) => f.endsWith(".json")).sort();
+      names = readdirSync5(dir).filter((f) => f.endsWith(".json")).sort();
     } catch {
       parts.push(`${dir}:missing`);
       continue;
@@ -33334,7 +34215,7 @@ function fingerprintHookDirs(dirs) {
       continue;
     }
     for (const name of names) {
-      const full = join14(dir, name);
+      const full = join17(dir, name);
       try {
         const st = statSync3(full);
         parts.push(`${full}:${st.mtimeMs}:${st.size}`);
@@ -33375,7 +34256,7 @@ var init_lifecycleHooks = __esm({
 });
 
 // src/cli/toolResultCache.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { promises as fs14 } from "node:fs";
 import path29 from "node:path";
 function isToolCacheEnabled() {
@@ -33388,7 +34269,7 @@ function resolveToolCacheTtlMs() {
   return Number.isFinite(n) && n >= 0 ? n : TOOL_CACHE_DEFAULT_TTL_MS;
 }
 function hashKey(parts) {
-  return createHash4("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
+  return createHash6("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
 }
 function resultBytes(result) {
   try {
@@ -33678,6 +34559,11 @@ function createBuiltinToolRegistry(options = {}) {
   const todoRead = enableTodos ? withPerm(createTodoReadTool()) : null;
   if (todoWrite) registry4.register(todoWrite);
   if (todoRead) registry4.register(todoRead);
+  const enablePlanTasks = options.enablePlanTasks !== false && options.readOnly !== true && (profile === "full" || options.planMode === true) && profile !== "explore" && profile !== "verify" && profile !== "general";
+  const planTaskToolsWrapped = (enablePlanTasks ? createPlanTaskTools({ projectRoot: root, onTaskEvent: options.onTaskEvent }) : []).map((t) => withPerm(t));
+  for (const t of planTaskToolsWrapped) {
+    registry4.register(t);
+  }
   const summary = [
     safeReadFile,
     safeGrepContent,
@@ -33690,7 +34576,8 @@ function createBuiltinToolRegistry(options = {}) {
     ...askUserTool ? [askUserTool] : [],
     ...skillTool ? [skillTool] : [],
     ...todoWrite ? [todoWrite] : [],
-    ...todoRead ? [todoRead] : []
+    ...todoRead ? [todoRead] : [],
+    ...planTaskToolsWrapped.length > 0 ? planTaskToolsWrapped : []
   ];
   const tools = summary.map((t) => ({
     name: t.name,
@@ -34039,6 +34926,7 @@ var init_toolRegistry = __esm({
     init_askUser();
     init_skillTool();
     init_todoTools();
+    init_planTaskTools();
     init_tools2();
     init_manager();
     init_tools3();
@@ -34069,7 +34957,7 @@ var init_toolRegistry = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID2 } from "node:crypto";
 import { promises as fs15 } from "node:fs";
 import * as path30 from "node:path";
 function shortId() {
@@ -34112,16 +35000,16 @@ function isStateEnabled(env = process.env) {
 }
 async function getStateStore(projectRoot, env = process.env) {
   if (!isStateEnabled(env)) return new NoopDurableStateStore();
-  const store3 = new FileDurableStateStore();
+  const store4 = new FileDurableStateStore();
   try {
-    await store3.init(projectRoot);
-    return store3;
+    await store4.init(projectRoot);
+    return store4;
   } catch {
     return new NoopDurableStateStore();
   }
 }
 function hashStablePrompt(stable) {
-  return createHash5("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
+  return createHash7("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
 }
 var DEFAULT_MATERIALIZE_CHARS, FileDurableStateStore, NoopDurableStateStore;
 var init_fileStateStore = __esm({
@@ -34452,29 +35340,6 @@ function extractiveHistorySummary(dropped, opts) {
   }
   return out;
 }
-function formatDroppedForLlm(dropped) {
-  const lines = [];
-  for (const m of dropped) {
-    if (m.role === "user") {
-      lines.push(`USER: ${oneLine(m.content, 400)}`);
-    } else if (m.role === "assistant") {
-      const tools = m.toolCalls?.map((t) => t.name).join(",") || "";
-      const body2 = oneLine(m.content, 300);
-      lines.push(
-        tools ? `ASSISTANT(tools=${tools}): ${body2}` : `ASSISTANT: ${body2}`
-      );
-    } else if (m.role === "tool") {
-      lines.push(`TOOL(${m.toolCallId ?? "?"}): ${oneLine(m.content, 160)}`);
-    } else if (m.role === "system") {
-      lines.push(`SYSTEM: ${oneLine(m.content, 200)}`);
-    }
-  }
-  let body = lines.join("\n");
-  if (body.length > MAX_LLM_INPUT_CHARS) {
-    body = body.slice(body.length - MAX_LLM_INPUT_CHARS);
-  }
-  return body;
-}
 function oneLine(s, max) {
   const t = s.replace(/\s+/g, " ").trim();
   if (t.length <= max) return t;
@@ -34500,12 +35365,11 @@ function collectPathsFromText(text, out) {
     n += 1;
   }
 }
-var MAX_SUMMARY_CHARS, MAX_LLM_INPUT_CHARS;
+var MAX_SUMMARY_CHARS;
 var init_historySummary = __esm({
   "src/cli/budget/historySummary.ts"() {
     "use strict";
     MAX_SUMMARY_CHARS = 3500;
-    MAX_LLM_INPUT_CHARS = 24e3;
   }
 });
 
@@ -34515,92 +35379,87 @@ function isLlmCompactEnabled() {
   if (v === "0" || v === "false" || v === "off" || v === "no") return false;
   return true;
 }
-async function llmSummarizeHistory(input) {
-  if (!isLlmCompactEnabled()) return null;
-  if (!input.droppedTranscript.trim()) return null;
-  let config2 = null;
-  try {
-    config2 = await resolveCompactProviderConfig();
-  } catch {
-    return null;
+function compactModelOverride() {
+  const v = process.env.ZELARI_COMPACT_MODEL?.trim();
+  return v ? v : void 0;
+}
+async function llmSummarizeHistoryReplay(input) {
+  const override = input.overrideModel ?? compactModelOverride();
+  const model = override ?? input.model;
+  const cacheReuseExpected = !override;
+  if (!isLlmCompactEnabled()) return { summary: null, model, cacheReuseExpected };
+  if (input.droppedMessages.length === 0) {
+    return { summary: null, model, cacheReuseExpected };
   }
-  if (!config2) return null;
-  const model = process.env.ZELARI_COMPACT_MODEL?.trim() || config2.model;
+  const messages = [
+    ...input.systemMessages,
+    ...input.droppedMessages,
+    {
+      role: "user",
+      content: COMPACTION_INSTRUCTION
+    }
+  ];
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 45e3);
+  const timeout = setTimeout(() => controller.abort(), REPLAY_TIMEOUT_MS);
   const onOuterAbort = () => controller.abort();
   input.signal?.addEventListener("abort", onOuterAbort, { once: true });
   try {
-    const url2 = `${config2.baseUrl.replace(/\/$/, "")}/chat/completions`;
-    const res = await fetch(url2, {
-      method: "POST",
+    let text = "";
+    let emittedToolCall = false;
+    for await (const delta of input.providerStream({
+      provider: input.provider,
+      model,
+      messages,
+      // Tools stay advertised: dropping them would change the prefix token
+      // sequence and destroy cache reuse (explicit DSH decision). They are
+      // sorted canonically (same discipline as the live routed request and
+      // the snapshot fingerprints) so the replay prefix is byte-identical.
+      tools: [...input.tools].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0),
       signal: controller.signal,
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${config2.apiKey}`
-      },
-      body: JSON.stringify({
-        model,
+      generation: {
+        purpose: "compaction",
         temperature: 0.1,
-        max_tokens: 900,
-        stream: false,
-        messages: [
-          { role: "system", content: COMPACT_SYSTEM },
-          {
-            role: "user",
-            content: `Extractive sketch (may be incomplete):
-${input.extractive.slice(0, 2500)}
-
-Transcript of dropped turns:
-${input.droppedTranscript}`
-          }
-        ]
-      })
-    });
-    if (!res.ok) return null;
-    const json2 = await res.json();
-    const text = json2.choices?.[0]?.message?.content?.trim();
-    if (!text) return null;
-    return "[history-summary \xB7 llm]\n" + text + "\n\nContinue from the recent messages below; honor decisions already made above.";
+        maxTokens: 900
+      }
+    })) {
+      if (delta.kind === "text") text += delta.delta;
+      if (delta.kind === "tool_call") emittedToolCall = true;
+    }
+    if (emittedToolCall) return { summary: null, model, cacheReuseExpected };
+    if (!text.trim()) return { summary: null, model, cacheReuseExpected };
+    return { summary: text.trim(), model, cacheReuseExpected };
   } catch {
-    return null;
+    return { summary: null, model, cacheReuseExpected };
   } finally {
     clearTimeout(timeout);
     input.signal?.removeEventListener("abort", onOuterAbort);
   }
 }
-async function resolveCompactProviderConfig() {
-  const active = getProviderConfig().activeProviderId;
-  const meta3 = await resolveApiKeyWithMeta(active);
-  const apiKey = meta3?.apiKey;
-  if (!apiKey) return null;
-  const custom2 = getCustomEndpoint(active);
-  let baseUrl = custom2 || (active === "openai-compatible" || active === "custom" ? process.env.OPENAI_BASE_URL ?? PROVIDER_ENDPOINTS[active] : PROVIDER_ENDPOINTS[active]);
-  if (!baseUrl) return null;
-  const model = getModelForProvider(active);
-  return {
-    apiKey,
-    baseUrl,
-    model,
-    providerId: active
-  };
-}
-var COMPACT_SYSTEM;
+var COMPACTION_INSTRUCTION, REPLAY_TIMEOUT_MS;
 var init_llmCompact = __esm({
   "src/cli/budget/llmCompact.ts"() {
     "use strict";
-    init_providerConfig();
-    init_keyStore();
-    init_openai_compatible();
-    COMPACT_SYSTEM = `You compress earlier turns of a coding-agent session into a dense continuity brief.
-Output plain text (no markdown fences) with these sections:
-1) Goal \u2014 what the user wants
-2) Decisions \u2014 choices already made
-3) Done \u2014 completed work / files changed
-4) Open \u2014 remaining tasks / blockers
-5) Constraints \u2014 important rules the agent must keep
+    COMPACTION_INSTRUCTION = `
+You are now acting as a compaction engine for this coding-agent session.
+
+Condense the conversation ABOVE into a compact checkpoint sufficient to continue the task.
+
+Preserve:
+- user's goal and evolving intent
+- decisions already made
+- exact file paths and identifiers
+- code changes already completed
+- commands/errors that still matter
+- constraints
+- unfinished work
+- the single most likely next action
 
-Be factual and concise. Max ~400 words. Do not invent work that was not present.`;
+Do not call tools.
+Do not mention this summarization request.
+Output only the checkpoint.
+Be concise.
+`.trim();
+    REPLAY_TIMEOUT_MS = 6e4;
   }
 });
 
@@ -34639,6 +35498,7 @@ function resolveMaxMessages(opts) {
     turns = Math.min(turns, 3);
   }
   if (turns <= 0) return 0;
+  if (opts?.force && opts?.maxMessages) return Math.max(1, opts.maxMessages);
   return turns * 4;
 }
 function findValidCutIndex(messages, naiveCut) {
@@ -34704,12 +35564,18 @@ function pruneToolResultsDetailed(messages, opts) {
 function compactHistory(messages, opts) {
   return compactHistoryDetailed(messages, opts).messages;
 }
+function buildCheckpointMessage(summaryText) {
+  return {
+    role: "user",
+    content: CHECKPOINT_WRAPPER_PREFIX + "\n\n<compacted-summary>\n" + summaryText + "\n</compacted-summary>"
+  };
+}
 function compactHistoryDetailed(messages, opts) {
   const maxMessages = resolveMaxMessages(opts);
   if (maxMessages === 0) {
     return { messages: [], compacted: true, messagesRemoved: messages.length, summary: "" };
   }
-  if (messages.length <= maxMessages * 2) {
+  if (messages.length <= maxMessages * 2 && !opts?.force) {
     return {
       messages,
       compacted: false,
@@ -34717,7 +35583,7 @@ function compactHistoryDetailed(messages, opts) {
       summary: ""
     };
   }
-  const naiveCut = messages.length - maxMessages;
+  const naiveCut = Math.max(0, messages.length - maxMessages);
   const cut = findValidCutIndex(messages, naiveCut);
   if (cut === 0) {
     return {
@@ -34731,10 +35597,9 @@ function compactHistoryDetailed(messages, opts) {
   const pruned = pruneToolResultsDetailed(messages.slice(cut));
   const kept = pruned.messages;
   const summaryText = extractiveHistorySummary(droppedMsgs);
-  const summary = {
-    role: "system",
-    content: summaryText || `${COMPACT_MARKER} ${cut} earlier message(s) dropped.`
-  };
+  const summary = buildCheckpointMessage(
+    summaryText || `${COMPACT_MARKER} ${cut} earlier message(s) dropped.`
+  );
   return {
     messages: [summary, ...kept],
     compacted: true,
@@ -34749,29 +35614,58 @@ async function compactHistoryAsync(messages, opts) {
   const cut = base.messagesRemoved;
   const droppedMsgs = messages.slice(0, cut);
   const extractive = extractiveHistorySummary(droppedMsgs);
-  const droppedTranscript = formatDroppedForLlm(droppedMsgs);
   let summaryText = extractive;
-  try {
-    const llm = await llmSummarizeHistory({
-      extractive,
-      droppedTranscript,
-      signal: opts?.signal
-    });
-    if (llm && llm.trim().length > 40) summaryText = llm.trim();
-  } catch {
+  let cacheReuseExpected;
+  let replayExactPrefix;
+  const canReplay = !!(opts?.providerStream && opts?.requestSnapshot);
+  if (canReplay) {
+    try {
+      const replay = await llmSummarizeHistoryReplay({
+        providerStream: opts.providerStream,
+        provider: opts.requestSnapshot.provider,
+        model: opts.requestSnapshot.model,
+        systemMessages: opts.requestSnapshot.systemMessages,
+        tools: opts.requestSnapshot.tools,
+        droppedMessages: droppedMsgs,
+        signal: opts?.signal
+      });
+      cacheReuseExpected = replay.cacheReuseExpected;
+      if (replay.summary && replay.summary.trim().length > 40) {
+        const sourceTokens = roughTokens(droppedMsgs);
+        const summaryTok = Math.ceil(replay.summary.length / 4);
+        if (summaryTok < sourceTokens) {
+          summaryText = replay.summary.trim();
+        }
+      }
+    } catch {
+    }
   }
   const pruned = pruneToolResultsDetailed(messages.slice(cut));
   const kept = pruned.messages;
-  const summary = { role: "system", content: summaryText };
+  const summary = buildCheckpointMessage(summaryText);
   return {
     messages: [summary, ...kept],
     compacted: true,
     messagesRemoved: cut,
     summary: summaryText,
-    prunedToolResults: pruned.stats.pruned
+    prunedToolResults: pruned.stats.pruned,
+    cacheReuseExpected,
+    replayExactPrefix
   };
 }
-var COMPACT_MARKER;
+function roughTokens(msgs) {
+  let n = 0;
+  for (const m of msgs) {
+    n += Math.ceil((m.content ?? "").length / 4);
+    if (m.toolCalls) {
+      for (const tc of m.toolCalls) {
+        n += Math.ceil(JSON.stringify(tc.args ?? {}).length / 4);
+      }
+    }
+  }
+  return Math.max(1, n);
+}
+var COMPACT_MARKER, CHECKPOINT_WRAPPER_PREFIX;
 var init_historyCompaction = __esm({
   "src/cli/hooks/historyCompaction.ts"() {
     "use strict";
@@ -34779,6 +35673,30 @@ var init_historyCompaction = __esm({
     init_llmCompact();
     init_envNumber();
     COMPACT_MARKER = "[history] Earlier turns were compacted to stay within the context budget.";
+    CHECKPOINT_WRAPPER_PREFIX = "This is an automatically generated checkpoint of earlier conversation. Treat it as established context and continue directly.";
+  }
+});
+
+// src/cli/budget/requestSnapshotStore.ts
+function recordRequestSnapshot(sessionId, snapshot) {
+  store3.set(sessionId, { snapshot });
+}
+function recordRequestUsage(sessionId, usage) {
+  const entry = store3.get(sessionId);
+  if (!entry) return;
+  entry.usage = usage;
+}
+function getRequestSnapshotWithUsage(sessionId) {
+  return store3.get(sessionId) ?? null;
+}
+function clearAllRequestSnapshots() {
+  store3.clear();
+}
+var store3;
+var init_requestSnapshotStore = __esm({
+  "src/cli/budget/requestSnapshotStore.ts"() {
+    "use strict";
+    store3 = /* @__PURE__ */ new Map();
   }
 });
 
@@ -34804,8 +35722,8 @@ __export(conversationContext_exports, {
   setHistory: () => setHistory,
   setLastClarification: () => setLastClarification
 });
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join19 } from "node:path";
 function getHistory() {
   return history;
 }
@@ -34813,7 +35731,7 @@ function setHistory(messages) {
   history = [...messages];
 }
 function compactInPlace(cwd = process.cwd()) {
-  const durableStatePresent = existsSync20(join16(cwd, ".zelari", "state", "HEAD.json"));
+  const durableStatePresent = existsSync23(join19(cwd, ".zelari", "state", "HEAD.json"));
   history = compactHistory(history, { durableStatePresent });
 }
 function appendMessages(msgs) {
@@ -34823,6 +35741,7 @@ function appendMessages(msgs) {
 function clearHistory() {
   history = [];
   lastClarification = null;
+  clearAllRequestSnapshots();
   clearSessionTodos();
   clearSessionPermissionGrants();
 }
@@ -34981,6 +35900,7 @@ var init_conversationContext = __esm({
     init_toolPermissions();
     init_sessionTodos();
     init_historyCompaction();
+    init_requestSnapshotStore();
     history = [];
     lastClarification = null;
     SHORT_CONTINUE = /^(procedi|continua|continue|go\s*ahead|go|ok|okay|sì|si|yes|vai|avanti|next|proceed|conferma|confermo|applica|fai|scrivi|esegui|implementa|vai pure|fai pure|ok procedi|sì procedi|si procedi)$/i;
@@ -35326,14 +36246,14 @@ var init_claudeProvider = __esm({
 });
 
 // src/cli/workspace/projectInstructions.ts
-import { existsSync as existsSync21, readFileSync as readFileSync20 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync22 } from "node:fs";
+import { join as join20 } from "node:path";
 function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
   for (const name of CANDIDATES) {
-    const full = join17(projectRoot, name);
-    if (!existsSync21(full)) continue;
+    const full = join20(projectRoot, name);
+    if (!existsSync24(full)) continue;
     try {
-      let raw = readFileSync20(full, "utf8");
+      let raw = readFileSync22(full, "utf8");
       raw = raw.replace(/\r\n/g, "\n").trim();
       if (!raw) continue;
       if (raw.length <= maxChars) {
@@ -35368,75 +36288,6 @@ var init_projectInstructions = __esm({
   }
 });
 
-// src/cli/workspace/paths.ts
-import {
-  mkdirSync as mkdirSync12,
-  writeFileSync as writeFileSync14,
-  existsSync as existsSync22,
-  accessSync,
-  constants,
-  realpathSync
-} from "node:fs";
-import { join as join18, basename } from "node:path";
-import { homedir as homedir9 } from "node:os";
-import { createHash as createHash6 } from "node:crypto";
-function resolveWorkspaceRoot(projectRoot = process.cwd()) {
-  const candidates = [
-    join18(projectRoot, ".zelari"),
-    join18(homedir9(), ".zelari-code", "workspace", hashProject(projectRoot))
-  ];
-  for (const candidate of candidates) {
-    if (isWritableDir(projectRoot) || candidate !== candidates[0]) {
-      ensureWorkspaceDir(candidate);
-      return candidate;
-    }
-  }
-  ensureWorkspaceDir(candidates[0]);
-  return candidates[0];
-}
-function hashProject(projectPath) {
-  return createHash6("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
-}
-function isWritableDir(dir) {
-  try {
-    if (!existsSync22(dir)) return false;
-    accessSync(dir, constants.W_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function ensureWorkspaceDir(workspaceDir) {
-  mkdirSync12(workspaceDir, { recursive: true });
-  if (workspaceDir.endsWith("/.zelari") && existsSync22(join18(workspaceDir, "..", ".git"))) {
-    const gitignorePath = join18(workspaceDir, ".gitignore");
-    if (!existsSync22(gitignorePath)) {
-      writeFileSync14(gitignorePath, "*\n!.gitignore\n");
-    }
-  }
-}
-function workspaceFile(rootDir, kind) {
-  switch (kind) {
-    case "plan":
-      return join18(rootDir, "plan.md");
-    case "risks":
-      return join18(rootDir, "risks.md");
-    case "index":
-      return join18(rootDir, "workspace.json");
-  }
-}
-function workspaceArtifact(rootDir, subdir, slug) {
-  return join18(rootDir, subdir, `${slug}.md`);
-}
-function projectName(projectRoot = process.cwd()) {
-  return basename(realpathSync(projectRoot));
-}
-var init_paths2 = __esm({
-  "src/cli/workspace/paths.ts"() {
-    "use strict";
-  }
-});
-
 // src/cli/workspace/workspaceSummary.ts
 var workspaceSummary_exports = {};
 __export(workspaceSummary_exports, {
@@ -35446,8 +36297,8 @@ __export(workspaceSummary_exports, {
   buildWorkspaceSummary: () => buildWorkspaceSummary,
   buildZelariReadHint: () => buildZelariReadHint
 });
-import { existsSync as existsSync23, readFileSync as readFileSync21, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
-import { join as join19, relative } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync23, readdirSync as readdirSync6, statSync as statSync4 } from "node:fs";
+import { join as join21, relative } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30, maxChars = 3500, maxDeps = 24, maxScripts = 16 } = options;
   const name = safeProjectName(projectRoot);
@@ -35480,11 +36331,11 @@ function formatTaskLine(t) {
 }
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  const planPath = join19(zelariRoot, "plan.json");
-  if (!existsSync23(planPath)) return null;
+  const planPath = join21(zelariRoot, "plan.json");
+  if (!existsSync25(planPath)) return null;
   let plan;
   try {
-    plan = JSON.parse(readFileSync21(planPath, "utf8"));
+    plan = JSON.parse(readFileSync23(planPath, "utf8"));
   } catch {
     return null;
   }
@@ -35498,7 +36349,10 @@ function buildPlanSummary(projectRoot = process.cwd(), options) {
     "# Plan ops (DRAFT \u2014 .zelari/plan.json)",
     "_This is operational task list from design, not product law. Ground every change in the real source tree._"
   ];
-  const open = tasks.filter((t) => t.status !== "done");
+  const open = tasks.filter((t) => {
+    const s = t.status;
+    return s !== "done" && s !== "completed" && s !== "cancelled";
+  });
   const done = tasks.length - open.length;
   const userMessage = options?.userMessage?.trim();
   let scopedOpen = open;
@@ -35620,8 +36474,8 @@ function pickNextTask(open) {
   )[0];
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
-  const planPath = join19(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync23(planPath)) return "";
+  const planPath = join21(resolveWorkspaceRoot(projectRoot), "plan.json");
+  if (!existsSync25(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/) \u2014 DRAFT vault",
     "`.zelari/plan.json` and `.zelari/docs/` hold **design hypotheses**, not verified product state.",
@@ -35636,10 +36490,10 @@ function safeProjectName(root) {
   }
 }
 function readPackageJson(projectRoot) {
-  const p3 = join19(projectRoot, "package.json");
-  if (!existsSync23(p3)) return null;
+  const p3 = join21(projectRoot, "package.json");
+  if (!existsSync25(p3)) return null;
   try {
-    return JSON.parse(readFileSync21(p3, "utf8"));
+    return JSON.parse(readFileSync23(p3, "utf8"));
   } catch {
     return null;
   }
@@ -35680,7 +36534,7 @@ function readBuildScripts(projectRoot, maxScripts = 16) {
 function listShallow(projectRoot, maxEntries) {
   const out = [];
   try {
-    const top = readdirSync5(projectRoot, { withFileTypes: true }).filter(
+    const top = readdirSync6(projectRoot, { withFileTypes: true }).filter(
       (e) => !e.name.startsWith(".") && e.name !== "node_modules" && e.name !== "dist"
     ).sort((a, b) => a.name.localeCompare(b.name));
     let count = 0;
@@ -35689,11 +36543,11 @@ function listShallow(projectRoot, maxEntries) {
         out.push(`\u2026 (+${top.length - count} more)`);
         break;
       }
-      const rel2 = relative(projectRoot, join19(projectRoot, entry.name));
+      const rel2 = relative(projectRoot, join21(projectRoot, entry.name));
       if (entry.isDirectory()) {
         let inner = "";
         try {
-          const sub = readdirSync5(join19(projectRoot, entry.name), {
+          const sub = readdirSync6(join21(projectRoot, entry.name), {
             withFileTypes: true
           }).filter((e) => !e.name.startsWith(".")).slice(0, 4).map((e) => e.name);
           if (sub.length > 0)
@@ -35741,12 +36595,12 @@ var init_workspaceSummary = __esm({
 });
 
 // src/cli/workspace/buildLessonsSummary.ts
-import { existsSync as existsSync24 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+import { join as join22 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync24(join20(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync26(join22(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -35767,8 +36621,8 @@ var composeContext_exports = {};
 __export(composeContext_exports, {
   composeProjectContext: () => composeProjectContext
 });
-import { existsSync as existsSync25, readdirSync as readdirSync6, readFileSync as readFileSync22 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync27, readdirSync as readdirSync7, readFileSync as readFileSync24 } from "node:fs";
+import { join as join23 } from "node:path";
 function cap2(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
   return {
@@ -35780,19 +36634,19 @@ function cap2(text, max, label) {
 }
 function buildDesignIndex(projectRoot, maxChars) {
   const root = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync25(root)) return "";
+  if (!existsSync27(root)) return "";
   const lines = [
     "# Design vault index (.zelari/) \u2014 HYPOTHESES only",
     "Full design docs are NOT product source of truth. Open with list_files / read_file / searchDocuments if needed."
   ];
-  const docsDir = join21(root, "docs");
-  if (existsSync25(docsDir)) {
+  const docsDir = join23(root, "docs");
+  if (existsSync27(docsDir)) {
     try {
-      const docs = readdirSync6(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
+      const docs = readdirSync7(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
       if (docs.length > 0) {
         lines.push("", "## docs/ (titles only)");
         for (const d of docs) lines.push(`- .zelari/docs/${d}`);
-        if (readdirSync6(docsDir).filter((n) => n.endsWith(".md")).length > 12) {
+        if (readdirSync7(docsDir).filter((n) => n.endsWith(".md")).length > 12) {
           lines.push("- \u2026 (more under .zelari/docs/)");
         }
       }
@@ -35800,14 +36654,14 @@ function buildDesignIndex(projectRoot, maxChars) {
     }
   }
   for (const name of ["risks.md", "plan.json", "nfr-spec.json"]) {
-    if (existsSync25(join21(root, name))) {
+    if (existsSync27(join23(root, name))) {
       lines.push(`- .zelari/${name} present`);
     }
   }
-  const decisionsDir = join21(root, "decisions");
-  if (existsSync25(decisionsDir)) {
+  const decisionsDir = join23(root, "decisions");
+  if (existsSync27(decisionsDir)) {
     try {
-      const n = readdirSync6(decisionsDir).filter((f) => f.endsWith(".md")).length;
+      const n = readdirSync7(decisionsDir).filter((f) => f.endsWith(".md")).length;
       if (n > 0) lines.push(`- .zelari/decisions/ (${n} ADR file(s) \u2014 treat proposed as non-binding)`);
     } catch {
     }
@@ -35906,17 +36760,17 @@ function composeProjectContext(input) {
 }
 function readDurableHeadSync(projectRoot) {
   try {
-    const headPath = join21(projectRoot, ".zelari", "state", "HEAD.json");
-    if (!existsSync25(headPath)) return "";
-    const head = JSON.parse(readFileSync22(headPath, "utf8"));
+    const headPath = join23(projectRoot, ".zelari", "state", "HEAD.json");
+    if (!existsSync27(headPath)) return "";
+    const head = JSON.parse(readFileSync24(headPath, "utf8"));
     if (!head?.id) return "";
-    const metaPath = join21(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
-    if (!existsSync25(metaPath)) return "";
-    const meta3 = JSON.parse(readFileSync22(metaPath, "utf8"));
-    const discPath = meta3.artifactDir ? join21(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join21(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
+    const metaPath = join23(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
+    if (!existsSync27(metaPath)) return "";
+    const meta3 = JSON.parse(readFileSync24(metaPath, "utf8"));
+    const discPath = meta3.artifactDir ? join23(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join23(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
     let discoveries = [];
-    if (existsSync25(discPath)) {
-      discoveries = JSON.parse(readFileSync22(discPath, "utf8"));
+    if (existsSync27(discPath)) {
+      discoveries = JSON.parse(readFileSync24(discPath, "utf8"));
     }
     const reusable = discoveries.filter((d) => d.reusable !== false);
     const lines = [
@@ -35949,13 +36803,13 @@ var planDetect_exports = {};
 __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
-import { existsSync as existsSync26, readFileSync as readFileSync23 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync25 } from "node:fs";
+import { join as join24 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
-  const planPath = join22(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync26(planPath)) return false;
+  const planPath = join24(resolveWorkspaceRoot(projectRoot), "plan.json");
+  if (!existsSync28(planPath)) return false;
   try {
-    const parsed = JSON.parse(readFileSync23(planPath, "utf8"));
+    const parsed = JSON.parse(readFileSync25(planPath, "utf8"));
     return Array.isArray(parsed.phases) && parsed.phases.length > 0;
   } catch {
     return false;
@@ -35986,8 +36840,8 @@ async function loadDurableContext(projectRoot, opts) {
     return cache.text;
   }
   try {
-    const store3 = await getStateStore(projectRoot, env);
-    const text = await store3.materializeContext(void 0, opts?.maxChars);
+    const store4 = await getStateStore(projectRoot, env);
+    const text = await store4.materializeContext(void 0, opts?.maxChars);
     cache = { text: text || "", at: now, projectRoot };
     return cache.text;
   } catch {
@@ -36004,333 +36858,6 @@ var init_loadDurableContext = __esm({
   }
 });
 
-// src/cli/workspace/storage.ts
-var storage_exports = {};
-__export(storage_exports, {
-  Storage: () => Storage,
-  parseFrontmatter: () => parseFrontmatter,
-  parseYaml: () => parseYaml,
-  serializeFrontmatter: () => serializeFrontmatter,
-  serializeYaml: () => serializeYaml,
-  workspaceMutex: () => workspaceMutex
-});
-import {
-  readFileSync as readFileSync24,
-  writeFileSync as writeFileSync15,
-  existsSync as existsSync27,
-  mkdirSync as mkdirSync13,
-  readdirSync as readdirSync7,
-  renameSync as renameSync2
-} from "node:fs";
-import { dirname as dirname4, join as join23 } from "node:path";
-function parseFrontmatter(md) {
-  const m = FRONTMATTER_RE.exec(md);
-  if (!m) return { meta: {}, body: md };
-  const meta3 = parseYaml(m[1]);
-  const body = m[2];
-  return { meta: meta3, body };
-}
-function serializeFrontmatter(meta3, body) {
-  const yamlStr = serializeYaml(meta3);
-  return `---
-${yamlStr}
----
-${body}`;
-}
-function parseYaml(input) {
-  const lines = input.split(/\r?\n/);
-  const ctx = { lines, i: 0 };
-  return parseNode(ctx, 0);
-}
-function parseNode(ctx, indent) {
-  while (ctx.i < ctx.lines.length) {
-    const line2 = ctx.lines[ctx.i];
-    if (line2.trim() === "" || line2.trim().startsWith("#")) {
-      ctx.i++;
-      continue;
-    }
-    break;
-  }
-  if (ctx.i >= ctx.lines.length) return null;
-  const line = ctx.lines[ctx.i];
-  const lineIndent = countIndent(line);
-  if (/^\s*-\s+/.test(line)) {
-    return parseBlockSequence(ctx, indent);
-  }
-  if (/^\s*\[.*\]\s*$/.test(line)) {
-    const flow = line.trim().replace(/^\[/, "").replace(/\]$/, "");
-    return parseFlowSequence(flow);
-  }
-  if (/^\s*\{.*\}\s*$/.test(line)) {
-    const flow = line.trim().replace(/^\{/, "").replace(/\}$/, "");
-    return parseFlowMap(flow);
-  }
-  return parseBlockMap(ctx, indent);
-}
-function parseBlockMap(ctx, indent) {
-  const out = {};
-  while (ctx.i < ctx.lines.length) {
-    const line = ctx.lines[ctx.i];
-    if (line.trim() === "" || line.trim().startsWith("#")) {
-      ctx.i++;
-      continue;
-    }
-    const lineIndent = countIndent(line);
-    if (lineIndent < indent) break;
-    if (lineIndent > indent) {
-      ctx.i++;
-      continue;
-    }
-    const m = /^([^:]+):\s*(.*)$/.exec(line);
-    if (!m) {
-      ctx.i++;
-      continue;
-    }
-    const key = m[1].trim();
-    const valuePart = m[2].trim();
-    if (valuePart === "" || valuePart === "|" || valuePart === ">") {
-      ctx.i++;
-      const nested = parseNode(ctx, indent + 2);
-      out[key] = nested;
-    } else {
-      if (valuePart.startsWith("[")) {
-        out[key] = parseFlowSequence(stripFlow(valuePart, "[", "]"));
-      } else if (valuePart.startsWith("{")) {
-        out[key] = parseFlowMap(stripFlow(valuePart, "{", "}"));
-      } else {
-        out[key] = parseScalar(valuePart);
-      }
-      ctx.i++;
-    }
-  }
-  return out;
-}
-function parseBlockSequence(ctx, indent) {
-  const out = [];
-  while (ctx.i < ctx.lines.length) {
-    const line = ctx.lines[ctx.i];
-    if (line.trim() === "") {
-      ctx.i++;
-      continue;
-    }
-    const lineIndent = countIndent(line);
-    if (lineIndent < indent) break;
-    if (lineIndent > indent) break;
-    const m = /^-\s*(.*)$/.exec(line);
-    if (!m) break;
-    const rest = m[1];
-    if (rest === "") {
-      ctx.i++;
-      out.push(parseNode(ctx, indent + 2));
-    } else if (rest.startsWith("[") || rest.startsWith("{")) {
-      let buffer = rest;
-      let depthSq = (buffer.match(/\[/g) || []).length - (buffer.match(/\]/g) || []).length;
-      let depthCu = (buffer.match(/\{/g) || []).length - (buffer.match(/\}/g) || []).length;
-      while ((depthSq > 0 || depthCu > 0) && ctx.i + 1 < ctx.lines.length) {
-        ctx.i++;
-        const next = ctx.lines[ctx.i].trim();
-        buffer += " " + next;
-        depthSq = (buffer.match(/\[/g) || []).length - (buffer.match(/\]/g) || []).length;
-        depthCu = (buffer.match(/\{/g) || []).length - (buffer.match(/\}/g) || []).length;
-      }
-      if (buffer.startsWith("[")) {
-        out.push(parseFlowSequence(buffer.slice(1).replace(/\]$/, "")));
-      } else {
-        out.push(parseFlowMap(buffer.slice(1).replace(/\}$/, "")));
-      }
-      ctx.i++;
-    } else if (rest.includes(":")) {
-      ctx.i++;
-      const mapCtx = { lines: [" ".repeat(indent + 2) + rest, ...ctx.lines.slice(ctx.i)], i: 0 };
-      const val = parseBlockMap(mapCtx, indent + 2);
-      ctx.i += mapCtx.i - 1;
-      out.push(val);
-    } else {
-      out.push(parseScalar(rest));
-      ctx.i++;
-    }
-  }
-  return out;
-}
-function parseFlowSequence(input) {
-  const parts = splitFlow(input);
-  return parts.map((p3) => {
-    const trimmed = p3.trim();
-    if (trimmed.startsWith("{")) {
-      return parseFlowMap(stripFlow(trimmed, "{", "}"));
-    }
-    return parseScalar(trimmed);
-  });
-}
-function stripFlow(s, open, close) {
-  let out = s.trim();
-  if (out.startsWith(open)) out = out.slice(1);
-  if (out.endsWith(close)) out = out.slice(0, -1);
-  return out;
-}
-function parseFlowMap(input) {
-  const parts = splitFlow(input);
-  const out = {};
-  for (const p3 of parts) {
-    const colonIdx = p3.indexOf(":");
-    if (colonIdx < 0) continue;
-    const key = p3.slice(0, colonIdx).trim();
-    const value = p3.slice(colonIdx + 1).trim();
-    out[key] = parseScalar(value);
-  }
-  return out;
-}
-function splitFlow(input) {
-  const out = [];
-  let depthSq = 0, depthCu = 0, depthQu = 0;
-  let buffer = "";
-  for (let i = 0; i < input.length; i++) {
-    const c = input[i];
-    if (c === '"' || c === "'") {
-      depthQu = depthQu === 0 ? depthQu + 1 : 0;
-      buffer += c;
-    } else if (depthQu === 0) {
-      if (c === "[") depthSq++;
-      else if (c === "]") depthSq--;
-      else if (c === "{") depthCu++;
-      else if (c === "}") depthCu--;
-      else if (c === "," && depthSq === 0 && depthCu === 0) {
-        out.push(buffer);
-        buffer = "";
-        continue;
-      }
-      buffer += c;
-    } else {
-      buffer += c;
-    }
-  }
-  if (buffer.trim()) out.push(buffer);
-  return out;
-}
-function parseScalar(s) {
-  if (s === "" || s === "null" || s === "~") return null;
-  if (VALID_SCALARS.test(s)) return s.toLowerCase() === "true";
-  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
-  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
-function serializeYaml(value, indent = 0) {
-  if (value === null || value === void 0) return "";
-  if (typeof value === "string") {
-    if (/[:#\n\[\]\{\},&*!|>'"%@`]/.test(value)) {
-      return JSON.stringify(value);
-    }
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "[]";
-    if (value.every((v) => v === null || typeof v !== "object")) {
-      return `[${value.map(serializeScalarInline).join(", ")}]`;
-    }
-    return `[${value.map((v) => "{" + serializeInlineObject(v) + "}").join(", ")}]`;
-  }
-  if (typeof value === "object") {
-    const entries = Object.entries(value).filter(([, v]) => v !== void 0);
-    return entries.map(([k, v]) => {
-      if (v === null || v === void 0) return `${k}:`;
-      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-        return `${k}: ${serializeScalarInline(v)}`;
-      }
-      if (Array.isArray(v)) {
-        if (v.length === 0) return `${k}: []`;
-        if (v.every((x) => x === null || typeof x !== "object")) {
-          return `${k}: [${v.map(serializeScalarInline).join(", ")}]`;
-        }
-        return `${k}: [${v.map((x) => "{" + serializeInlineObject(x) + "}").join(", ")}]`;
-      }
-      return `${k}:
-${serializeYaml(v, indent + 2)}`;
-    }).map((line) => `${" ".repeat(indent)}${line}`).join("\n");
-  }
-  return String(value);
-}
-function serializeScalarInline(v) {
-  if (typeof v === "string" && /[:#\n\[\]\{\},&*!|>'"%@`]/.test(v)) return JSON.stringify(v);
-  return String(v);
-}
-function serializeInlineObject(v) {
-  if (v === null || typeof v !== "object" || Array.isArray(v)) {
-    return serializeScalarInline(v);
-  }
-  const entries = Object.entries(v).filter(([, val]) => val !== void 0);
-  return entries.map(([k, val]) => `${k}: ${serializeYaml(val)}`).join(", ");
-}
-function countIndent(line) {
-  let i = 0;
-  while (i < line.length && line[i] === " ") i++;
-  return i;
-}
-var FRONTMATTER_RE, VALID_SCALARS, Storage, KeyedMutex, workspaceMutex;
-var init_storage = __esm({
-  "src/cli/workspace/storage.ts"() {
-    "use strict";
-    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-    VALID_SCALARS = /^(true|false|null|~)$/i;
-    Storage = class {
-      /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path53) {
-        if (!existsSync27(path53)) {
-          throw new Error(`File not found: ${path53}`);
-        }
-        const md = readFileSync24(path53, "utf8");
-        return parseFrontmatter(md);
-      }
-      /** Read a Markdown file; returns null if not found. */
-      readIfExists(path53) {
-        if (!existsSync27(path53)) return null;
-        return this.read(path53);
-      }
-      /**
-       * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
-       * The meta object is serialized as YAML frontmatter; body as Markdown.
-       */
-      write(path53, meta3, body) {
-        mkdirSync13(dirname4(path53), { recursive: true });
-        const tmp = path53 + ".tmp-" + process.pid;
-        const md = serializeFrontmatter(meta3, body);
-        writeFileSync15(tmp, md, "utf8");
-        renameSync2(tmp, path53);
-      }
-      /** List all .md files in a directory (non-recursive). */
-      listMarkdown(dir) {
-        if (!existsSync27(dir)) return [];
-        return readdirSync7(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join23(dir, f));
-      }
-    };
-    KeyedMutex = class {
-      chains = /* @__PURE__ */ new Map();
-      async run(key, fn) {
-        const prev2 = this.chains.get(key) ?? Promise.resolve();
-        let release = () => {
-        };
-        const next = new Promise((resolve3) => {
-          release = resolve3;
-        });
-        const chained = prev2.then(() => next);
-        this.chains.set(key, chained);
-        await prev2;
-        try {
-          return await fn();
-        } finally {
-          release();
-          if (this.chains.get(key) === chained) {
-            this.chains.delete(key);
-          }
-        }
-      }
-    };
-    workspaceMutex = new KeyedMutex();
-  }
-});
-
 // src/cli/workspace/stubs.ts
 var stubs_exports = {};
 __export(stubs_exports, {
@@ -36341,14 +36868,14 @@ __export(stubs_exports, {
   resolveWorkspaceRoot: () => resolveWorkspaceRoot
 });
 import {
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   readdirSync as readdirSync8,
-  writeFileSync as writeFileSync16,
-  readFileSync as readFileSync25,
-  mkdirSync as mkdirSync14,
-  renameSync as renameSync3
+  writeFileSync as writeFileSync17,
+  readFileSync as readFileSync26,
+  mkdirSync as mkdirSync15,
+  renameSync as renameSync4
 } from "node:fs";
-import { join as join24, basename as basename2, dirname as dirname5, relative as relative2 } from "node:path";
+import { join as join25, basename as basename2, dirname as dirname6, relative as relative2 } from "node:path";
 function createWorkspaceContext(projectRoot = process.cwd()) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return {
@@ -36358,19 +36885,21 @@ function createWorkspaceContext(projectRoot = process.cwd()) {
   };
 }
 function planJsonPath(ctx) {
-  return join24(ctx.rootDir, "plan.json");
+  return join25(ctx.rootDir, "plan.json");
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
-  if (existsSync28(jsonPath)) {
+  if (existsSync29(jsonPath)) {
     try {
       const parsed = JSON.parse(
-        readFileSync25(jsonPath, "utf8")
+        readFileSync26(jsonPath, "utf8")
       );
+      const { phases, tasks, milestones, ...root } = parsed;
       return {
-        phases: Array.isArray(parsed.phases) ? parsed.phases : [],
-        tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
-        milestones: Array.isArray(parsed.milestones) ? parsed.milestones : []
+        phases: Array.isArray(phases) ? phases : [],
+        tasks: Array.isArray(tasks) ? tasks : [],
+        milestones: Array.isArray(milestones) ? milestones : [],
+        root
       };
     } catch {
     }
@@ -36387,10 +36916,23 @@ function readPlan(ctx) {
 }
 function writePlan(ctx, summary) {
   const jsonPath = planJsonPath(ctx);
-  mkdirSync14(dirname5(jsonPath), { recursive: true });
+  mkdirSync15(dirname6(jsonPath), { recursive: true });
   const tmp = jsonPath + ".tmp-" + process.pid;
-  writeFileSync16(tmp, JSON.stringify(summary, null, 2), "utf8");
-  renameSync3(tmp, jsonPath);
+  writeFileSync17(
+    tmp,
+    JSON.stringify(
+      {
+        ...summary.root ?? {},
+        phases: summary.phases,
+        tasks: summary.tasks,
+        milestones: summary.milestones
+      },
+      null,
+      2
+    ),
+    "utf8"
+  );
+  renameSync4(tmp, jsonPath);
   const mdPath = workspaceFile(ctx.rootDir, "plan");
   const summaryMeta = {
     kind: "plan-summary",
@@ -36456,8 +36998,8 @@ function renderPlanBody(summary) {
   return lines.join("\n");
 }
 function nextAdrId(ctx) {
-  const decisionsDir = join24(ctx.rootDir, "decisions");
-  if (!existsSync28(decisionsDir)) return "001";
+  const decisionsDir = join25(ctx.rootDir, "decisions");
+  if (!existsSync29(decisionsDir)) return "001";
   const existing = readdirSync8(decisionsDir).filter((f) => f.endsWith(".md")).map((f) => f.match(/^(\d+)-/)).filter((m) => !!m).map((m) => parseInt(m[1], 10));
   const max = existing.length === 0 ? 0 : Math.max(...existing);
   return String(max + 1).padStart(3, "0");
@@ -36499,7 +37041,7 @@ function addTaskRecord(ctx, summary, phaseId, t, options) {
     status: "pending",
     priority: t.priority
   });
-  const taskPath = join24(ctx.rootDir, "plan-tasks", `${id}.md`);
+  const taskPath = join25(ctx.rootDir, "plan-tasks", `${id}.md`);
   const meta3 = {
     kind: "task",
     id,
@@ -36541,7 +37083,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path53 = join24(ctx.rootDir, "milestones", `${id}.md`);
+  const path53 = join25(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -36839,8 +37381,8 @@ function createNfrSpecStub(ctx) {
           },
           planFeatureKeywords: Array.isArray(args["planFeatureKeywords"]) ? args["planFeatureKeywords"] : void 0
         };
-        const outPath = join24(ctx.rootDir, "nfr-spec.json");
-        writeFileSync16(outPath, JSON.stringify(spec, null, 2), "utf8");
+        const outPath = join25(ctx.rootDir, "nfr-spec.json");
+        writeFileSync17(outPath, JSON.stringify(spec, null, 2), "utf8");
         return `NFR spec written to nfr-spec.json (${targets.length} target(s)).`;
       });
     }
@@ -36903,18 +37445,18 @@ function searchDocumentsStub(ctx) {
         (w) => w.length >= 3 && w !== "or" && w !== "and" && w !== "the"
       );
       const files = [
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "reviews")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "plan-tasks")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "milestones")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "reviews")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "plan-tasks")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "milestones")),
         workspaceFile(ctx.rootDir, "plan"),
         workspaceFile(ctx.rootDir, "risks")
       ];
       const results = [];
       for (const file2 of files) {
-        if (!existsSync28(file2)) continue;
-        const raw = readFileSync25(file2, "utf8");
+        if (!existsSync29(file2)) continue;
+        const raw = readFileSync26(file2, "utf8");
         const content = raw.toLowerCase();
         let idx = -1;
         let matchLen = 0;
@@ -36965,9 +37507,9 @@ function linkDocumentsStub(ctx) {
         const toId = args["toId"] ?? args["targetId"] ?? args["targetPathOrTitle"];
         if (!fromId || !toId) return "linkDocuments requires fromId and toId.";
         const allFiles = [
-          ...ctx.storage.listMarkdown(join24(ctx.rootDir, "decisions")),
-          ...ctx.storage.listMarkdown(join24(ctx.rootDir, "docs")),
-          ...ctx.storage.listMarkdown(join24(ctx.rootDir, "reviews"))
+          ...ctx.storage.listMarkdown(join25(ctx.rootDir, "decisions")),
+          ...ctx.storage.listMarkdown(join25(ctx.rootDir, "docs")),
+          ...ctx.storage.listMarkdown(join25(ctx.rootDir, "reviews"))
         ];
         const source = allFiles.find((f) => {
           try {
@@ -36998,9 +37540,9 @@ function getDocumentBacklinksStub(ctx) {
       const targetId = args["targetId"] ?? args["id"];
       if (!targetId) return "getDocumentBacklinks requires targetId.";
       const allFiles = [
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "reviews"))
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "reviews"))
       ];
       const backlinks = [];
       for (const file2 of allFiles) {
@@ -37095,7 +37637,7 @@ __export(updater_exports, {
 });
 import { createRequire as createRequire2 } from "node:module";
 import { spawn as spawn8 } from "node:child_process";
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 import path31 from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveBundledNpmCli(execPath = process.execPath) {
@@ -37108,7 +37650,7 @@ function resolveBundledNpmCli(execPath = process.execPath) {
   ];
   for (const candidate of candidates) {
     try {
-      if (existsSync29(candidate)) return candidate;
+      if (existsSync30(candidate)) return candidate;
     } catch {
     }
   }
@@ -37408,23 +37950,23 @@ var init_mcpClient = __esm({
 
 // src/cli/mcp/mcpConfigIo.ts
 import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync15,
-  readFileSync as readFileSync26,
-  writeFileSync as writeFileSync17
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync16,
+  readFileSync as readFileSync27,
+  writeFileSync as writeFileSync18
 } from "node:fs";
-import { dirname as dirname6, join as join25 } from "node:path";
+import { dirname as dirname7, join as join26 } from "node:path";
 import { homedir as homedir10 } from "node:os";
 function getUserMcpPath() {
-  return join25(homedir10(), ".zelari-code", "mcp.json");
+  return join26(homedir10(), ".zelari-code", "mcp.json");
 }
 function getProjectMcpPath(projectRoot) {
-  return join25(projectRoot, ".zelari", "mcp.json");
+  return join26(projectRoot, ".zelari", "mcp.json");
 }
 function readFile2(path53) {
-  if (!existsSync30(path53)) return {};
+  if (!existsSync31(path53)) return {};
   try {
-    const parsed = JSON.parse(readFileSync26(path53, "utf8"));
+    const parsed = JSON.parse(readFileSync27(path53, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -37441,9 +37983,9 @@ function readFile2(path53) {
   }
 }
 function writeFile(path53, servers) {
-  mkdirSync15(dirname6(path53), { recursive: true });
+  mkdirSync16(dirname7(path53), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync17(path53, `${JSON.stringify(body, null, 2)}
+  writeFileSync18(path53, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -37652,22 +38194,22 @@ __export(mcpManager_exports, {
   readMcpConfig: () => readMcpConfig,
   registerMcpTools: () => registerMcpTools
 });
-import { existsSync as existsSync31, readFileSync as readFileSync27 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync28 } from "node:fs";
+import { join as join27 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 function readMcpConfig(projectRoot = process.cwd(), opts) {
   const merged = {};
   const paths = [];
   if (process.env["ZELARI_MCP_USER"] !== "0") {
-    paths.push(join26(homedir11(), ".zelari-code", "mcp.json"));
+    paths.push(join27(homedir11(), ".zelari-code", "mcp.json"));
   }
   if (!opts?.skipProjectMcp) {
-    paths.push(join26(projectRoot, ".zelari", "mcp.json"));
+    paths.push(join27(projectRoot, ".zelari", "mcp.json"));
   }
   for (const p3 of paths) {
-    if (!existsSync31(p3)) continue;
+    if (!existsSync32(p3)) continue;
     try {
-      const parsed = JSON.parse(readFileSync27(p3, "utf8"));
+      const parsed = JSON.parse(readFileSync28(p3, "utf8"));
       for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
         if (!cfg || typeof cfg.command !== "string" || cfg.command.length === 0) continue;
         merged[name] = cfg;
@@ -37681,7 +38223,7 @@ async function ensureLoaded(projectRoot) {
   if (state2.loaded) return;
   state2.loaded = true;
   const trusted = isFolderTrusted(projectRoot);
-  if (!trusted && existsSync31(join26(projectRoot, ".zelari", "mcp.json"))) {
+  if (!trusted && existsSync32(join27(projectRoot, ".zelari", "mcp.json"))) {
     state2.warnings.push(
       "[mcp] project .zelari/mcp.json ignored \u2014 folder not trusted (run /trust or `zelari-code --trust` to enable project MCP)"
     );
@@ -37906,13 +38448,13 @@ __export(agentsMd_exports, {
   serializeAgentsMd: () => serializeAgentsMd,
   updateAgentsMd: () => updateAgentsMd
 });
-import { existsSync as existsSync32, readFileSync as readFileSync28, writeFileSync as writeFileSync18 } from "node:fs";
-import { createHash as createHash7 } from "node:crypto";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync33, readFileSync as readFileSync29, writeFileSync as writeFileSync19 } from "node:fs";
+import { createHash as createHash8 } from "node:crypto";
+import { join as join28 } from "node:path";
 import { readFile as readFile3 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path53 = join27(projectRoot, "package.json");
-  if (!existsSync32(path53)) return null;
+  const path53 = join28(projectRoot, "package.json");
+  if (!existsSync33(path53)) return null;
   try {
     return JSON.parse(await readFile3(path53, "utf8"));
   } catch {
@@ -37936,8 +38478,8 @@ async function genTechStack(ctx) {
   ].join("\n");
 }
 async function genDecisions(ctx) {
-  const decisionsDir = join27(ctx.rootDir, "decisions");
-  if (!existsSync32(decisionsDir)) return "_No ADRs yet._";
+  const decisionsDir = join28(ctx.rootDir, "decisions");
+  if (!existsSync33(decisionsDir)) return "_No ADRs yet._";
   const files = ctx.storage.listMarkdown(decisionsDir).sort();
   const accepted = [];
   const proposed = [];
@@ -37962,9 +38504,9 @@ async function genDecisions(ctx) {
 }
 async function genConventions(ctx) {
   const lines = [];
-  const claudeMd = join27(ctx.projectRoot, "CLAUDE.MD");
-  if (existsSync32(claudeMd)) {
-    const content = readFileSync28(claudeMd, "utf8");
+  const claudeMd = join28(ctx.projectRoot, "CLAUDE.MD");
+  if (existsSync33(claudeMd)) {
+    const content = readFileSync29(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
     if (match) {
       lines.push('<!-- Extracted from CLAUDE.MD "Architecture rules" -->');
@@ -37996,9 +38538,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path53 = join27(ctx.rootDir, "risks.md");
-  if (!existsSync32(path53)) return "_No open questions._";
-  const content = readFileSync28(path53, "utf8");
+  const path53 = join28(ctx.rootDir, "risks.md");
+  if (!existsSync33(path53)) return "_No open questions._";
+  const content = readFileSync29(path53, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -38072,9 +38614,9 @@ function titleCase(id) {
   return id.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
 }
 async function updateAgentsMd(ctx, projectRoot) {
-  const agentsPath = join27(projectRoot, "AGENTS.MD");
-  if (existsSync32(agentsPath)) {
-    const content = readFileSync28(agentsPath, "utf8");
+  const agentsPath = join28(projectRoot, "AGENTS.MD");
+  if (existsSync33(agentsPath)) {
+    const content = readFileSync29(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id) => content.includes(MARKER_OPEN(id)));
     if (!hasAnyMarker) {
       return {
@@ -38089,8 +38631,8 @@ async function updateAgentsMd(ctx, projectRoot) {
     newSections.set(id, await GENERATORS[id](ctx));
   }
   let manualContent = "";
-  if (existsSync32(agentsPath)) {
-    const { manualBlocks } = parseAgentsMd(readFileSync28(agentsPath, "utf8"));
+  if (existsSync33(agentsPath)) {
+    const { manualBlocks } = parseAgentsMd(readFileSync29(agentsPath, "utf8"));
     manualContent = manualBlocks.after;
   } else {
     const projectName2 = projectName(projectRoot);
@@ -38106,7 +38648,7 @@ async function updateAgentsMd(ctx, projectRoot) {
       ""
     ].join("\n");
   }
-  const oldContent = existsSync32(agentsPath) ? readFileSync28(agentsPath, "utf8") : "";
+  const oldContent = existsSync33(agentsPath) ? readFileSync29(agentsPath, "utf8") : "";
   const { sections: oldSections } = parseAgentsMd(oldContent);
   const changedSections = [];
   for (const id of AUTO_SECTIONS) {
@@ -38118,11 +38660,11 @@ async function updateAgentsMd(ctx, projectRoot) {
     return { changed: false, sections: [] };
   }
   const newContent = serializeAgentsMd(manualContent, newSections);
-  writeFileSync18(agentsPath, newContent, "utf8");
+  writeFileSync19(agentsPath, newContent, "utf8");
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
-  return createHash7("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash8("sha256").update(s).digest("hex").slice(0, 16);
 }
 var AUTO_SECTIONS, MARKER_OPEN, MARKER_CLOSE, GENERATORS;
 var init_agentsMd = __esm({
@@ -38244,8 +38786,8 @@ var init_completeDesign = __esm({
 
 // src/cli/workspace/projectSmoke.ts
 import { spawn as spawn10 } from "node:child_process";
-import { existsSync as existsSync33, readFileSync as readFileSync29 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync34, readFileSync as readFileSync30 } from "node:fs";
+import { join as join29 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
   for (const name of SMOKE_SCRIPT_PRIORITY) {
@@ -38257,13 +38799,13 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS2) {
   if (process.env["ZELARI_SMOKE"] === "0") {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
-  const pkgPath = join28(projectRoot, "package.json");
-  if (!existsSync33(pkgPath)) {
+  const pkgPath = join29(projectRoot, "package.json");
+  if (!existsSync34(pkgPath)) {
     return { ran: false, reason: "no package.json (skipped)" };
   }
   let scripts = {};
   try {
-    const pkg = JSON.parse(readFileSync29(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync30(pkgPath, "utf8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return { ran: false, reason: "package.json unreadable (skipped)" };
@@ -38351,8 +38893,8 @@ __export(postCouncilHook_exports, {
   runPostCouncilHook: () => runPostCouncilHook
 });
 import { spawn as spawn11 } from "node:child_process";
-import { existsSync as existsSync34, readFileSync as readFileSync30 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync35, readFileSync as readFileSync31 } from "node:fs";
+import { join as join30 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
     return {
@@ -38363,9 +38905,9 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (process.env["ZELARI_COMPLETE_DESIGN"] === "0") {
     return { ran: false, reason: "ZELARI_COMPLETE_DESIGN=0 (disabled)" };
   }
-  const planJsonPath2 = join29(ctx.rootDir, "plan.json");
-  const scriptPath = join29(ctx.projectRoot, "complete-design.mjs");
-  if (!existsSync34(planJsonPath2)) {
+  const planJsonPath2 = join30(ctx.rootDir, "plan.json");
+  const scriptPath = join30(ctx.projectRoot, "complete-design.mjs");
+  if (!existsSync35(planJsonPath2)) {
     return {
       ran: false,
       reason: ".zelari/plan.json missing (not design-phase)"
@@ -38373,7 +38915,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   }
   let phaseCount = 0;
   try {
-    const parsed = JSON.parse(readFileSync30(planJsonPath2, "utf8"));
+    const parsed = JSON.parse(readFileSync31(planJsonPath2, "utf8"));
     phaseCount = Array.isArray(parsed.phases) ? parsed.phases.length : 0;
   } catch {
     return { ran: false, reason: ".zelari/plan.json corrupt" };
@@ -38381,7 +38923,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (phaseCount === 0) {
     return { ran: false, reason: ".zelari/plan.json has no phases" };
   }
-  if (!existsSync34(scriptPath)) {
+  if (!existsSync35(scriptPath)) {
     try {
       const builtin = await runBuiltinCompleteDesign(ctx);
       return {
@@ -38604,10 +39146,10 @@ __export(councilFeedback_exports, {
 });
 import {
   promises as fs16,
-  existsSync as existsSync35,
-  readFileSync as readFileSync31,
-  writeFileSync as writeFileSync19,
-  mkdirSync as mkdirSync16
+  existsSync as existsSync36,
+  readFileSync as readFileSync32,
+  writeFileSync as writeFileSync20,
+  mkdirSync as mkdirSync17
 } from "node:fs";
 import path32 from "node:path";
 import os9 from "node:os";
@@ -38713,9 +39255,9 @@ var init_councilFeedback = __esm({
       }
       // --- persistence ---------------------------------------------------------
       load() {
-        if (!existsSync35(this.file)) return;
+        if (!existsSync36(this.file)) return;
         try {
-          const raw = readFileSync31(this.file, "utf-8");
+          const raw = readFileSync32(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -38726,8 +39268,8 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync16(path32.dirname(this.file), { recursive: true });
-        writeFileSync19(
+        mkdirSync17(path32.dirname(this.file), { recursive: true });
+        writeFileSync20(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
           { encoding: "utf-8", mode: 384 }
@@ -38933,7 +39475,7 @@ __export(commitHelpers_exports, {
 });
 async function tryStateCommit(args) {
   try {
-    const store3 = args.store ?? await getStateStore(args.projectRoot, args.env);
+    const store4 = args.store ?? await getStateStore(args.projectRoot, args.env);
     let workspaceCheckpointId = args.workspaceCheckpointId;
     if (!workspaceCheckpointId && args.withCheckpoint && (args.env ?? process.env).ZELARI_CHECKPOINT !== "0") {
       const cp = await createCheckpoint(
@@ -38942,7 +39484,7 @@ async function tryStateCommit(args) {
       );
       if (cp.ok) workspaceCheckpointId = cp.value.id;
     }
-    const meta3 = await store3.commit({
+    const meta3 = await store4.commit({
       mode: args.mode,
       label: args.label,
       layer: args.layer,
@@ -41153,7 +41695,7 @@ __export(executor_exports, {
   resolveNodeTimeoutMs: () => resolveNodeTimeoutMs,
   thoroughnessForKind: () => thoroughnessForKind
 });
-import { existsSync as existsSync36 } from "node:fs";
+import { existsSync as existsSync37 } from "node:fs";
 import path40 from "node:path";
 function resolveMaxParallel(env = process.env) {
   const raw = env.ZELARI_KRAKEN_MAX_PARALLEL;
@@ -41212,7 +41754,7 @@ function isWorldModelGateEnabled(cwd, env = process.env, checksExists = defaultC
 }
 function defaultChecksExists(cwd) {
   try {
-    return existsSync36(path40.join(cwd, ".zelari", "world", "checks.json"));
+    return existsSync37(path40.join(cwd, ".zelari", "world", "checks.json"));
   } catch {
     return false;
   }
@@ -42179,8 +42721,8 @@ __export(prereqChecks_exports, {
   runPrereqChecks: () => runPrereqChecks
 });
 import { execSync, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync37 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { existsSync as existsSync38 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
 function isWslBashPath2(p3) {
   if (!p3 || typeof p3 !== "string") return false;
   const n = p3.replace(/\//g, "\\").toLowerCase();
@@ -42286,7 +42828,7 @@ function resolveAgentShellSync() {
 function agentProbeEnv() {
   const env = { ...process.env };
   try {
-    const nodeDir = dirname7(process.execPath);
+    const nodeDir = dirname8(process.execPath);
     if (!nodeDir) return env;
     const sep2 = process.platform === "win32" ? ";" : ":";
     const current = env.PATH ?? env.Path ?? "";
@@ -42303,7 +42845,7 @@ function agentProbeEnv() {
 }
 function existsSyncSafe2(p3) {
   try {
-    return existsSync37(p3);
+    return existsSync38(p3);
   } catch {
     return false;
   }
@@ -42550,7 +43092,7 @@ var init_prereqChecks = __esm({
 });
 
 // src/cli/plugins/prefs.ts
-import { existsSync as existsSync38, readFileSync as readFileSync32, writeFileSync as writeFileSync20, mkdirSync as mkdirSync17 } from "node:fs";
+import { existsSync as existsSync39, readFileSync as readFileSync33, writeFileSync as writeFileSync21, mkdirSync as mkdirSync18 } from "node:fs";
 import path43 from "node:path";
 import os10 from "node:os";
 function getPluginPrefsPath() {
@@ -42559,8 +43101,8 @@ function getPluginPrefsPath() {
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
   try {
-    if (!existsSync38(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
-    const raw = readFileSync32(file2, "utf-8");
+    if (!existsSync39(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
+    const raw = readFileSync33(file2, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && parsed.dontAskAgain && typeof parsed.dontAskAgain === "object") {
       const clean = {};
@@ -42575,8 +43117,8 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync17(path43.dirname(file2), { recursive: true });
-  writeFileSync20(file2, JSON.stringify(prefs, null, 2), {
+  mkdirSync18(path43.dirname(file2), { recursive: true });
+  writeFileSync21(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
@@ -42611,7 +43153,7 @@ __export(registry_exports, {
   findPlugin: () => findPlugin,
   isBinaryOnPath: () => isBinaryOnPath
 });
-import { existsSync as existsSync39 } from "node:fs";
+import { existsSync as existsSync40 } from "node:fs";
 import path44 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
@@ -42628,7 +43170,7 @@ function isBinaryOnPath(bin, opts = {}) {
     return false;
   }
   const platform = opts.platform ?? process.platform;
-  const exists = opts.exists ?? existsSync39;
+  const exists = opts.exists ?? existsSync40;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
   const pathMod = platform === "win32" ? path44.win32 : path44.posix;
   const sep2 = platform === "win32" ? ";" : ":";
@@ -43362,7 +43904,7 @@ __export(atMentions_exports, {
   extractAtMentions: () => extractAtMentions,
   hasAtMentions: () => hasAtMentions
 });
-import { existsSync as existsSync42, readFileSync as readFileSync34, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync43, readFileSync as readFileSync35, statSync as statSync7 } from "node:fs";
 import { basename as basename3, isAbsolute as isAbsolute2, relative as relative3, resolve, sep } from "node:path";
 function isImagePath(abs) {
   const ext = abs.split(".").pop()?.toLowerCase() ?? "";
@@ -43416,7 +43958,7 @@ function resolveMention(token, cwd) {
       note: "outside project root \u2014 skipped"
     };
   }
-  if (!existsSync42(abs)) {
+  if (!existsSync43(abs)) {
     return {
       raw: token,
       path: token,
@@ -43468,7 +44010,7 @@ function resolveMention(token, cwd) {
         note: `image too large (${Math.round(st.size / 1024)} KB) \u2014 path only`
       };
     }
-    const dataBase64 = readFileSync34(abs).toString("base64");
+    const dataBase64 = readFileSync35(abs).toString("base64");
     return {
       raw: token,
       path: rel2,
@@ -43479,7 +44021,7 @@ function resolveMention(token, cwd) {
     };
   }
   try {
-    const buf = readFileSync34(abs);
+    const buf = readFileSync35(abs);
     const head = buf.subarray(0, 800).toString("utf8");
     if (!isProbablyText(abs, head)) {
       return {
@@ -43976,14 +44518,14 @@ var init_skillCategories = __esm({
 
 // src/cli/skillConfigIo.ts
 import {
-  existsSync as existsSync44,
-  mkdirSync as mkdirSync20,
+  existsSync as existsSync45,
+  mkdirSync as mkdirSync21,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync36,
+  readFileSync as readFileSync37,
   rmSync as rmSync4,
-  writeFileSync as writeFileSync22
+  writeFileSync as writeFileSync23
 } from "node:fs";
-import { dirname as dirname9, join as join35 } from "node:path";
+import { dirname as dirname10, join as join36 } from "node:path";
 import { homedir as homedir12 } from "node:os";
 function ensureBuiltinSkillsLoadedSync() {
   if (builtinsLoaded) return;
@@ -43995,13 +44537,13 @@ function ensureBuiltinSkillsLoadedSync() {
   }
 }
 function getUserSkillsDir() {
-  return join35(homedir12(), ".zelari-code", "skills");
+  return join36(homedir12(), ".zelari-code", "skills");
 }
 function getProjectSkillsDir(projectRoot) {
-  return join35(projectRoot, ".zelari", "skills");
+  return join36(projectRoot, ".zelari", "skills");
 }
 function skillFilePath(dir, name) {
-  return join35(dir, name, "SKILL.md");
+  return join36(dir, name, "SKILL.md");
 }
 function classifyScope(skillPath, projectRoot) {
   const userDir = getUserSkillsDir().replace(/\\/g, "/");
@@ -44050,7 +44592,7 @@ function entryFromBuiltin(skill) {
   };
 }
 function scanSkillsDir(dir, projectRoot, seen, out) {
-  if (!existsSync44(dir)) return;
+  if (!existsSync45(dir)) return;
   let entries;
   try {
     entries = readdirSync9(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -44059,9 +44601,9 @@ function scanSkillsDir(dir, projectRoot, seen, out) {
   }
   for (const entry of entries) {
     const skillPath = skillFilePath(dir, entry);
-    if (!existsSync44(skillPath)) continue;
+    if (!existsSync45(skillPath)) continue;
     try {
-      const parsed = parseSkillMd(readFileSync36(skillPath, "utf8"), skillPath);
+      const parsed = parseSkillMd(readFileSync37(skillPath, "utf8"), skillPath);
       if (!parsed) continue;
       if (seen.has(parsed.name)) continue;
       seen.add(parsed.name);
@@ -44077,9 +44619,9 @@ function listSkillsSnapshot(projectRoot) {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
   if (root) {
-    scanSkillsDir(join35(root, ".zelari", "skills"), root, seen, skills);
-    scanSkillsDir(join35(root, ".claude", "skills"), root, seen, skills);
-    scanSkillsDir(join35(root, ".opencode", "skills"), root, seen, skills);
+    scanSkillsDir(join36(root, ".zelari", "skills"), root, seen, skills);
+    scanSkillsDir(join36(root, ".claude", "skills"), root, seen, skills);
+    scanSkillsDir(join36(root, ".opencode", "skills"), root, seen, skills);
   }
   scanSkillsDir(userSkillsDir, root, seen, skills);
   for (const s of listCodingSkills()) {
@@ -44158,8 +44700,8 @@ function upsertSkill(opts) {
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync20(dirname9(path53), { recursive: true });
-  writeFileSync22(path53, content, "utf8");
+  mkdirSync21(dirname10(path53), { recursive: true });
+  writeFileSync23(path53, content, "utf8");
   return { ok: true, path: path53 };
 }
 function removeSkill(opts) {
@@ -44177,9 +44719,9 @@ function removeSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const skillDir = join35(dir, name);
+  const skillDir = join36(dir, name);
   const path53 = skillFilePath(dir, name);
-  if (!existsSync44(path53) && !existsSync44(skillDir)) {
+  if (!existsSync45(path53) && !existsSync45(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -44484,36 +45026,36 @@ var init_permissionCli = __esm({
 
 // src/cli/companion/config.ts
 import {
-  existsSync as existsSync45,
-  mkdirSync as mkdirSync21,
-  readFileSync as readFileSync37,
-  writeFileSync as writeFileSync23
+  existsSync as existsSync46,
+  mkdirSync as mkdirSync22,
+  readFileSync as readFileSync38,
+  writeFileSync as writeFileSync24
 } from "node:fs";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 import { homedir as homedir13 } from "node:os";
-import { createHash as createHash8, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
+import { createHash as createHash9, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
-  return join36(homedir13(), ".zelari-code");
+  return join37(homedir13(), ".zelari-code");
 }
 function getCompanionConfigPath() {
-  return join36(getZelariHome(), "companion.json");
+  return join37(getZelariHome(), "companion.json");
 }
 function getCompanionTokenPath() {
-  return join36(getZelariHome(), "companion.token");
+  return join37(getZelariHome(), "companion.token");
 }
 function ensureHome() {
   const home = getZelariHome();
-  if (!existsSync45(home)) {
-    mkdirSync21(home, { recursive: true });
+  if (!existsSync46(home)) {
+    mkdirSync22(home, { recursive: true });
   }
 }
 function loadCompanionConfig() {
   const path53 = getCompanionConfigPath();
-  if (!existsSync45(path53)) {
+  if (!existsSync46(path53)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync37(path53, "utf8"));
+    const raw = JSON.parse(readFileSync38(path53, "utf8"));
     const projects = Array.isArray(raw.projects) ? raw.projects.filter(
       (p3) => p3 && typeof p3.path === "string" && p3.path.trim() && typeof (p3.id ?? p3.name) === "string"
     ).map((p3) => ({
@@ -44532,7 +45074,7 @@ function loadCompanionConfig() {
 }
 function saveCompanionConfig(cfg) {
   ensureHome();
-  writeFileSync23(
+  writeFileSync24(
     getCompanionConfigPath(),
     JSON.stringify(
       {
@@ -44552,12 +45094,12 @@ function loadOrCreateToken(explicit) {
   }
   ensureHome();
   const path53 = getCompanionTokenPath();
-  if (existsSync45(path53)) {
-    const t = readFileSync37(path53, "utf8").trim();
+  if (existsSync46(path53)) {
+    const t = readFileSync38(path53, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes5(24).toString("base64url");
-  writeFileSync23(path53, token + "\n", "utf8");
+  writeFileSync24(path53, token + "\n", "utf8");
   try {
     const fs31 = __require("node:fs");
     fs31.chmodSync?.(path53, 384);
@@ -44567,8 +45109,8 @@ function loadOrCreateToken(explicit) {
 }
 function tokenMatches(expected, provided) {
   if (!provided) return false;
-  const a = createHash8("sha256").update(expected).digest();
-  const b = createHash8("sha256").update(provided).digest();
+  const a = createHash9("sha256").update(expected).digest();
+  const b = createHash9("sha256").update(provided).digest();
   try {
     return timingSafeEqual(a, b);
   } catch {
@@ -44646,8 +45188,8 @@ var init_config = __esm({
 import { spawn as spawn13 } from "node:child_process";
 import { createInterface as createInterface2 } from "node:readline";
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { writeFileSync as writeFileSync24, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join37 } from "node:path";
+import { writeFileSync as writeFileSync25, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join38 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 var RunManager;
 var init_runManager = __esm({
@@ -44751,9 +45293,9 @@ var init_runManager = __esm({
         }
         let historyFile;
         if (args.history && Array.isArray(args.history) && args.history.length > 0) {
-          historyFile = join37(tmpdir3(), `zelari-companion-hist-${id}.json`);
+          historyFile = join38(tmpdir3(), `zelari-companion-hist-${id}.json`);
           try {
-            writeFileSync24(historyFile, JSON.stringify(args.history), "utf8");
+            writeFileSync25(historyFile, JSON.stringify(args.history), "utf8");
             argv.push("--history-file", historyFile);
           } catch {
             historyFile = void 0;
@@ -44878,7 +45420,7 @@ __export(serve_exports, {
   runCompanionServe: () => runCompanionServe
 });
 import { createServer as createServer3 } from "node:http";
-import { existsSync as existsSync46 } from "node:fs";
+import { existsSync as existsSync47 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
 function readBody(req, max = 2e6) {
   return new Promise((resolveBody, reject) => {
@@ -44926,7 +45468,7 @@ async function runCompanionServe(opts = {}) {
   let projects = mergeProjects(fileCfg, opts.projects ?? []);
   projects = projects.filter((p3) => {
     const abs = resolve2(p3.path);
-    if (!existsSync46(abs)) {
+    if (!existsSync47(abs)) {
       process.stderr.write(
         `[zelari-code serve] skip missing project path: ${p3.path}
 `
@@ -45248,7 +45790,7 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync47, readFileSync as readFileSync38, readlinkSync, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync48, readFileSync as readFileSync39, readlinkSync, statSync as statSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import path51 from "node:path";
@@ -45256,9 +45798,9 @@ function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
     const candidate = path51.join(dir, "package.json");
-    if (existsSync47(candidate)) {
+    if (existsSync48(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync38(candidate, "utf8"));
+        const pkg = JSON.parse(readFileSync39(candidate, "utf8"));
         if (pkg.name === "zelari-code") return dir;
       } catch {
       }
@@ -45282,7 +45824,7 @@ function tryExec(cmd) {
 function readPackageJson3() {
   try {
     const pkgPath = path51.join(packageRoot, "package.json");
-    return JSON.parse(readFileSync38(pkgPath, "utf8"));
+    return JSON.parse(readFileSync39(pkgPath, "utf8"));
   } catch {
     return null;
   }
@@ -45298,7 +45840,7 @@ function checkShim(pkgName) {
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
   const shimPath = path51.join(prefix, shimName);
-  if (!existsSync47(shimPath)) {
+  if (!existsSync48(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
          fix:  npm install -g ${pkgName}@latest --force`
@@ -45307,7 +45849,7 @@ function checkShim(pkgName) {
   try {
     const st = statSync8(shimPath);
     if (isWin) {
-      const content = readFileSync38(shimPath, "utf8");
+      const content = readFileSync39(shimPath, "utf8");
       if (content.includes(`${pkgName}\\bin\\`) || content.includes(`${pkgName}/bin/`)) {
         return OK(`shim OK at ${shimPath} (${st.size} bytes)`);
       }
@@ -45366,7 +45908,7 @@ function checkNode(pkg) {
 }
 function checkBundle() {
   const bundle = path51.join(packageRoot, "dist", "cli", "main.bundled.js");
-  if (!existsSync47(bundle)) {
+  if (!existsSync48(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
          fix:  npm run build:cli   (then reinstall or run via tsx)`
@@ -45747,7 +46289,7 @@ __export(inspect_exports, {
   runInspect: () => runInspect
 });
 import path52 from "node:path";
-import { existsSync as existsSync48, readFileSync as readFileSync39, readdirSync as readdirSync10 } from "node:fs";
+import { existsSync as existsSync49, readFileSync as readFileSync40, readdirSync as readdirSync10 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
@@ -45780,11 +46322,11 @@ async function collectInspectReport(cwd = process.cwd()) {
       folders: listTrustedFolders()
     },
     configSources: [
-      { path: userMcpPath, exists: existsSync48(userMcpPath) },
-      { path: projectMcpPath, exists: existsSync48(projectMcpPath) },
-      { path: path52.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync48(path52.join(homedir14(), ".zelari-code", "provider.json")) },
-      { path: path52.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync48(path52.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path52.join(cwd, "AGENTS.md"), exists: existsSync48(path52.join(cwd, "AGENTS.md")) }
+      { path: userMcpPath, exists: existsSync49(userMcpPath) },
+      { path: projectMcpPath, exists: existsSync49(projectMcpPath) },
+      { path: path52.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync49(path52.join(homedir14(), ".zelari-code", "provider.json")) },
+      { path: path52.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync49(path52.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path52.join(cwd, "AGENTS.md"), exists: existsSync49(path52.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -45797,7 +46339,7 @@ async function collectInspectReport(cwd = process.cwd()) {
       user: mcp.servers.filter((s) => s.scope === "user").map((s) => ({ name: s.name, enabled: s.enabled !== false })),
       project: mcp.servers.filter((s) => s.scope === "project").map((s) => ({ name: s.name, enabled: s.enabled !== false })),
       projectTrusted,
-      projectConfigExists: existsSync48(projectMcpPath)
+      projectConfigExists: existsSync49(projectMcpPath)
     },
     hooks: {
       global: {
@@ -45829,9 +46371,9 @@ function findAgentsMd(cwd) {
   ];
   const found = [];
   for (const c of candidates) {
-    if (existsSync48(c)) {
+    if (existsSync49(c)) {
       try {
-        const text = readFileSync39(c, "utf8");
+        const text = readFileSync40(c, "utf8");
         found.push(`${c} (${text.length} bytes)`);
       } catch {
         found.push(`${c} (unreadable)`);
@@ -49235,34 +49777,58 @@ function phaseKnobs(phase2) {
     })
   };
 }
-function occupancyOf(hist, sessionExtra, contextLimit) {
-  const estimated = estimateHistoryTokens(hist);
-  const occupancy = Math.min(1, (estimated + sessionExtra) / contextLimit);
-  return { estimated, occupancy };
-}
+var RESERVED_OUTPUT_TOKENS = 8192;
 async function applyBudgetPolicyAsync(history2, phase2, opts) {
   const contextLimit = resolveContextLimit(opts?.model);
   const sessionExtra = opts?.sessionTokens ?? 0;
   const warnings = [];
   let { historyTurns, maxToolLoopIterations } = phaseKnobs(phase2);
+  const envelope = opts?.requestSnapshot ?? null;
+  const replayBase = envelope ? {
+    provider: envelope.snapshot.provider,
+    model: envelope.snapshot.model,
+    systemMessages: envelope.snapshot.systemMessages,
+    tools: envelope.snapshot.tools
+  } : opts?.providerStream ? { provider: "local", model: opts?.model ?? "unknown", systemMessages: [], tools: [] } : null;
+  const headerTokens = envelope ? estimateSystemTokensLite(envelope.snapshot.systemMessages) + estimateToolSchemaTokensLite(envelope.snapshot.tools) : 0;
+  const convTokensOf = (h) => estimateConversationTokensLite(h);
   let hist = history2;
-  let { estimated, occupancy } = occupancyOf(hist, sessionExtra, contextLimit);
+  let estimated = envelope ? headerTokens + convTokensOf(hist) + RESERVED_OUTPUT_TOKENS : estimateHistoryTokens(hist) + sessionExtra;
+  let occupancy = Math.min(1, estimated / contextLimit);
   let compactSummary = "";
   let messagesRemoved = 0;
+  let cacheReuseExpected;
+  let prunedTotal = 0;
   if (occupancy >= 0.7 && occupancy < 0.85) {
     warnings.push(
-      `[budget] context ~${Math.round(occupancy * 100)}% full (${estimated + sessionExtra}/${contextLimit} tok est.) \u2014 consider /compact or shorter replies.`
+      `[budget] context ~${Math.round(occupancy * 100)}% full (${estimated}/${contextLimit} tok full-request est.) \u2014 consider /compact or shorter replies.`
     );
   }
+  if (occupancy >= 0.8) {
+    const pruned = pruneToolResultsDetailed(hist);
+    if (pruned.stats.pruned > 0) {
+      hist = pruned.messages;
+      prunedTotal += pruned.stats.pruned;
+      estimated = envelope ? headerTokens + convTokensOf(hist) + RESERVED_OUTPUT_TOKENS : estimateHistoryTokens(hist) + sessionExtra;
+      occupancy = Math.min(1, estimated / contextLimit);
+      warnings.push(
+        `[budget] pruned ${pruned.stats.pruned} oversized tool result(s) \u2192 ${Math.round(occupancy * 100)}% (${estimated} tok).`
+      );
+    }
+  }
   const fold = (r, label, forcedTurns) => {
     hist = r.messages;
     if (r.compacted) {
       messagesRemoved += r.messagesRemoved;
       if (r.summary) compactSummary = r.summary;
+      if (r.cacheReuseExpected !== void 0) {
+        cacheReuseExpected = r.cacheReuseExpected;
+      }
     }
-    ({ estimated, occupancy } = occupancyOf(hist, sessionExtra, contextLimit));
+    estimated = envelope ? headerTokens + convTokensOf(hist) + RESERVED_OUTPUT_TOKENS : estimateHistoryTokens(hist) + sessionExtra;
+    occupancy = Math.min(1, estimated / contextLimit);
     warnings.push(
-      `[budget] ${label} at ${forcedTurns === 2 ? "95%" : "85%"} \u2014 kept ~${forcedTurns} turns (${estimated} tok history est.` + (r.messagesRemoved ? `, removed ${r.messagesRemoved} msgs` : "") + `).`
+      `[budget] ${label} \u2014 kept ~${forcedTurns} turns (${estimated} tok est.` + (r.messagesRemoved ? `, removed ${r.messagesRemoved} msgs` : "") + (r.cacheReuseExpected === false ? ", cache reuse NOT expected (model override)" : "") + ")."
     );
   };
   if (occupancy >= 0.85) {
@@ -49272,39 +49838,91 @@ async function applyBudgetPolicyAsync(history2, phase2, opts) {
       maxToolLoopIterations,
       phase2 === "plan" ? 24 : 40
     );
-    const r = await compactHistoryAsync(hist, {
-      maxMessages: forcedTurns * 4,
-      signal: opts?.signal
-    });
-    const label = r.summary.includes("\xB7 llm") ? "llm-compact" : "auto-compact";
+    let r = await compactHistoryAsync(hist, {
+      maxMessages: Math.max(2, forcedTurns * 4),
+      force: true,
+      signal: opts?.signal,
+      ...replayBase ? { requestSnapshot: replayBase, providerStream: opts?.providerStream } : {}
+    });
+    if (!r.compacted) {
+      r = await compactHistoryAsync(hist, {
+        maxMessages: 2,
+        force: true,
+        signal: opts?.signal,
+        ...replayBase ? { requestSnapshot: replayBase, providerStream: opts?.providerStream } : {}
+      });
+    }
+    const label = r.cacheReuseExpected === false ? "llm-compact (model override)" : "auto-compact";
     fold(r, label, forcedTurns);
   }
   if (occupancy >= 0.95) {
     const hard = await compactHistoryAsync(hist, {
-      maxMessages: 8,
+      maxMessages: 2,
+      force: true,
       signal: opts?.signal
     });
-    fold(hard, hard.summary.includes("\xB7 llm") ? "llm-compact" : "auto-compact", 2);
+    fold(hard, hard.summary.includes("\xB7 llm") ? "llm-compact" : "HARD trim", 2);
     historyTurns = 2;
     maxToolLoopIterations = Math.min(maxToolLoopIterations, 16);
     warnings.push(
-      `[budget] HARD context pressure (\u226595%) \u2014 prefer /clear or a new session if quality drops.`
+      "[budget] HARD context pressure (\u226595%) \u2014 prefer /clear or a new session if quality drops."
     );
   }
+  const cacheMetricsLine = envelope ? [
+    "compaction meter:",
+    `provider/model: ${envelope.snapshot.provider}/${envelope.snapshot.model}`,
+    `headerFingerprint: ${envelope.snapshot.headerFingerprint.slice(0, 12)}`,
+    `occupancy: ${Math.round(occupancy * 100)}% (${estimated}/${contextLimit})`,
+    ...envelope.usage?.cachedPromptTokens !== void 0 ? [`cachedPromptTokens: ${envelope.usage.cachedPromptTokens}`] : [],
+    ...cacheReuseExpected !== void 0 ? [`cacheReuseExpected: ${cacheReuseExpected}`] : []
+  ].join(" | ") : void 0;
   return {
     history: hist,
     warnings,
     maxToolLoopIterations,
     historyTurns,
-    estimatedHistoryTokens: estimated,
+    estimatedHistoryTokens: envelope ? convTokensOf(hist) : estimated,
     contextLimit,
     occupancy,
     compactSummary: compactSummary || void 0,
-    messagesRemoved: messagesRemoved || void 0
+    messagesRemoved: messagesRemoved || void 0,
+    ...envelope ? { contextPressureTokens: estimated } : {},
+    ...cacheReuseExpected !== void 0 ? { cacheReuseExpected } : {},
+    ...cacheMetricsLine ? { cacheMetricsLine } : {}
   };
 }
+function estimateSystemTokensLite(systemMessages) {
+  let n = 0;
+  for (const m of systemMessages) n += 4 + Math.ceil((m.content ?? "").length / 4);
+  return n;
+}
+function estimateToolSchemaTokensLite(tools) {
+  let n = 0;
+  for (const t of tools) {
+    n += Math.ceil((t.name ?? "").length / 4);
+    n += Math.ceil((t.description ?? "").length / 4);
+    n += Math.ceil(JSON.stringify(t.parameters ?? {}).length / 4);
+  }
+  return n + tools.length * 4;
+}
+function estimateConversationTokensLite(messages) {
+  let n = 0;
+  for (const m of messages) {
+    n += 4 + Math.ceil((m.content ?? "").length / 4);
+    if (m.toolCalls) {
+      for (const tc of m.toolCalls) {
+        n += Math.ceil(tc.name.length / 4) + Math.ceil(tc.id.length / 4);
+        n += Math.ceil(JSON.stringify(tc.args ?? {}).length / 4);
+      }
+    }
+    if (m.reasoningContent) n += Math.ceil(m.reasoningContent.length / 4);
+    if (m.toolCallId) n += Math.ceil(m.toolCallId.length / 4);
+  }
+  return n;
+}
 
 // src/cli/hooks/useChatTurn.ts
+init_requestSnapshotStore();
 function useChatTurn(params) {
   const {
     sessionId,
@@ -49331,17 +49949,9 @@ function useChatTurn(params) {
       let envConfig;
       let harness;
       let historySeedLen = 0;
+      let systemPrefixLen = 0;
       let turnSucceeded = false;
       try {
-        compactInPlace();
-        const budget = await applyBudgetPolicyAsync(getHistory(), getPhase(), {
-          model: getActiveModel()
-        });
-        setHistory(budget.history);
-        for (const w of budget.warnings) {
-          appendSystem(setMessages, w, Date.now());
-        }
-        historySeedLen = getHistory().length;
         const anchored = maybeAnchorShortAnswer(userText);
         const effectiveUserText = anchored ?? userText;
         const localCli = (process.env.ZELARI_LOCAL_CLI ?? "").trim();
@@ -49436,6 +50046,33 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           });
         }
         const cwd = process.cwd();
+        const budget = await applyBudgetPolicyAsync(getHistory(), getPhase(), {
+          model: getActiveModel(),
+          sessionId,
+          // v1.36.0: envelope for full-request metering + cache-aware
+          // compaction replay (last warm prefix + provider usage anchor).
+          requestSnapshot: getRequestSnapshotWithUsage(sessionId),
+          providerStream
+        });
+        setHistory(budget.history);
+        for (const w of budget.warnings) {
+          appendSystem(setMessages, w, Date.now());
+        }
+        if ((budget.messagesRemoved ?? 0) > 0) {
+          const envelope = getRequestSnapshotWithUsage(sessionId);
+          const compactionEvent = createBrainEvent("session_compacted", sessionId, {
+            summary: budget.compactSummary ?? "",
+            messagesRemoved: budget.messagesRemoved ?? 0,
+            ...envelope ? {
+              sourceRequestFingerprint: envelope.snapshot.requestFingerprint,
+              headerFingerprint: envelope.snapshot.headerFingerprint
+            } : {},
+            ...budget.contextPressureTokens !== void 0 ? { sourceEstimatedTokens: budget.contextPressureTokens } : {},
+            ...budget.cacheReuseExpected !== void 0 ? { cacheReuseExpected: budget.cacheReuseExpected } : {}
+          });
+          void writerRef.current?.append(compactionEvent);
+        }
+        historySeedLen = getHistory().length;
         let composedWorkspace = "";
         let composedInstructions = "";
         let hasPlan = false;
@@ -49593,6 +50230,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           lastStableHash = hashStablePrompt(fallback);
           systemMessages = [{ role: "system", content: fallback }];
         }
+        systemPrefixLen = systemMessages.length;
         const maxToolCallsPerTurn = envNumber(process.env.ZELARI_MAX_TOOL_CALLS, {
           default: 25,
           min: 1
@@ -49605,7 +50243,10 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
         });
         const harness2 = new AgentHarness({
           model: envConfig.model,
-          provider: "openai-compatible",
+          // v1.36.0 (P0.2): real provider identity — the harness used to
+          // hardcode "openai-compatible" (the transport family) so snapshots
+          // and telemetry mislabeled deepseek/glm/minimax routing.
+          provider: envConfig.providerId,
           messages: [
             ...systemMessages,
             // v1.8.0: shared rolling history (agent/council/zelari) so short
@@ -49624,6 +50265,9 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           cwd,
           maxToolCallsPerTurn,
           maxToolLoopIterations,
+          // v1.36.0: routed-request snapshots feed the meter (occupancy) and
+          // the cache-aware compaction replay (last warm prefix).
+          onRequestSnapshot: (snap) => recordRequestSnapshot(sessionId, snap),
           ...maxToolLoopHardCap > 0 ? { maxToolLoopHardCap } : {}
         });
         harnessRef.current = harness2;
@@ -49638,6 +50282,14 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           for await (const event of harness2.run()) {
             if (event.type === "message_end") {
               if (event.usage) realUsage = event.usage;
+              if (event.usage) {
+                recordRequestUsage(sessionId, {
+                  promptTokens: event.usage.promptTokens,
+                  completionTokens: event.usage.completionTokens,
+                  totalTokens: event.usage.totalTokens,
+                  cachedPromptTokens: event.usage.cachedPromptTokens
+                });
+              }
               if (streamContent) {
                 const sealed = streamScrub.finalize(streamContent);
                 if (useLiveModel) setStreaming(commitStreaming, sealed, event.ts);
@@ -49797,18 +50449,17 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
             const h = harnessRef.current;
             if (h && turnSucceeded) {
               const all = h.getMessages();
-              const seedLen = 1 + historySeedLen + 1;
+              const seedLen = systemPrefixLen + historySeedLen + 1;
               if (all.length > seedLen) {
                 appendMessages(
-                  all.slice(seedLen).map(
-                    (m) => m.role === "assistant" && m.content ? {
-                      ...m,
-                      content: cleanAgentContent(m.content, {
-                        stripQuestion: false,
-                        stripThink: false
-                      })
-                    } : m
-                  )
+                  all.slice(seedLen).map((m) => {
+                    if (m.role !== "assistant" || !m.content) return m;
+                    const cleaned = cleanAgentContent(m.content, {
+                      stripQuestion: false,
+                      stripThink: false
+                    });
+                    return cleaned === m.content ? m : { ...m, content: cleaned };
+                  })
                 );
               }
             }
@@ -51751,12 +52402,12 @@ init_fileStateStore();
 async function restoreDurableState(opts) {
   const restoreTree = opts.restoreTree !== false;
   try {
-    const store3 = opts.store ?? await getStateStore(opts.projectRoot);
+    const store4 = opts.store ?? await getStateStore(opts.projectRoot);
     let meta3;
     if (opts.commitId) {
-      meta3 = await store3.setHead(opts.commitId);
+      meta3 = await store4.setHead(opts.commitId);
     } else {
-      meta3 = await store3.head();
+      meta3 = await store4.head();
       if (!meta3) {
         return {
           ok: false,
@@ -51809,8 +52460,8 @@ function ago2(ms) {
   return `${Math.round(s / 3600)}h ago`;
 }
 async function handleStateStatus(ctx) {
-  const store3 = await getStateStore(ctx.cwd);
-  const head = await store3.head();
+  const store4 = await getStateStore(ctx.cwd);
+  const head = await store4.head();
   if (!head) {
     appendSystem(
       ctx.setMessages,
@@ -51818,9 +52469,9 @@ async function handleStateStatus(ctx) {
     );
     return;
   }
-  const discoveries = await store3.loadDiscoveries(head.id);
+  const discoveries = await store4.loadDiscoveries(head.id);
   const reusable = discoveries.filter((d) => d.reusable).length;
-  const recent = await store3.list(8);
+  const recent = await store4.list(8);
   const lines = recent.map((c, i) => {
     const ver2 = c.verification.ran ? c.verification.ok ? "ok" : "fail" : "n/a";
     return `  ${i === 0 ? "\u2192" : " "} ${c.id}  ${ago2(c.createdAt)}  ${c.label}  ver=${ver2}` + (c.layer ? `  [${c.layer}]` : "") + (c.stablePromptHash ? `  hash=${c.stablePromptHash.slice(0, 8)}` : "");
@@ -51839,9 +52490,9 @@ async function handleStateStatus(ctx) {
   );
 }
 async function handleStateCommit(ctx, label) {
-  const store3 = await getStateStore(ctx.cwd);
+  const store4 = await getStateStore(ctx.cwd);
   try {
-    const meta3 = await store3.commit({
+    const meta3 = await store4.commit({
       mode: "agent",
       label: label?.trim() || "manual state commit",
       layer: "manual",
@@ -51868,8 +52519,8 @@ async function handleStateCommit(ctx, label) {
   }
 }
 async function handleStateShow(ctx, id) {
-  const store3 = await getStateStore(ctx.cwd);
-  const meta3 = id ? await store3.get(id) : await store3.head();
+  const store4 = await getStateStore(ctx.cwd);
+  const meta3 = id ? await store4.get(id) : await store4.head();
   if (!meta3) {
     appendSystem(
       ctx.setMessages,
@@ -51877,7 +52528,7 @@ async function handleStateShow(ctx, id) {
     );
     return;
   }
-  const text = await store3.materializeContext(meta3.id, 6e3);
+  const text = await store4.materializeContext(meta3.id, 6e3);
   appendSystem(ctx.setMessages, `[state] show ${meta3.id}
 ${text}`);
 }
@@ -52916,7 +53567,7 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs26, existsSync as existsSync40, readFileSync as readFileSync33, writeFileSync as writeFileSync21, mkdirSync as mkdirSync18, statSync as statSync5, rmSync as rmSync3 } from "node:fs";
+import { promises as fs26, existsSync as existsSync41, readFileSync as readFileSync34, writeFileSync as writeFileSync22, mkdirSync as mkdirSync19, statSync as statSync5, rmSync as rmSync3 } from "node:fs";
 import path46 from "node:path";
 import os12 from "node:os";
 var META_FILENAME = "meta.json";
@@ -52938,11 +53589,11 @@ function sessionsPathFor(name, baseDir) {
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
-  if (!existsSync40(metaPath)) {
+  if (!existsSync41(metaPath)) {
     throw new BranchNotFoundError(`Branch "${name}" not found`);
   }
   try {
-    const raw = readFileSync33(metaPath, "utf-8");
+    const raw = readFileSync34(metaPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || typeof parsed.name !== "string" || typeof parsed.createdAt !== "number" || typeof parsed.fromSessionId !== "string") {
       throw new BranchCorruptError(`Branch "${name}" meta.json is malformed`);
@@ -52959,8 +53610,8 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync18(path46.dirname(metaPath), { recursive: true });
-  writeFileSync21(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
+  mkdirSync19(path46.dirname(metaPath), { recursive: true });
+  writeFileSync22(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
@@ -52998,7 +53649,7 @@ var SessionNotFoundError = class extends Error {
 };
 function branchExists(name, baseDir = getBranchesBaseDir()) {
   const bp = branchPathFor(name, baseDir);
-  return existsSync40(bp) && existsSync40(metaPathFor(name, baseDir));
+  return existsSync41(bp) && existsSync41(metaPathFor(name, baseDir));
 }
 async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(), sessionsBaseDir = getSessionsBaseDir()) {
   if (!name || name.trim().length === 0) {
@@ -53011,12 +53662,12 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
     throw new BranchAlreadyExistsError(name);
   }
   const sourcePath = path46.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
-  if (!existsSync40(sourcePath)) {
+  if (!existsSync41(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
-  mkdirSync18(branchSessionsPath, { recursive: true });
+  mkdirSync19(branchSessionsPath, { recursive: true });
   const destPath = path46.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs26.copyFile(sourcePath, destPath);
   const meta3 = {
@@ -53044,7 +53695,7 @@ async function listBranches(baseDir = getBranchesBaseDir()) {
   const results = [];
   for (const entry of entries) {
     const metaPath = metaPathFor(entry, baseDir);
-    if (!existsSync40(metaPath)) continue;
+    if (!existsSync41(metaPath)) continue;
     try {
       const meta3 = readBranchMeta(entry, baseDir);
       const sessionCount = await countSessions(entry, baseDir);
@@ -53235,7 +53886,7 @@ import path48 from "node:path";
 import os13 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs28, existsSync as existsSync41, statSync as statSync6, renameSync as renameSync4, appendFileSync as appendFileSync4, mkdirSync as mkdirSync19 } from "node:fs";
+import { promises as fs28, existsSync as existsSync42, statSync as statSync6, renameSync as renameSync5, appendFileSync as appendFileSync4, mkdirSync as mkdirSync20 } from "node:fs";
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
@@ -53386,14 +54037,14 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
 }
 function handleCouncilFeedback(ctx, memberId, score, note) {
   try {
-    const store3 = new FeedbackStore();
-    const entry = store3.record({
+    const store4 = new FeedbackStore();
+    const entry = store4.record({
       memberId,
       score,
       ...note ? { note } : {},
       ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
     });
-    const stats = store3.getStats(memberId);
+    const stats = store4.getStats(memberId);
     appendSystem(
       ctx.setMessages,
       `[council-feedback] ${memberId} rated ${entry.score}/5 \u2014 running avg ${stats.avg.toFixed(2)} over ${stats.count} rating(s).`
@@ -54563,9 +55214,9 @@ function ContinueKey({ onContinue }) {
 init_providerConfig();
 
 // src/cli/wizard/firstRun.ts
-import { existsSync as existsSync43 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 function shouldRunWizard(input) {
-  const exists = input.exists ?? existsSync43;
+  const exists = input.exists ?? existsSync44;
   if (input.hasResetConfigFlag) {
     return { shouldRun: true, reason: "--reset-config flag forced wizard" };
   }
@@ -54850,7 +55501,7 @@ init_keyStore();
 init_providerConfig();
 init_openai_compatible();
 init_phase();
-import { readFileSync as readFileSync35 } from "node:fs";
+import { readFileSync as readFileSync36 } from "node:fs";
 function parseHeadlessFlags(argv) {
   if (!argv.includes("--headless")) {
     return { options: null };
@@ -54923,7 +55574,7 @@ function parseHeadlessFlags(argv) {
         let raw = null;
         if (arg === "--history-file") {
           try {
-            raw = readFileSync35(next, "utf-8");
+            raw = readFileSync36(next, "utf-8");
           } catch {
             raw = null;
           }
@@ -55410,6 +56061,20 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   const sessionId = crypto.randomUUID();
   const { registry: toolRegistry } = createBuiltinToolRegistry({
     planMode: planModeFromOpts(opts),
+    // ADR-0018 3b: upgrade plan-task domain events to first-class NDJSON
+    // BrainEvents. Rust envelopes every stdout line with runId/conversationId,
+    // so task events ride the same multiplexed channel as the rest.
+    onTaskEvent: (ev) => {
+      if (opts.output !== "json") return;
+      emitEvent({
+        type: ev.type,
+        id: crypto.randomUUID(),
+        ts: Date.now(),
+        sessionId,
+        source: ev.source,
+        ...ev.type === "task_update" ? { task: ev.task } : { tasks: ev.tasks }
+      });
+    },
     permissionPolicy: {
       read: "allow",
       write: "allow",