zelari-code 2.11.2 → 2.13.0

package/dist/cli/main.bundled.js

@@ -3288,10 +3288,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path72) {
-  if (!path72)
+function getElementAtPath(obj, path74) {
+  if (!path74)
     return obj;
-  return path72.reduce((acc, key) => acc?.[key], obj);
+  return path74.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3619,11 +3619,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path72, issues) {
+function prefixIssues(path74, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path72);
+    iss.path.unshift(path74);
     return iss;
   });
 }
@@ -3841,16 +3841,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path72 = []) => {
+  const processError = (error52, path74 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path72, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path74, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path72, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path74, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path72, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path74, ...issue2.path]);
       } else {
-        const fullpath = [...path72, ...issue2.path];
+        const fullpath = [...path74, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -3877,17 +3877,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path72 = []) => {
+  const processError = (error52, path74 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path72, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path74, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path72, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path74, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path72, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path74, ...issue2.path]);
       } else {
-        const fullpath = [...path72, ...issue2.path];
+        const fullpath = [...path74, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -3919,8 +3919,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path72 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path72) {
+  const path74 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path74) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17423,13 +17423,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path72 = ref.slice(1).split("/").filter(Boolean);
-  if (path72.length === 0) {
+  const path74 = ref.slice(1).split("/").filter(Boolean);
+  if (path74.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path72[0] === defsKey) {
-    const key = path72[1];
+  if (path74[0] === defsKey) {
+    const key = path74[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18235,15 +18235,66 @@ var init_toolTypes = __esm({
   }
 });
 
+// packages/core/dist/core/tools/builtin/newlines.js
+function detectNewline(text) {
+  if (text.includes("\r\n"))
+    return "\r\n";
+  if (text.includes("\r"))
+    return "\r";
+  return "\n";
+}
+function toLF(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function fromLF(text, nl) {
+  if (nl === "\n")
+    return text;
+  return text.replace(/\n/g, nl);
+}
+function splitLinesLF(text) {
+  return toLF(text).split("\n");
+}
+var init_newlines = __esm({
+  "packages/core/dist/core/tools/builtin/newlines.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/core/tools/builtin/filesystem.js
 import { promises as fs4 } from "node:fs";
 import path6 from "node:path";
+function replaceFileString(text, oldString, newString, replaceAll) {
+  const exact = replaceOnceOrAll(text, oldString, newString, replaceAll);
+  if (exact.occurrences > 0)
+    return exact;
+  const nl = detectNewline(text);
+  const normalized = replaceOnceOrAll(toLF(text), toLF(oldString), toLF(newString), replaceAll);
+  if (normalized.occurrences === 0)
+    return normalized;
+  return { occurrences: normalized.occurrences, newContent: fromLF(normalized.newContent, nl) };
+}
+function replaceOnceOrAll(text, oldString, newString, replaceAll) {
+  if (replaceAll) {
+    if (!text.includes(oldString))
+      return { occurrences: 0, newContent: text };
+    const parts = text.split(oldString);
+    return { occurrences: parts.length - 1, newContent: parts.join(newString) };
+  }
+  const idx = text.indexOf(oldString);
+  if (idx === -1)
+    return { occurrences: 0, newContent: text };
+  return {
+    occurrences: 1,
+    newContent: text.slice(0, idx) + newString + text.slice(idx + oldString.length)
+  };
+}
 var ReadFileArgsSchema, readFileTool, WriteFileArgsSchema, writeFileTool, EditFileArgsSchema, editFileTool;
 var init_filesystem = __esm({
   "packages/core/dist/core/tools/builtin/filesystem.js"() {
     "use strict";
     init_zod();
     init_toolTypes();
+    init_newlines();
     ReadFileArgsSchema = external_exports.object({
       path: external_exports.string().min(1),
       startLine: external_exports.number().int().nonnegative().optional().describe("0-based first line to include. Range is applied to the full file before maxBytes."),
@@ -18337,7 +18388,7 @@ var init_filesystem = __esm({
     });
     editFileTool = {
       name: "edit_file",
-      description: "Replace exact string match in a file. Idempotent: returns 0 occurrences if no match.",
+      description: "Replace a string in a file. Matching ignores CRLF vs LF; the file keeps its original line endings. Returns an error if oldString is not found.",
       permissions: ["write"],
       sideEffect: "local",
       timeoutMs: 1e4,
@@ -18347,22 +18398,7 @@ var init_filesystem = __esm({
           const absPath = path6.isAbsolute(args.path) ? args.path : path6.join(ctx.cwd, args.path);
           const content = await fs4.readFile(absPath, { encoding: "utf-8", signal: ctx.signal });
           const text = typeof content === "string" ? content : content.toString("utf-8");
-          let occurrences = 0;
-          let newContent;
-          if (args.replaceAll) {
-            const parts = text.split(args.oldString);
-            occurrences = parts.length - 1;
-            newContent = parts.join(args.newString);
-          } else {
-            const idx = text.indexOf(args.oldString);
-            if (idx === -1) {
-              occurrences = 0;
-              newContent = text;
-            } else {
-              occurrences = 1;
-              newContent = text.slice(0, idx) + args.newString + text.slice(idx + args.oldString.length);
-            }
-          }
+          const { occurrences, newContent } = replaceFileString(text, args.oldString, args.newString, args.replaceAll);
           if (occurrences === 0) {
             return typedErr(`edit_file: no match for oldString in ${args.path}. Use read_file to copy the exact text (whitespace included) and retry.`);
           }
@@ -19114,7 +19150,7 @@ function formatUnified(hunks, oldLabel, newLabel) {
   return lines.join("\n");
 }
 function parseUnified(raw) {
-  const lines = raw.split("\n");
+  const lines = splitLinesLF(raw);
   if (lines.length < 2 || !lines[0].startsWith("--- ") || !lines[1].startsWith("+++ ")) {
     throw new Error("Invalid unified diff: missing --- / +++ headers");
   }
@@ -19170,6 +19206,72 @@ function parseUnified(raw) {
 function normalizeWhitespace(s) {
   return s.replace(/\s+/g, " ").trim();
 }
+function linesEqual(fileLine, opText, fuzzy) {
+  if (fileLine === opText)
+    return true;
+  if (fuzzy && normalizeWhitespace(fileLine) === normalizeWhitespace(opText))
+    return true;
+  return false;
+}
+function hunkOldNeedle(hunk) {
+  return hunk.ops.filter((op) => op.kind !== "+").map((op) => op.text);
+}
+function matchAt(lines, at, needle, fuzzy) {
+  if (needle.length === 0)
+    return at >= 0 && at <= lines.length;
+  if (at < 0 || at + needle.length > lines.length)
+    return false;
+  for (let i = 0; i < needle.length; i++) {
+    if (!linesEqual(lines[at + i] ?? "", needle[i], fuzzy))
+      return false;
+  }
+  return true;
+}
+function locateHunk(lines, hunk, fileIdx, fuzzy) {
+  const needle = hunkOldNeedle(hunk);
+  const preferred = hunk.oldStart - 1;
+  if (needle.length === 0) {
+    const start = Math.max(fileIdx, preferred >= 0 ? preferred : fileIdx);
+    return { start };
+  }
+  if (preferred >= fileIdx && matchAt(lines, preferred, needle, fuzzy)) {
+    return { start: preferred };
+  }
+  const hits = [];
+  for (let i = fileIdx; i <= lines.length - needle.length; i++) {
+    if (matchAt(lines, i, needle, fuzzy))
+      hits.push(i);
+  }
+  if (hits.length === 0) {
+    if (preferred >= fileIdx) {
+      let fileAt = preferred;
+      for (const op of hunk.ops) {
+        if (op.kind === "+")
+          continue;
+        const fileLine = lines[fileAt] ?? "";
+        if (!linesEqual(fileLine, op.text, fuzzy)) {
+          const label = op.kind === "-" ? "Delete mismatch" : "Context mismatch";
+          return {
+            error: `${label} at line ${fileAt + 1}: expected "${op.text.slice(0, 60)}", got "${fileLine.slice(0, 60)}"`
+          };
+        }
+        fileAt++;
+      }
+    }
+    return { error: `Hunk context not found (oldStart ${hunk.oldStart})` };
+  }
+  if (hits.length === 1)
+    return { start: hits[0] };
+  hits.sort((a, b) => Math.abs(a - preferred) - Math.abs(b - preferred) || a - b);
+  const bestDist = Math.abs(hits[0] - preferred);
+  const tied = hits.filter((h) => Math.abs(h - preferred) === bestDist);
+  if (tied.length > 1) {
+    return {
+      error: `Ambiguous hunk at oldStart ${hunk.oldStart}: ${tied.length} equally close matches (refusing to guess)`
+    };
+  }
+  return { start: hits[0] };
+}
 function applyAllHunks(originalLines, hunks, fuzzy) {
   const out = [];
   let fileIdx = 0;
@@ -19177,17 +19279,13 @@ function applyAllHunks(originalLines, hunks, fuzzy) {
   let hunksSkipped = 0;
   let lastReason;
   for (const hunk of hunks) {
-    const startIdx = hunk.oldStart - 1;
-    if (startIdx < 0) {
-      hunksSkipped++;
-      lastReason = `oldStart ${hunk.oldStart} out of range (must be >= 1)`;
-      continue;
-    }
-    if (startIdx > originalLines.length) {
+    const located = locateHunk(originalLines, hunk, fileIdx, fuzzy);
+    if ("error" in located) {
       hunksSkipped++;
-      lastReason = `oldStart ${hunk.oldStart} beyond file end (length ${originalLines.length})`;
-      continue;
+      lastReason = located.error;
+      break;
     }
+    const startIdx = located.start;
     while (fileIdx < startIdx) {
       out.push(originalLines[fileIdx]);
       fileIdx++;
@@ -19200,7 +19298,7 @@ function applyAllHunks(originalLines, hunks, fuzzy) {
       const op = hunk.ops[hunkIdx];
       if (op.kind === " ") {
         const fileLine = originalLines[hunkFileIdx] ?? "";
-        if (fileLine === op.text || fuzzy && normalizeWhitespace(fileLine) === normalizeWhitespace(op.text)) {
+        if (linesEqual(fileLine, op.text, fuzzy)) {
           hunkOut.push(fileLine);
           hunkFileIdx++;
           hunkIdx++;
@@ -19211,7 +19309,7 @@ function applyAllHunks(originalLines, hunks, fuzzy) {
         }
       } else if (op.kind === "-") {
         const fileLine = originalLines[hunkFileIdx] ?? "";
-        if (fileLine === op.text || fuzzy && normalizeWhitespace(fileLine) === normalizeWhitespace(op.text)) {
+        if (linesEqual(fileLine, op.text, fuzzy)) {
           hunkFileIdx++;
           hunkIdx++;
         } else {
@@ -19244,6 +19342,7 @@ var init_diff = __esm({
     "use strict";
     init_zod();
     init_toolTypes();
+    init_newlines();
     LCS_MAX_CELLS = 4e6;
     ShowDiffArgsSchema = external_exports.object({
       path: external_exports.string().min(1),
@@ -19268,8 +19367,8 @@ var init_diff = __esm({
               return typedErr(err instanceof Error ? err.message : String(err));
             }
           }
-          const a = current.split("\n");
-          const b = args.proposedContent.split("\n");
+          const a = splitLinesLF(current);
+          const b = splitLinesLF(args.proposedContent);
           const CONTEXT = args.contextLines;
           const rawOps = diffOps(a, b);
           if (rawOps === null) {
@@ -19355,7 +19454,7 @@ var init_diff = __esm({
     });
     applyDiffTool = {
       name: "apply_diff",
-      description: "Apply a unified diff patch to a file. Parses ---/+++/@@ headers and applies each hunk sequentially. With fuzzyMatch=true, tolerates whitespace differences. With dryRun=true, returns the final content without writing. Atomic: if any hunk fails, no partial write occurs.",
+      description: "Apply a unified diff patch to a file. Parses ---/+++/@@ headers and applies each hunk sequentially. CRLF vs LF is ignored; the file keeps its original line endings. Hunks whose @@ line numbers drifted (common after an earlier insert) are relocated by matching context. With fuzzyMatch=true, also tolerates whitespace differences. With dryRun=true, returns the final content without writing. Atomic: if any hunk fails, no partial write occurs.",
       permissions: ["write"],
       sideEffect: "local",
       timeoutMs: 15e3,
@@ -19380,9 +19479,10 @@ var init_diff = __esm({
           if (parsed.hunks.length === 0) {
             return typedErr("No hunks found in diff");
           }
-          const originalLines = current.split("\n");
+          const nl = detectNewline(current);
+          const originalLines = splitLinesLF(current);
           const result = applyAllHunks(originalLines, parsed.hunks, args.fuzzyMatch);
-          const finalContent = result.lines.join("\n");
+          const finalContent = fromLF(result.lines.join("\n"), nl);
           const ok = result.hunksSkipped === 0;
           if (ok && !args.dryRun) {
             await fs7.mkdir(path10.dirname(absPath), { recursive: true });
@@ -19765,11 +19865,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path72 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path74 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path72,
+            path: path74,
             title,
             content,
             format: "markdown",
@@ -19778,7 +19878,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path72}".`;
+          return `Document "${title}" created at "${path74}".`;
         }
       }
     ];
@@ -25734,11 +25834,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join4 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path72 = join4(zelariRoot, "nfr-spec.json");
-  if (!existsSync7(path72))
+  const path74 = join4(zelariRoot, "nfr-spec.json");
+  if (!existsSync7(path74))
     return null;
   try {
-    const raw = JSON.parse(readFileSync7(path72, "utf8"));
+    const raw = JSON.parse(readFileSync7(path74, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -28044,9 +28144,9 @@ var init_types5 = __esm({
 import { readFileSync as readFileSync12 } from "node:fs";
 import { join as join10 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path72 = join10(zelariRoot, LESSONS_FILE);
+  const path74 = join10(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync12(path72, "utf8");
+    const raw = readFileSync12(path74, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -28147,8 +28247,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path72 = join11(zelariRoot, LESSONS_FILE);
-  appendFileSync(path72, `${JSON.stringify(lesson)}
+  const path74 = join11(zelariRoot, LESSONS_FILE);
+  appendFileSync(path74, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -30111,9 +30211,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path72 = [];
+    const path74 = [];
     color.set(start, GRAY);
-    path72.push(start);
+    path74.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id3, idx] = top;
@@ -30126,17 +30226,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path72.indexOf(dep);
-          return [...path72.slice(at), dep];
+          const at = path74.indexOf(dep);
+          return [...path74.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path72.push(dep);
+          path74.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id3, BLACK);
-        path72.pop();
+        path74.pop();
         stack.pop();
       }
     }
@@ -31056,8 +31156,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path72 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path72}`);
+        const path74 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path74}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -33499,16 +33599,16 @@ function runRetentionFromEnv() {
     maxTotalBytes: Number.isFinite(parseMb) && parseMb > 0 ? Math.round(parseMb * 1024 * 1024) : DEFAULT_RUN_RETENTION_MAX_MB * 1024 * 1024
   };
 }
-async function dirSize(path72) {
+async function dirSize(path74) {
   let total = 0;
   let entries;
   try {
-    entries = await readdir(path72, { withFileTypes: true });
+    entries = await readdir(path74, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child = join13(path72, entry.name);
+    const child = join13(path74, entry.name);
     if (entry.isDirectory())
       total += await dirSize(child);
     else {
@@ -33535,19 +33635,19 @@ async function enforceRunRetention(runsDir, options = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const path72 = join13(runsDir, entry.name);
+    const path74 = join13(runsDir, entry.name);
     let startedAt = 0;
     let endedAt;
     let completed = false;
     try {
-      const manifest = JSON.parse(await readFile(join13(path72, "manifest.json"), "utf8"));
+      const manifest = JSON.parse(await readFile(join13(path74, "manifest.json"), "utf8"));
       startedAt = manifest.startedAt ?? 0;
       endedAt = manifest.endedAt;
       completed = Boolean(endedAt) && manifest.status !== "running";
     } catch {
       completed = false;
     }
-    infos.push({ name: entry.name, path: path72, startedAt, endedAt, completed, bytes: await dirSize(path72) });
+    infos.push({ name: entry.name, path: path74, startedAt, endedAt, completed, bytes: await dirSize(path74) });
   }
   const remove = async (info) => {
     await rm(info.path, { recursive: true, force: true });
@@ -34319,12 +34419,12 @@ var init_engine = __esm({
        * content digest) and the returned ref carries the event seq when the
        * emitter resolved one.
        */
-      async fsEvidence(observation, path72, sha256, content, extra = {}) {
+      async fsEvidence(observation, path74, sha256, content, extra = {}) {
         const digest = sha256 && content !== void 0 ? sha256(content) : void 0;
-        const seq = await this.emitEvidence({ observation, path: path72, ...extra, ...digest ? { digest } : {} });
+        const seq = await this.emitEvidence({ observation, path: path74, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
-          ref: path72,
+          ref: path74,
           capturedAt: Date.now(),
           ...digest ? { digest } : {},
           ...seq !== void 0 ? { seq } : {}
@@ -34706,7 +34806,8 @@ var init_verifier = __esm({
     });
     VERIFIER_SYSTEM_PROMPT = [
       "You are an independent completion verifier.",
-      "You receive a work summary and deterministic verification results.",
+      "You receive the original task, a git diff summary, a test output excerpt,",
+      "and deterministic verification results \u2014 never the builder narration.",
       "Answer with a single JSON object and nothing else:",
       '{"verdict":"confirmed|rejected|unknown","score":0..1,"rationale":"..."}',
       "Rules: never confirm when a required deterministic check failed or is unknown;",
@@ -34741,8 +34842,14 @@ var init_verifier = __esm({
         try {
           response = await this.deps.callModel({
             system: VERIFIER_SYSTEM_PROMPT,
+            // Blind review payload: evidence only (task, diff summary, test output
+            // excerpt, deterministic results). Builder narration/reasoning is
+            // structurally excluded — undefined keys are omitted.
             user: JSON.stringify({
+              ...request.task === void 0 ? {} : { task: request.task },
               summary: request.summary,
+              ...request.diffSummary === void 0 ? {} : { diffSummary: request.diffSummary },
+              ...request.testOutputExcerpt === void 0 ? {} : { testOutputExcerpt: request.testOutputExcerpt },
               deterministicResults: request.results.map((r) => ({
                 criterionId: r.criterionId,
                 status: r.status,
@@ -37457,9 +37564,9 @@ function spillToolOutput(fullText, meta3) {
     const rnd = randomBytes3(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
     const file2 = `${stamp}-${safeTool}-${hash3}-${rnd}.txt`;
-    const path72 = join14(dir, file2);
-    writeFileSync11(path72, fullText, "utf8");
-    return path72;
+    const path74 = join14(dir, file2);
+    writeFileSync11(path74, fullText, "utf8");
+    return path74;
   } catch {
     return null;
   }
@@ -37505,10 +37612,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path72 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path72) {
+    const path74 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path74) {
       const spillNote = `
-\u2026 [full output spilled to: ${path72} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path74} \u2014 re-read with read_file if you need the complete text] \u2026`;
       if (preview.includes("] \u2026\n")) {
         preview = preview.replace("] \u2026\n", `] \u2026${spillNote}
 `);
@@ -39305,7 +39412,7 @@ var init_taskTool = __esm({
     init_candidateRegistry();
     init_verifyReport();
     init_metrics2();
-    TASK_TOOL_TIMEOUT_MS = 9e5;
+    TASK_TOOL_TIMEOUT_MS = 27e5;
     EXPLORE_PROMPT = [
       "You are a focused EXPLORE tentacle of Kraken (parent super-agent).",
       "READ-ONLY tools only (read, list, grep, fetch). No edits, no shell.",
@@ -40340,28 +40447,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path72) {
-        if (!existsSync19(path72)) {
-          throw new Error(`File not found: ${path72}`);
+      read(path74) {
+        if (!existsSync19(path74)) {
+          throw new Error(`File not found: ${path74}`);
         }
-        const md = readFileSync16(path72, "utf8");
+        const md = readFileSync16(path74, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path72) {
-        if (!existsSync19(path72)) return null;
-        return this.read(path72);
+      readIfExists(path74) {
+        if (!existsSync19(path74)) return null;
+        return this.read(path74);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path72, meta3, body) {
-        mkdirSync10(dirname2(path72), { recursive: true });
-        const tmp = path72 + ".tmp-" + process.pid;
+      write(path74, meta3, body) {
+        mkdirSync10(dirname2(path74), { recursive: true });
+        const tmp = path74 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync13(tmp, md, "utf8");
-        renameSync(tmp, path72);
+        renameSync(tmp, path74);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -40423,8 +40530,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path72 = join18(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync11(dirname3(path72), { recursive: true });
+  const path74 = join18(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync11(dirname3(path74), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -40445,7 +40552,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path72, meta3, body);
+  new Storage().write(path74, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join18(rootDir, "plan.json");
@@ -43733,21 +43840,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path72 = getSshSecretsPath();
-  if (!existsSync23(path72)) return {};
+  const path74 = getSshSecretsPath();
+  if (!existsSync23(path74)) return {};
   try {
-    return JSON.parse(readFileSync20(path72, "utf8"));
+    return JSON.parse(readFileSync20(path74, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path72 = getSshSecretsPath();
-  mkdirSync12(dirname4(path72), { recursive: true });
-  writeFileSync15(path72, `${JSON.stringify(data, null, 2)}
+  const path74 = getSshSecretsPath();
+  mkdirSync12(dirname4(path74), { recursive: true });
+  writeFileSync15(path74, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path72, 384);
+    chmodSync(path74, 384);
   } catch {
   }
 }
@@ -43776,10 +43883,10 @@ function deleteSshPassword(id3) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path72 = getSshTargetsPath();
-  if (!existsSync23(path72)) return [];
+  const path74 = getSshTargetsPath();
+  if (!existsSync23(path74)) return [];
   try {
-    const parsed = JSON.parse(readFileSync20(path72, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path74, "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"
@@ -43794,11 +43901,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path72 = getSshTargetsPath();
-  mkdirSync12(dirname4(path72), { recursive: true });
+  const path74 = getSshTargetsPath();
+  mkdirSync12(dirname4(path74), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync15(
-    path72,
+    path74,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -44044,11 +44151,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path72 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path74 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
     const allow = t.allowedCommands?.length ? ` allowed=${t.allowedCommands.join("|")}` : " allowed=status-only";
     const auth = t.auth === "password" ? " auth=password" : t.auth === "keyPath" ? " auth=key" : " auth=agent";
     lines.push(
-      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path72}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path74}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -45048,6 +45155,19 @@ function defaultPermissionPolicy(overrides) {
     ...overrides
   };
 }
+function moreRestrictive(a, b) {
+  return ACTION_RANK2[a] >= ACTION_RANK2[b] ? a : b;
+}
+function intersectPermissionPolicy(parent, child) {
+  return {
+    read: moreRestrictive(parent.read, child.read),
+    write: moreRestrictive(parent.write, child.write),
+    execute: moreRestrictive(parent.execute, child.execute),
+    network: moreRestrictive(parent.network, child.network),
+    ui: moreRestrictive(parent.ui, child.ui),
+    auto: parent.auto && child.auto
+  };
+}
 function resolveToolPermission(toolName, required2, policy) {
   if (!required2.length) {
     return { action: "allow", reason: "", categories: [] };
@@ -45083,12 +45203,13 @@ function resolveToolPermission(toolName, required2, policy) {
     categories: hit
   };
 }
-var sessionToolGrants, sessionCategoryGrants;
+var sessionToolGrants, sessionCategoryGrants, ACTION_RANK2;
 var init_toolPermissions = __esm({
   "src/cli/safety/toolPermissions.ts"() {
     "use strict";
     sessionToolGrants = /* @__PURE__ */ new Set();
     sessionCategoryGrants = /* @__PURE__ */ new Set();
+    ACTION_RANK2 = { allow: 0, ask: 1, deny: 2 };
   }
 });
 
@@ -45265,10 +45386,239 @@ var init_lifecycleHooks = __esm({
   }
 });
 
+// src/cli/safety/policyEngine.ts
+import { readFileSync as readFileSync22 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import path40 from "node:path";
+function emptyPolicySet() {
+  return { agents: /* @__PURE__ */ new Map(), warnings: [], precedence: policyPrecedenceFromEnv() };
+}
+function agentLayersFor(set2, agent) {
+  return set2.agents.get(agent) ?? EMPTY_POLICY_LAYERS;
+}
+function globToRegExp(pattern) {
+  let src = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      while (pattern[i + 1] === "*") i++;
+      src += ".*";
+    } else if ("\\^$.|?+()[]{}".includes(ch)) {
+      src += "\\" + ch;
+    } else {
+      src += ch;
+    }
+  }
+  return new RegExp(src + "$");
+}
+function normalizeForMatch(value) {
+  return value.replace(/\\/g, "/");
+}
+function resolvePolicyRule(rules, value) {
+  const v = normalizeForMatch(value);
+  for (const rule of rules) {
+    if (globToRegExp(normalizeForMatch(rule.match)).test(v)) return rule;
+  }
+  return null;
+}
+function mergeRuleEffect(base2, rule) {
+  if (!rule) return base2;
+  return EFFECT_RANK[rule.effect] > EFFECT_RANK[base2] ? rule.effect : base2;
+}
+function pathCandidates(value, root) {
+  const norm = normalizeForMatch(value);
+  if (!root) return [norm];
+  const prefix = normalizeForMatch(root).replace(/\/+$/, "") + "/";
+  const stripped = norm.toLowerCase().startsWith(prefix.toLowerCase()) ? norm.slice(prefix.length) : null;
+  return stripped !== null ? [stripped, norm] : [norm];
+}
+function matchAgentPolicyRule(rules, required2, args, root) {
+  if (!rules) return null;
+  const a = args !== null && typeof args === "object" ? args : {};
+  if (required2.includes("execute")) {
+    const cmd = a["command"];
+    if (typeof cmd === "string" && cmd !== "") {
+      const hit = resolvePolicyRule(rules.shell, cmd);
+      if (hit) return hit;
+    }
+  }
+  if (required2.includes("write")) {
+    const p3 = typeof a["path"] === "string" ? a["path"] : typeof a["file_path"] === "string" ? a["file_path"] : "";
+    if (p3 !== "") {
+      for (const candidate of pathCandidates(p3, root)) {
+        const hit = resolvePolicyRule(rules.edit, candidate);
+        if (hit) return hit;
+      }
+    }
+  }
+  return null;
+}
+function isPolicyEngineDisabled() {
+  const v = process.env.ZELARI_POLICY?.trim().toLowerCase();
+  return v === "0" || v === "false" || v === "no" || v === "off";
+}
+function policyPrecedenceFromEnv() {
+  const v = process.env.ZELARI_POLICY_PRECEDENCE?.trim().toLowerCase();
+  return v === "legacy" ? "legacy" : "restrict-only";
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseRuleList(raw, origin, warnings) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw)) {
+    warnings.push(`${origin}: expected an array of rules, got ${typeof raw} \u2014 section ignored.`);
+    return [];
+  }
+  const out = [];
+  raw.forEach((item, i) => {
+    const where = `${origin}[${i}]`;
+    if (!isPlainObject2(item)) {
+      warnings.push(`${where}: rule is not an object \u2014 skipped.`);
+      return;
+    }
+    const match = item["match"];
+    const effect = item["effect"];
+    const reason = item["reason"];
+    if (typeof match !== "string" || match.trim() === "") {
+      warnings.push(`${where}: missing or empty "match" \u2014 skipped.`);
+      return;
+    }
+    if (effect !== "allow" && effect !== "ask" && effect !== "deny") {
+      warnings.push(`${where} ("${match}"): "effect" must be allow|ask|deny \u2014 skipped.`);
+      return;
+    }
+    out.push(
+      typeof reason === "string" && reason.trim() !== "" ? { match, effect, reason } : { match, effect }
+    );
+  });
+  return out;
+}
+function parsePolicyFile(raw, origin, warnings) {
+  if (!isPlainObject2(raw)) {
+    warnings.push(`${origin}: policy file is not a JSON object \u2014 file ignored.`);
+    return null;
+  }
+  const version2 = raw["version"];
+  if (version2 !== void 0 && version2 !== 1) {
+    warnings.push(`${origin}: unsupported "version" ${JSON.stringify(version2)} (expected 1) \u2014 file ignored.`);
+    return null;
+  }
+  const agentsRaw = raw["agents"];
+  if (agentsRaw === void 0) {
+    warnings.push(`${origin}: no "agents" key \u2014 file ignored.`);
+    return null;
+  }
+  if (!isPlainObject2(agentsRaw)) {
+    warnings.push(`${origin}: "agents" is not an object \u2014 file ignored.`);
+    return null;
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, val] of Object.entries(agentsRaw)) {
+    const agent = key.trim().toLowerCase();
+    if (!KNOWN_AGENTS.has(agent)) {
+      warnings.push(`${origin}: unknown agent "${key}" (known: ${POLICY_AGENTS.join(" | ")}) \u2014 ignored.`);
+      continue;
+    }
+    if (!isPlainObject2(val)) {
+      warnings.push(`${origin}: agents.${key} is not an object \u2014 ignored.`);
+      continue;
+    }
+    const shell = parseRuleList(val["shell"], `${origin} agents.${key}.shell`, warnings);
+    const edit = parseRuleList(val["edit"], `${origin} agents.${key}.edit`, warnings);
+    out.set(agent, { shell, edit });
+  }
+  return out;
+}
+function readPolicyFile(file2, warnings) {
+  let text;
+  try {
+    text = readFileSync22(file2, "utf8");
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    warnings.push(
+      `${file2}: invalid JSON (${err instanceof Error ? err.message : String(err)}) \u2014 file ignored.`
+    );
+    return /* @__PURE__ */ new Map();
+  }
+  return parsePolicyFile(parsed, file2, warnings) ?? /* @__PURE__ */ new Map();
+}
+function loadPolicySet(root, opts = {}) {
+  if (isPolicyEngineDisabled()) return emptyPolicySet();
+  const warnings = [];
+  const precedence = policyPrecedenceFromEnv();
+  const project = readPolicyFile(path40.join(root, ".zelari", "policy.json"), warnings);
+  const global = readPolicyFile(path40.join(opts.homeDir ?? homedir10(), ".zelari", "policy.json"), warnings);
+  const agents = /* @__PURE__ */ new Map();
+  for (const [agent, p3] of project) {
+    agents.set(agent, { project: p3, global: EMPTY_POLICY_RULE_SET });
+  }
+  for (const [agent, g] of global) {
+    const l = agents.get(agent);
+    agents.set(agent, l ? { ...l, global: g } : { project: EMPTY_POLICY_RULE_SET, global: g });
+  }
+  return { agents, warnings, precedence };
+}
+var POLICY_AGENTS, KNOWN_AGENTS, EMPTY_POLICY_RULE_SET, EMPTY_POLICY_LAYERS, EFFECT_RANK;
+var init_policyEngine = __esm({
+  "src/cli/safety/policyEngine.ts"() {
+    "use strict";
+    POLICY_AGENTS = ["lead", "explore", "general", "verify"];
+    KNOWN_AGENTS = new Set(POLICY_AGENTS);
+    EMPTY_POLICY_RULE_SET = { shell: [], edit: [] };
+    EMPTY_POLICY_LAYERS = {
+      global: EMPTY_POLICY_RULE_SET,
+      project: EMPTY_POLICY_RULE_SET
+    };
+    EFFECT_RANK = { allow: 0, ask: 1, deny: 2 };
+  }
+});
+
+// src/cli/safety/policyLayers.ts
+function intersectEffects(...effects) {
+  let best;
+  for (const effect of effects) {
+    if (effect === void 0) continue;
+    if (best === void 0 || EFFECT_RANK[effect] > EFFECT_RANK[best]) best = effect;
+  }
+  return best ?? "allow";
+}
+function matchAgentPolicyRuleLayered(layers, precedence, required2, args, root) {
+  if (!layers) return null;
+  if (precedence === "legacy") {
+    return matchAgentPolicyRule(
+      {
+        shell: [...layers.project.shell, ...layers.global.shell],
+        edit: [...layers.project.edit, ...layers.global.edit]
+      },
+      required2,
+      args,
+      root
+    );
+  }
+  const g = matchAgentPolicyRule(layers.global, required2, args, root);
+  const p3 = matchAgentPolicyRule(layers.project, required2, args, root);
+  if (!g) return p3;
+  if (!p3) return g;
+  const win = intersectEffects(p3.effect, g.effect);
+  return p3.effect === win ? p3 : g;
+}
+var init_policyLayers = __esm({
+  "src/cli/safety/policyLayers.ts"() {
+    "use strict";
+    init_policyEngine();
+  }
+});
+
 // src/cli/toolResultCache.ts
 import { createHash as createHash13 } from "node:crypto";
 import { promises as fs19 } from "node:fs";
-import path40 from "node:path";
+import path41 from "node:path";
 function isToolCacheEnabled() {
   const raw = process.env.ZELARI_TOOL_CACHE;
   return raw !== "0" && raw !== "false" && raw !== "off";
@@ -45353,7 +45703,7 @@ async function statKey(toolName, input, ctx) {
   if (!input || typeof input !== "object") return null;
   const rawPath = input.path;
   if (typeof rawPath !== "string" || rawPath.length === 0) return null;
-  const abs = path40.isAbsolute(rawPath) ? rawPath : path40.join(ctx.cwd, rawPath);
+  const abs = path41.isAbsolute(rawPath) ? rawPath : path41.join(ctx.cwd, rawPath);
   try {
     const st = await fs19.stat(abs);
     return hashKey({
@@ -45402,10 +45752,13 @@ var init_toolResultCache = __esm({
 // src/cli/tools/krakenModel.ts
 var krakenModel_exports = {};
 __export(krakenModel_exports, {
+  inferModelFamily: () => inferModelFamily,
   isCheapModelId: () => isCheapModelId,
   isKrakenAutoModelEnabled: () => isKrakenAutoModelEnabled,
   parseQualifiedModelRef: () => parseQualifiedModelRef,
   pickCheapModel: () => pickCheapModel,
+  pickDifferentFamily: () => pickDifferentFamily,
+  resolveCrossModelVerifier: () => resolveCrossModelVerifier,
   resolveKrakenPlannerModel: () => resolveKrakenPlannerModel,
   resolveKrakenSubModel: () => resolveKrakenSubModel,
   resolveKrakenSubModelAsync: () => resolveKrakenSubModelAsync,
@@ -45450,6 +45803,44 @@ function parseQualifiedModelRef(ref) {
   if (!provider || !model) return null;
   return { provider, model };
 }
+function inferModelFamily(provider, model) {
+  const p3 = (provider ?? "").trim().toLowerCase();
+  const m = (model ?? "").trim().toLowerCase();
+  const hay = `${p3} ${m}`.trim();
+  if (!hay) return "other";
+  if (/\b(zhipu|glm)\b/.test(hay)) return "zhipu";
+  if (/\b(google|gemini)\b/.test(hay)) return "google";
+  if (/\b(xai|grok)\b/.test(hay)) return "xai";
+  if (/\b(anthropic|claude)\b/.test(hay)) return "anthropic";
+  if (/\b(openai|chatgpt|codex)\b/.test(hay) || /\bgpt\b/.test(hay) || /(^|\s)o[134]($|[-_.])/.test(hay)) {
+    return "openai";
+  }
+  return p3 || "other";
+}
+function pickDifferentFamily(builder, candidates) {
+  const builderFamily = inferModelFamily(builder.provider, builder.model);
+  for (const c of candidates) {
+    const provider = c.provider?.trim() ?? "";
+    const model = c.model?.trim() ?? "";
+    if (!provider || !model) continue;
+    if (inferModelFamily(provider, model) !== builderFamily) {
+      return { provider, model };
+    }
+  }
+  return null;
+}
+function resolveCrossModelVerifier(builder, candidates, env = process.env) {
+  const cross = (env.ZELARI_KRAKEN_CROSS_MODEL ?? "").trim().toLowerCase();
+  if (cross === "0" || cross === "false" || cross === "off") return null;
+  const specific = env.ZELARI_KRAKEN_VERIFY_MODEL?.trim();
+  if (specific) {
+    const qualified = parseQualifiedModelRef(specific);
+    if (qualified) return qualified;
+    const provider = builder.provider?.trim();
+    return provider ? { provider, model: specific } : null;
+  }
+  return pickDifferentFamily(builder, candidates);
+}
 function resolveKrakenSubModel(agent, parentModel, env = process.env, opts = {}) {
   const kindKey = agent === "explore" ? "ZELARI_KRAKEN_EXPLORE_MODEL" : agent === "verify" ? "ZELARI_KRAKEN_VERIFY_MODEL" : "ZELARI_KRAKEN_GENERAL_MODEL";
   const specific = env[kindKey]?.trim();
@@ -45462,6 +45853,13 @@ function resolveKrakenSubModel(agent, parentModel, env = process.env, opts = {})
     }
     return shared2;
   }
+  if (agent === "verify" && opts.familyCandidates && opts.familyCandidates.length > 0) {
+    const picked = pickDifferentFamily(
+      { provider: opts.provider ?? "", model: parentModel },
+      opts.familyCandidates
+    );
+    if (picked) return `${picked.provider}/${picked.model}`;
+  }
   if ((agent === "explore" || agent === "verify") && isKrakenAutoModelEnabled(env) && opts.candidates && opts.candidates.length > 0) {
     const picked = pickCheapModel(parentModel, opts.candidates);
     if (picked) return picked;
@@ -45557,7 +45955,19 @@ function createBuiltinToolRegistry(options = {}) {
   const allowMutators = !readOnly && !verifyMode && !gauntletParent;
   const allowBash = (allowMutators || verifyMode) && !gauntletParent;
   const permPolicy = options.permissionPolicy ?? defaultPermissionPolicy();
-  const withPerm = (t) => wrapWithPermissions(t, permPolicy, options.onPermissionAsk);
+  const agentPolicySet = loadPolicySet(root);
+  const agentPolicyLayers = agentLayersFor(
+    agentPolicySet,
+    options.policyAgent ?? "lead"
+  );
+  const withPerm = (t) => wrapWithPermissions(
+    t,
+    permPolicy,
+    options.onPermissionAsk,
+    agentPolicyLayers,
+    agentPolicySet.precedence,
+    root
+  );
   registry4.register(withPerm(safeReadFile));
   registry4.register(withPerm(safeGrepContent));
   registry4.register(withPerm(safeListFiles));
@@ -45691,6 +46101,10 @@ function createBuiltinToolRegistry(options = {}) {
           root,
           audit,
           sessionId: sessionId2,
+          // P0.4 capability inheritance: tentacles intersect THIS
+          // registry's own policy (permPolicy above) — they can never
+          // exceed it.
+          parentPolicy: permPolicy,
           ...options.subAgentProvider ? { provider: options.subAgentProvider } : {},
           ...options.subAgentModel ? { model: options.subAgentModel } : {}
         }),
@@ -45768,7 +46182,7 @@ function taskAgentToProfile(agent) {
   return "explore";
 }
 function createKrakenSubAgentContextFactory(opts) {
-  const { root, audit, sessionId: sessionId2, provider: providerOverride, model: modelOverride } = opts;
+  const { root, audit, sessionId: sessionId2, provider: providerOverride, model: modelOverride, parentPolicy } = opts;
   return async ({ agent, cwd: subCwd }) => {
     const cfg = providerOverride ? await providerConfigFor(providerOverride) : await providerFromEnv();
     if (!cfg) return null;
@@ -45787,6 +46201,11 @@ function createKrakenSubAgentContextFactory(opts) {
     const subCfg = { ...effCfg, model };
     const subProfile = taskAgentToProfile(agent);
     const subRoot = subCwd || root;
+    const agentPolicyForSubProfile = defaultPermissionPolicy({ auto: true });
+    const effectiveSubPolicy = intersectPermissionPolicy(
+      parentPolicy ?? agentPolicyForSubProfile,
+      agentPolicyForSubProfile
+    );
     const { registry: subRegistry } = createBuiltinToolRegistry({
       root: subRoot,
       audit,
@@ -45796,7 +46215,9 @@ function createKrakenSubAgentContextFactory(opts) {
       enableSkill: agent === "general",
       diagnostics: false,
       lspProvider: null,
-      permissionPolicy: defaultPermissionPolicy({ auto: true })
+      permissionPolicy: effectiveSubPolicy,
+      // P0.5: the tentacle's agent identity drives per-agent policy rules.
+      policyAgent: agent
     });
     return {
       providerStream: buildProviderStream(subCfg),
@@ -45813,7 +46234,7 @@ function createKrakenSubAgentContextFactory(opts) {
     };
   };
 }
-function wrapWithPermissions(original, policy, onAsk) {
+function wrapWithPermissions(original, policy, onAsk, agentLayers, precedence = "restrict-only", root) {
   const required2 = original.permissions ?? [];
   const decisionProbe = resolveToolPermission(original.name, required2, policy);
   if (decisionProbe.action === "allow" && !required2.includes("write") && !required2.includes("execute")) {
@@ -45822,13 +46243,22 @@ function wrapWithPermissions(original, policy, onAsk) {
     ...original,
     execute: async (input, ctx) => {
       const decision = resolveToolPermission(original.name, required2, policy);
-      if (decision.action === "deny") {
-        return typedErr(`[permission] ${decision.reason}`);
-      }
-      if (decision.action === "ask") {
+      const rule = agentLayers ? matchAgentPolicyRuleLayered(
+        agentLayers,
+        precedence,
+        required2,
+        input ?? {},
+        root ?? process.cwd()
+      ) : null;
+      const action = mergeRuleEffect(decision.action, rule);
+      const rulePrefix = rule ? `[policy] rule '${rule.match}'${rule.reason ? ` \u2014 ${rule.reason}` : ""}` : "";
+      if (action === "deny") {
+        return typedErr(`[permission] ${rulePrefix || decision.reason}`);
+      }
+      if (action === "ask") {
         if (!onAsk) {
           return typedErr(
-            `[permission] ${decision.reason} No interactive approval available (set ZELARI_AUTO=1 to auto-allow, or configure onPermissionAsk).`
+            `[permission] ${rulePrefix ? `${rulePrefix} ` : ""}${decision.reason} No interactive approval available (set ZELARI_AUTO=1 to auto-allow, or configure onPermissionAsk).`
           );
         }
         try {
@@ -46044,6 +46474,8 @@ var init_toolRegistry = __esm({
     init_providerConfig();
     init_toolPermissions();
     init_lifecycleHooks();
+    init_policyEngine();
+    init_policyLayers();
     init_toolResultCache();
     init_toolTypes();
     init_skills2();
@@ -46064,7 +46496,7 @@ var init_toolRegistry = __esm({
 
 // src/cli/metrics.ts
 import { promises as fs20, existsSync as existsSync25, statSync as statSync4, renameSync as renameSync3, appendFileSync as appendFileSync3, mkdirSync as mkdirSync14 } from "node:fs";
-import path41 from "node:path";
+import path42 from "node:path";
 import os9 from "node:os";
 async function readMetrics(file2) {
   let raw = "";
@@ -46113,8 +46545,8 @@ var init_metrics3 = __esm({
       file;
       writeQueue = Promise.resolve();
       constructor(file2) {
-        this.file = file2 ?? process.env.ANATHEMA_METRICS_FILE ?? path41.join(os9.homedir(), ".tmp", "zelari-code", "metrics.jsonl");
-        mkdirSync14(path41.dirname(this.file), { recursive: true });
+        this.file = file2 ?? process.env.ANATHEMA_METRICS_FILE ?? path42.join(os9.homedir(), ".tmp", "zelari-code", "metrics.jsonl");
+        mkdirSync14(path42.dirname(this.file), { recursive: true });
       }
       /** Metrics file path — doctor/summary readers use this. */
       get filePath() {
@@ -46246,12 +46678,12 @@ Current policy: **lead only**.
 // src/cli/state/fileStateStore.ts
 import { createHash as createHash15, randomUUID as randomUUID3 } from "node:crypto";
 import { promises as fs21 } from "node:fs";
-import * as path43 from "node:path";
+import * as path45 from "node:path";
 function shortId() {
   return randomUUID3().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs21.mkdir(path43.dirname(filePath), { recursive: true });
+  await fs21.mkdir(path45.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   await fs21.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
   await fs21.rename(tmp, filePath);
@@ -46312,11 +46744,11 @@ var init_fileStateStore = __esm({
       indexPath = "";
       async init(projectRoot) {
         this.root = projectRoot;
-        this.stateDir = path43.join(projectRoot, ".zelari", "state");
-        this.commitsDir = path43.join(this.stateDir, "commits");
-        this.artifactsDir = path43.join(this.stateDir, "artifacts");
-        this.headPath = path43.join(this.stateDir, "HEAD.json");
-        this.indexPath = path43.join(this.stateDir, "index.jsonl");
+        this.stateDir = path45.join(projectRoot, ".zelari", "state");
+        this.commitsDir = path45.join(this.stateDir, "commits");
+        this.artifactsDir = path45.join(this.stateDir, "artifacts");
+        this.headPath = path45.join(this.stateDir, "HEAD.json");
+        this.indexPath = path45.join(this.stateDir, "index.jsonl");
         await fs21.mkdir(this.commitsDir, { recursive: true });
         await fs21.mkdir(this.artifactsDir, { recursive: true });
       }
@@ -46329,13 +46761,13 @@ var init_fileStateStore = __esm({
         const discoveries = input.discoveries ?? [];
         const parent = await this.head();
         const id3 = shortId();
-        const artifactRel = path43.join("artifacts", id3);
-        const artifactAbs = path43.join(this.artifactsDir, id3);
+        const artifactRel = path45.join("artifacts", id3);
+        const artifactAbs = path45.join(this.artifactsDir, id3);
         await fs21.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs21.writeFile(path43.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
-        await writeJsonAtomic(path43.join(artifactAbs, "discoveries.json"), discoveries);
-        await writeJsonAtomic(path43.join(artifactAbs, "verification.json"), input.verification);
+        await fs21.writeFile(path45.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await writeJsonAtomic(path45.join(artifactAbs, "discoveries.json"), discoveries);
+        await writeJsonAtomic(path45.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
           id: id3,
           parentId: parent?.id ?? null,
@@ -46347,14 +46779,14 @@ var init_fileStateStore = __esm({
           workspaceCheckpointId: input.workspaceCheckpointId,
           verification: {
             ...input.verification,
-            reportPath: input.verification.reportPath ?? path43.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
+            reportPath: input.verification.reportPath ?? path45.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
           },
           changedPaths: input.changedPaths ?? [],
           stablePromptHash: input.stablePromptHash,
           discoveryCount: discoveries.length,
           artifactDir: artifactRel.replace(/\\/g, "/")
         };
-        await writeJsonAtomic(path43.join(this.commitsDir, `${id3}.json`), meta3);
+        await writeJsonAtomic(path45.join(this.commitsDir, `${id3}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id: id3, updatedAt: meta3.createdAt });
         await fs21.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
@@ -46365,7 +46797,7 @@ var init_fileStateStore = __esm({
         return this.get(head.id);
       }
       async get(id3) {
-        const stored = await readJsonFile(path43.join(this.commitsDir, `${id3}.json`));
+        const stored = await readJsonFile(path45.join(this.commitsDir, `${id3}.json`));
         return stored ? stripStored(stored) : null;
       }
       async list(limit = 20) {
@@ -46404,9 +46836,9 @@ var init_fileStateStore = __esm({
       async loadDiscoveries(id3) {
         const meta3 = id3 ? await this.get(id3) : await this.head();
         if (!meta3) return [];
-        const stored = await readJsonFile(path43.join(this.commitsDir, `${meta3.id}.json`));
+        const stored = await readJsonFile(path45.join(this.commitsDir, `${meta3.id}.json`));
         if (!stored?.artifactDir) return [];
-        const discPath = path43.join(this.stateDir, stored.artifactDir, "discoveries.json");
+        const discPath = path45.join(this.stateDir, stored.artifactDir, "discoveries.json");
         return await readJsonFile(discPath) ?? [];
       }
       async materializeContext(id3, maxChars = DEFAULT_MATERIALIZE_CHARS) {
@@ -47357,7 +47789,7 @@ var init_mode = __esm({
 });
 
 // src/cli/headless.ts
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync23 } from "node:fs";
 function defaultProfileForMode(mode) {
   switch (mode) {
     case "council":
@@ -47378,6 +47810,7 @@ function parseHeadlessFlags(argv) {
   let phase2 = "build";
   let modeExplicit = false;
   let councilFlag = false;
+  let sawModeAuto = false;
   let provider;
   let model;
   let history2;
@@ -47412,7 +47845,7 @@ function parseHeadlessFlags(argv) {
       const next = argv[i + 1];
       if (next) {
         try {
-          const fromFile = readFileSync22(next, "utf-8");
+          const fromFile = readFileSync23(next, "utf-8");
           if (fromFile.trim()) task = fromFile;
         } catch {
         }
@@ -47422,11 +47855,17 @@ function parseHeadlessFlags(argv) {
       councilFlag = true;
     } else if (arg === "--mode") {
       const next = argv[i + 1];
+      if (next !== void 0 && next.trim().toLowerCase() === "auto") {
+        sawModeAuto = true;
+        modeExplicit = true;
+        i++;
+        continue;
+      }
       const parsed = next ? parseMode(next) : null;
       if (!parsed) {
         return {
           options: null,
-          error: `--mode requires 'kraken', 'council', or 'zelari' (agent=alias), got '${next ?? "(missing)"}'`
+          error: `--mode requires 'kraken', 'council', 'zelari', or 'auto' (agent=alias), got '${next ?? "(missing)"}'`
         };
       }
       mode = parsed;
@@ -47455,7 +47894,7 @@ function parseHeadlessFlags(argv) {
         let raw = null;
         if (arg === "--history-file") {
           try {
-            raw = readFileSync22(next, "utf-8");
+            raw = readFileSync23(next, "utf-8");
           } catch {
             raw = null;
           }
@@ -47550,7 +47989,7 @@ function parseHeadlessFlags(argv) {
       const next = argv[i + 1];
       if (next) {
         try {
-          const fromFile = readFileSync22(next, "utf-8");
+          const fromFile = readFileSync23(next, "utf-8");
           if (fromFile.trim()) krakenGraph = fromFile;
         } catch {
         }
@@ -47588,6 +48027,7 @@ function parseHeadlessFlags(argv) {
       mode,
       phase: phase2,
       useCouncil: mode === "council",
+      ...sawModeAuto ? { orchestrationAuto: true } : {},
       provider,
       model,
       ...history2 && history2.length > 0 ? { history: history2 } : {},
@@ -48115,7 +48555,7 @@ var init_claudeProvider = __esm({
 // src/cli/memory/legacyImport.ts
 import { createHash as createHash16 } from "node:crypto";
 import { promises as fs22 } from "node:fs";
-import * as path44 from "node:path";
+import * as path46 from "node:path";
 function sourceId(fact, line) {
   return `jsonl:${fact.id ?? createHash16("sha256").update(line).digest("hex")}`;
 }
@@ -48133,7 +48573,7 @@ function timestamp(value) {
 }
 async function importLegacyMemoryLog(backend, service) {
   const result = { found: 0, imported: 0, skipped: 0, corrupt: 0 };
-  const logPath = path44.join(path44.dirname(backend.databasePath), "log.jsonl");
+  const logPath = path46.join(path46.dirname(backend.databasePath), "log.jsonl");
   let raw;
   try {
     raw = await fs22.readFile(logPath, "utf8");
@@ -48316,7 +48756,7 @@ var init_sqliteCodec = __esm({
 // src/cli/memory/sqliteRpc.ts
 import { existsSync as existsSync27 } from "node:fs";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
-import * as path45 from "node:path";
+import * as path47 from "node:path";
 import { Worker } from "node:worker_threads";
 function isBusy(error51) {
   const candidate = error51;
@@ -48325,10 +48765,10 @@ function isBusy(error51) {
   );
 }
 function resolveWorkerUrl() {
-  const here = path45.dirname(fileURLToPath2(import.meta.url));
-  const direct = path45.join(here, "sqliteWorker.mjs");
+  const here = path47.dirname(fileURLToPath2(import.meta.url));
+  const direct = path47.join(here, "sqliteWorker.mjs");
   if (existsSync27(direct)) return pathToFileURL2(direct);
-  return pathToFileURL2(path45.join(here, "memory", "sqliteWorker.mjs"));
+  return pathToFileURL2(path47.join(here, "memory", "sqliteWorker.mjs"));
 }
 var SqliteWorkerRpc;
 var init_sqliteRpc = __esm({
@@ -48617,7 +49057,7 @@ WHERE NOT EXISTS (SELECT 1 FROM memory_fts f WHERE f.node_id = n.id);
 // src/cli/memory/sqliteBackend.ts
 import { createHash as createHash17, randomUUID as randomUUID4 } from "node:crypto";
 import { promises as fs23 } from "node:fs";
-import * as path46 from "node:path";
+import * as path48 from "node:path";
 function boundedLimit(value, fallback = 50) {
   return Math.max(1, Math.min(Math.floor(value ?? fallback), 1e5));
 }
@@ -48679,16 +49119,16 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         try {
           resolved = await fs23.realpath(projectRoot);
         } catch {
-          resolved = path46.resolve(projectRoot);
+          resolved = path48.resolve(projectRoot);
         }
         if (this.initialized && resolved === this.projectRoot) return;
         if (this.initialized) await this.close();
         const filename = this.options.filename ?? "memory.db";
-        if (path46.basename(filename) !== filename || filename === "." || filename === "..") {
+        if (path48.basename(filename) !== filename || filename === "." || filename === "..") {
           throw new Error("SQLite memory filename must not contain a path.");
         }
-        const zelariDirectory = path46.join(resolved, ".zelari");
-        const directory = path46.join(zelariDirectory, "memory");
+        const zelariDirectory = path48.join(resolved, ".zelari");
+        const directory = path48.join(zelariDirectory, "memory");
         for (const candidate of [zelariDirectory, directory]) {
           let stat2;
           try {
@@ -48707,12 +49147,12 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           }
         }
         const canonicalDirectory = await fs23.realpath(directory);
-        const relativeDirectory = path46.relative(resolved, canonicalDirectory);
-        if (relativeDirectory.startsWith("..") || path46.isAbsolute(relativeDirectory)) {
+        const relativeDirectory = path48.relative(resolved, canonicalDirectory);
+        if (relativeDirectory.startsWith("..") || path48.isAbsolute(relativeDirectory)) {
           throw new Error("SQLite memory directory resolves outside the active project.");
         }
         this.projectRoot = resolved;
-        this.databasePath = path46.join(canonicalDirectory, filename);
+        this.databasePath = path48.join(canonicalDirectory, filename);
         const opened = await this.rpc.open({
           dbPath: this.databasePath,
           schemaSql: SQLITE_MEMORY_BASE_SCHEMA,
@@ -49245,7 +49685,7 @@ __export(serviceFactory_exports, {
 });
 import { createHash as createHash18 } from "node:crypto";
 import { promises as fs24 } from "node:fs";
-import * as path47 from "node:path";
+import * as path49 from "node:path";
 function isMemoryV2Enabled(env = process.env) {
   if (env.ZELARI_MEMORY === "0") return false;
   if (env.ZELARI_MEMORY_BACKEND === "file" || env.ZELARI_MEMORY_BACKEND === "jsonl") return false;
@@ -49266,7 +49706,7 @@ async function canonicalProjectId(projectRoot) {
   try {
     canonical = await fs24.realpath(projectRoot);
   } catch {
-    canonical = path47.resolve(projectRoot);
+    canonical = path49.resolve(projectRoot);
   }
   canonical = canonical.replace(/\\/g, "/").replace(/\/$/, "");
   if (process.platform === "win32") canonical = canonical.toLocaleLowerCase("en-US");
@@ -49334,14 +49774,14 @@ var init_serviceFactory = __esm({
 });
 
 // src/cli/workspace/projectInstructions.ts
-import { existsSync as existsSync28, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync24 } from "node:fs";
 import { join as join26 } from "node:path";
 function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
   for (const name of CANDIDATES) {
     const full = join26(projectRoot, name);
     if (!existsSync28(full)) continue;
     try {
-      let raw = readFileSync23(full, "utf8");
+      let raw = readFileSync24(full, "utf8");
       raw = raw.replace(/\r\n/g, "\n").trim();
       if (!raw) continue;
       if (raw.length <= maxChars) {
@@ -49385,7 +49825,7 @@ __export(workspaceSummary_exports, {
   buildWorkspaceSummary: () => buildWorkspaceSummary,
   buildZelariReadHint: () => buildZelariReadHint
 });
-import { existsSync as existsSync29, readFileSync as readFileSync24, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync25, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
 import { join as join27, relative as relative2 } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30, maxChars = 3500, maxDeps = 24, maxScripts = 16 } = options;
@@ -49423,7 +49863,7 @@ function buildPlanSummary(projectRoot = process.cwd(), options) {
   if (!existsSync29(planPath)) return null;
   let plan;
   try {
-    plan = JSON.parse(readFileSync24(planPath, "utf8"));
+    plan = JSON.parse(readFileSync25(planPath, "utf8"));
   } catch {
     return null;
   }
@@ -49581,7 +50021,7 @@ function readPackageJson(projectRoot) {
   const p3 = join27(projectRoot, "package.json");
   if (!existsSync29(p3)) return null;
   try {
-    return JSON.parse(readFileSync24(p3, "utf8"));
+    return JSON.parse(readFileSync25(p3, "utf8"));
   } catch {
     return null;
   }
@@ -49709,7 +50149,7 @@ var composeContext_exports = {};
 __export(composeContext_exports, {
   composeProjectContext: () => composeProjectContext
 });
-import { existsSync as existsSync31, readdirSync as readdirSync7, readFileSync as readFileSync25 } from "node:fs";
+import { existsSync as existsSync31, readdirSync as readdirSync7, readFileSync as readFileSync26 } from "node:fs";
 import { join as join29 } from "node:path";
 function cap2(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
@@ -49850,15 +50290,15 @@ function readDurableHeadSync(projectRoot) {
   try {
     const headPath = join29(projectRoot, ".zelari", "state", "HEAD.json");
     if (!existsSync31(headPath)) return "";
-    const head = JSON.parse(readFileSync25(headPath, "utf8"));
+    const head = JSON.parse(readFileSync26(headPath, "utf8"));
     if (!head?.id) return "";
     const metaPath = join29(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
     if (!existsSync31(metaPath)) return "";
-    const meta3 = JSON.parse(readFileSync25(metaPath, "utf8"));
+    const meta3 = JSON.parse(readFileSync26(metaPath, "utf8"));
     const discPath = meta3.artifactDir ? join29(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join29(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
     let discoveries = [];
     if (existsSync31(discPath)) {
-      discoveries = JSON.parse(readFileSync25(discPath, "utf8"));
+      discoveries = JSON.parse(readFileSync26(discPath, "utf8"));
     }
     const reusable = discoveries.filter((d) => d.reusable !== false);
     const lines = [
@@ -49891,13 +50331,13 @@ var planDetect_exports = {};
 __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
-import { existsSync as existsSync32, readFileSync as readFileSync26 } from "node:fs";
+import { existsSync as existsSync32, readFileSync as readFileSync27 } from "node:fs";
 import { join as join30 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
   const planPath = join30(resolveWorkspaceRoot(projectRoot), "plan.json");
   if (!existsSync32(planPath)) return false;
   try {
-    const parsed = JSON.parse(readFileSync26(planPath, "utf8"));
+    const parsed = JSON.parse(readFileSync27(planPath, "utf8"));
     return Array.isArray(parsed.phases) && parsed.phases.length > 0;
   } catch {
     return false;
@@ -49959,7 +50399,7 @@ import {
   existsSync as existsSync33,
   readdirSync as readdirSync8,
   writeFileSync as writeFileSync17,
-  readFileSync as readFileSync27,
+  readFileSync as readFileSync28,
   mkdirSync as mkdirSync15,
   renameSync as renameSync4
 } from "node:fs";
@@ -49980,7 +50420,7 @@ function readPlan(ctx) {
   if (existsSync33(jsonPath)) {
     try {
       const parsed = JSON.parse(
-        readFileSync27(jsonPath, "utf8")
+        readFileSync28(jsonPath, "utf8")
       );
       const { phases, tasks, milestones, ...root } = parsed;
       return {
@@ -49992,8 +50432,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path72 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path72);
+  const path74 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path74);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -50171,7 +50611,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path72 = join31(ctx.rootDir, "milestones", `${id3}.md`);
+  const path74 = join31(ctx.rootDir, "milestones", `${id3}.md`);
   const meta3 = {
     kind: "milestone",
     id: id3,
@@ -50188,7 +50628,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path72, meta3, body);
+  ctx.storage.write(path74, meta3, body);
   return { id: id3, created: true };
 }
 function readPlanSummary(ctx) {
@@ -50392,7 +50832,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id3 = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path72 = workspaceArtifact(ctx.rootDir, "decisions", id3);
+        const path74 = workspaceArtifact(ctx.rootDir, "decisions", id3);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -50418,7 +50858,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path72, meta3, body);
+        ctx.storage.write(path74, meta3, body);
         return `ADR ${id3} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -50500,14 +50940,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path72 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path74 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path72, meta3, content);
+        ctx.storage.write(path74, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -50544,7 +50984,7 @@ function searchDocumentsStub(ctx) {
       const results = [];
       for (const file2 of files) {
         if (!existsSync33(file2)) continue;
-        const raw = readFileSync27(file2, "utf8");
+        const raw = readFileSync28(file2, "utf8");
         const content = raw.toLowerCase();
         let idx = -1;
         let matchLen = 0;
@@ -50883,21 +51323,21 @@ var init_mcpClient = __esm({
 import {
   existsSync as existsSync34,
   mkdirSync as mkdirSync16,
-  readFileSync as readFileSync28,
+  readFileSync as readFileSync29,
   writeFileSync as writeFileSync18
 } from "node:fs";
 import { dirname as dirname9, join as join32 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir11 } from "node:os";
 function getUserMcpPath() {
-  return join32(homedir10(), ".zelari-code", "mcp.json");
+  return join32(homedir11(), ".zelari-code", "mcp.json");
 }
 function getProjectMcpPath(projectRoot) {
   return join32(projectRoot, ".zelari", "mcp.json");
 }
-function readFile4(path72) {
-  if (!existsSync34(path72)) return {};
+function readFile4(path74) {
+  if (!existsSync34(path74)) return {};
   try {
-    const parsed = JSON.parse(readFileSync28(path72, "utf8"));
+    const parsed = JSON.parse(readFileSync29(path74, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -50913,10 +51353,10 @@ function readFile4(path72) {
     return {};
   }
 }
-function writeFile2(path72, servers) {
-  mkdirSync16(dirname9(path72), { recursive: true });
+function writeFile3(path74, servers) {
+  mkdirSync16(dirname9(path74), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync18(path72, `${JSON.stringify(body, null, 2)}
+  writeFileSync18(path74, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -50949,9 +51389,9 @@ function upsertMcpServer(opts) {
   if (!opts.config.command?.trim()) {
     return { ok: false, error: "command is required" };
   }
-  let path72;
+  let path74;
   if (opts.scope === "user") {
-    path72 = getUserMcpPath();
+    path74 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -50960,30 +51400,30 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path72 = getProjectMcpPath(root);
+    path74 = getProjectMcpPath(root);
   }
-  const current = readFile4(path72);
+  const current = readFile4(path74);
   current[name] = {
     command: opts.config.command.trim(),
     args: opts.config.args,
     env: opts.config.env,
     enabled: opts.config.enabled !== false
   };
-  writeFile2(path72, current);
-  return { ok: true, path: path72 };
+  writeFile3(path74, current);
+  return { ok: true, path: path74 };
 }
 function removeMcpServer(opts) {
-  const path72 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path72) {
+  const path74 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path74) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile4(path72);
+  const current = readFile4(path74);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path72}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path74}` };
   }
   delete current[opts.name];
-  writeFile2(path72, current);
-  return { ok: true, path: path72 };
+  writeFile3(path74, current);
+  return { ok: true, path: path74 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -51125,14 +51565,14 @@ __export(mcpManager_exports, {
   readMcpConfig: () => readMcpConfig,
   registerMcpTools: () => registerMcpTools
 });
-import { existsSync as existsSync35, readFileSync as readFileSync29 } from "node:fs";
+import { existsSync as existsSync35, readFileSync as readFileSync30 } from "node:fs";
 import { join as join33 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+import { homedir as homedir12 } from "node:os";
 function readMcpConfig(projectRoot = process.cwd(), opts) {
   const merged = {};
   const paths = [];
   if (process.env["ZELARI_MCP_USER"] !== "0") {
-    paths.push(join33(homedir11(), ".zelari-code", "mcp.json"));
+    paths.push(join33(homedir12(), ".zelari-code", "mcp.json"));
   }
   if (!opts?.skipProjectMcp) {
     paths.push(join33(projectRoot, ".zelari", "mcp.json"));
@@ -51140,7 +51580,7 @@ function readMcpConfig(projectRoot = process.cwd(), opts) {
   for (const p3 of paths) {
     if (!existsSync35(p3)) continue;
     try {
-      const parsed = JSON.parse(readFileSync29(p3, "utf8"));
+      const parsed = JSON.parse(readFileSync30(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;
@@ -51379,15 +51819,15 @@ __export(agentsMd_exports, {
   serializeAgentsMd: () => serializeAgentsMd,
   updateAgentsMd: () => updateAgentsMd
 });
-import { existsSync as existsSync36, readFileSync as readFileSync30, writeFileSync as writeFileSync19 } from "node:fs";
+import { existsSync as existsSync36, readFileSync as readFileSync31, writeFileSync as writeFileSync19 } from "node:fs";
 import { createHash as createHash19 } from "node:crypto";
 import { join as join34 } from "node:path";
 import { readFile as readFile5 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path72 = join34(projectRoot, "package.json");
-  if (!existsSync36(path72)) return null;
+  const path74 = join34(projectRoot, "package.json");
+  if (!existsSync36(path74)) return null;
   try {
-    return JSON.parse(await readFile5(path72, "utf8"));
+    return JSON.parse(await readFile5(path74, "utf8"));
   } catch {
     return null;
   }
@@ -51437,7 +51877,7 @@ async function genConventions(ctx) {
   const lines = [];
   const claudeMd = join34(ctx.projectRoot, "CLAUDE.MD");
   if (existsSync36(claudeMd)) {
-    const content = readFileSync30(claudeMd, "utf8");
+    const content = readFileSync31(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
     if (match) {
       lines.push('<!-- Extracted from CLAUDE.MD "Architecture rules" -->');
@@ -51469,9 +51909,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path72 = join34(ctx.rootDir, "risks.md");
-  if (!existsSync36(path72)) return "_No open questions._";
-  const content = readFileSync30(path72, "utf8");
+  const path74 = join34(ctx.rootDir, "risks.md");
+  if (!existsSync36(path74)) return "_No open questions._";
+  const content = readFileSync31(path74, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -51547,7 +51987,7 @@ function titleCase(id3) {
 async function updateAgentsMd(ctx, projectRoot) {
   const agentsPath = join34(projectRoot, "AGENTS.MD");
   if (existsSync36(agentsPath)) {
-    const content = readFileSync30(agentsPath, "utf8");
+    const content = readFileSync31(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id3) => content.includes(MARKER_OPEN(id3)));
     if (!hasAnyMarker) {
       return {
@@ -51563,7 +52003,7 @@ async function updateAgentsMd(ctx, projectRoot) {
   }
   let manualContent = "";
   if (existsSync36(agentsPath)) {
-    const { manualBlocks } = parseAgentsMd(readFileSync30(agentsPath, "utf8"));
+    const { manualBlocks } = parseAgentsMd(readFileSync31(agentsPath, "utf8"));
     manualContent = manualBlocks.after;
   } else {
     const projectName2 = projectName(projectRoot);
@@ -51579,7 +52019,7 @@ async function updateAgentsMd(ctx, projectRoot) {
       ""
     ].join("\n");
   }
-  const oldContent = existsSync36(agentsPath) ? readFileSync30(agentsPath, "utf8") : "";
+  const oldContent = existsSync36(agentsPath) ? readFileSync31(agentsPath, "utf8") : "";
   const { sections: oldSections } = parseAgentsMd(oldContent);
   const changedSections = [];
   for (const id3 of AUTO_SECTIONS) {
@@ -51716,7 +52156,7 @@ var init_completeDesign = __esm({
 });
 
 // src/cli/workspace/planDriftCheck.ts
-import { existsSync as existsSync37, readFileSync as readFileSync31, readdirSync as readdirSync9, statSync as statSync6, writeFileSync as writeFileSync20 } from "node:fs";
+import { existsSync as existsSync37, readFileSync as readFileSync32, readdirSync as readdirSync9, statSync as statSync6, writeFileSync as writeFileSync20 } from "node:fs";
 import { join as join35 } from "node:path";
 function findCanonicalDoc(rootDir) {
   const docsDir = join35(rootDir, "docs");
@@ -51745,9 +52185,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path72) {
+function readFileSyncSafe(path74) {
   try {
-    return readFileSync31(path72, "utf8");
+    return readFileSync32(path74, "utf8");
   } catch {
     return null;
   }
@@ -51762,7 +52202,7 @@ async function runPlanDriftCheck(rootDir) {
   }
   let plan;
   try {
-    plan = JSON.parse(readFileSync31(planPath, "utf8"));
+    plan = JSON.parse(readFileSync32(planPath, "utf8"));
   } catch {
     return { ran: false, reason: ".zelari/plan.json corrupt" };
   }
@@ -51888,7 +52328,7 @@ var init_planDriftCheck = __esm({
 
 // src/cli/workspace/projectSmoke.ts
 import { spawn as spawn14 } from "node:child_process";
-import { existsSync as existsSync38, readFileSync as readFileSync32 } from "node:fs";
+import { existsSync as existsSync38, readFileSync as readFileSync33 } from "node:fs";
 import { join as join36 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
@@ -51907,7 +52347,7 @@ async function runProjectSmoke(projectRoot, timeoutMs2 = DEFAULT_TIMEOUT_MS3) {
   }
   let scripts = {};
   try {
-    const pkg = JSON.parse(readFileSync32(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync33(pkgPath, "utf8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return { ran: false, reason: "package.json unreadable (skipped)" };
@@ -51995,7 +52435,7 @@ __export(postCouncilHook_exports, {
   runPostCouncilHook: () => runPostCouncilHook
 });
 import { spawn as spawn15 } from "node:child_process";
-import { existsSync as existsSync39, readFileSync as readFileSync33 } from "node:fs";
+import { existsSync as existsSync39, readFileSync as readFileSync34 } from "node:fs";
 import { join as join37 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
@@ -52017,7 +52457,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   }
   let phaseCount = 0;
   try {
-    const parsed = JSON.parse(readFileSync33(planJsonPath2, "utf8"));
+    const parsed = JSON.parse(readFileSync34(planJsonPath2, "utf8"));
     phaseCount = Array.isArray(parsed.phases) ? parsed.phases.length : 0;
   } catch {
     return { ran: false, reason: ".zelari/plan.json corrupt" };
@@ -52210,8 +52650,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path72 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path72, completion };
+      const path74 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path74, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -52252,11 +52692,11 @@ __export(councilFeedback_exports, {
 import {
   promises as fs25,
   existsSync as existsSync40,
-  readFileSync as readFileSync34,
+  readFileSync as readFileSync35,
   writeFileSync as writeFileSync21,
   mkdirSync as mkdirSync17
 } from "node:fs";
-import path48 from "node:path";
+import path50 from "node:path";
 import os10 from "node:os";
 var FeedbackStore;
 var init_councilFeedback = __esm({
@@ -52267,7 +52707,7 @@ var init_councilFeedback = __esm({
       now;
       entries = [];
       constructor(options = {}) {
-        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path48.join(os10.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
+        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path50.join(os10.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
         this.now = options.now ?? Date.now;
         this.load();
       }
@@ -52362,7 +52802,7 @@ var init_councilFeedback = __esm({
       load() {
         if (!existsSync40(this.file)) return;
         try {
-          const raw = readFileSync34(this.file, "utf-8");
+          const raw = readFileSync35(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -52373,7 +52813,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync17(path48.dirname(this.file), { recursive: true });
+        mkdirSync17(path50.dirname(this.file), { recursive: true });
         writeFileSync21(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -52441,7 +52881,7 @@ import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path49 from "node:path";
+import path51 from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 async function git3(cwd, args, env) {
   const { stdout } = await execFileAsync2("git", ["-C", cwd, ...args], {
@@ -52461,8 +52901,8 @@ async function isGitRepo(cwd) {
   return await gitSafe(cwd, ["rev-parse", "--is-inside-work-tree"]) === "true";
 }
 async function withTempIndex(fn) {
-  const dir = mkdtempSync(path49.join(tmpdir2(), "zelari-ckpt-"));
-  const indexFile = path49.join(dir, "index");
+  const dir = mkdtempSync(path51.join(tmpdir2(), "zelari-ckpt-"));
+  const indexFile = path51.join(dir, "index");
   try {
     return await fn(indexFile);
   } finally {
@@ -52553,7 +52993,7 @@ async function restoreCheckpoint(cwd, id3) {
     const deleted = [];
     for (const rel2 of added) {
       try {
-        rmSync2(path49.join(cwd, rel2), { force: true });
+        rmSync2(path51.join(cwd, rel2), { force: true });
         deleted.push(rel2);
       } catch {
       }
@@ -52654,7 +53094,7 @@ __export(fileBackend_exports, {
 });
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { promises as fs26 } from "node:fs";
-import * as path50 from "node:path";
+import * as path52 from "node:path";
 function tokenize(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -52705,8 +53145,8 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path50.join(projectRoot, ".zelari", "memory");
-        this.logPath = path50.join(this.memoryDir, "log.jsonl");
+        this.memoryDir = path52.join(projectRoot, ".zelari", "memory");
+        this.logPath = path52.join(this.memoryDir, "log.jsonl");
         await fs26.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata2 = {}, graph) {
@@ -52779,12 +53219,12 @@ var init_fileBackend = __esm({
 
 // src/cli/traceStore.ts
 import { promises as fs27 } from "node:fs";
-import * as path51 from "node:path";
+import * as path53 from "node:path";
 function traceDir(projectRoot) {
-  return path51.join(projectRoot, ".zelari", "trace");
+  return path53.join(projectRoot, ".zelari", "trace");
 }
 function tracePath(projectRoot, missionId) {
-  return path51.join(traceDir(projectRoot), `${missionId}.json`);
+  return path53.join(traceDir(projectRoot), `${missionId}.json`);
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
@@ -52821,7 +53261,7 @@ __export(zelariMission_exports, {
 });
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { promises as fs28 } from "node:fs";
-import * as path52 from "node:path";
+import * as path54 from "node:path";
 function resolveMaxIterations(env = process.env) {
   const raw = env.ZELARI_MISSION_MAX_ITER;
   const n = raw ? Number.parseInt(raw, 10) : DEFAULT_MAX_ITER;
@@ -52864,10 +53304,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state3) {
-  const dir = path52.join(projectRoot, ".zelari");
+  const dir = path54.join(projectRoot, ".zelari");
   await fs28.mkdir(dir, { recursive: true });
   await fs28.writeFile(
-    path52.join(dir, "mission-state.json"),
+    path54.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
   );
@@ -53542,7 +53982,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path72 = safeSocketPath(socketPath);
+  const path74 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -53642,10 +54082,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve7, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path72, () => {
+    server.listen(path74, () => {
       server.removeListener("error", onError);
       resolve7({
-        socketPath: path72,
+        socketPath: path74,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -53656,7 +54096,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path72, () => res());
+              unlink(path74, () => res());
             } else {
               res();
             }
@@ -53669,11 +54109,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path72 = safeSocketPath(socketPath);
+  const path74 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const connectTimeoutMs = opts?.connectTimeoutMs ?? PERMISSION_BROKER_DEFAULT_CONNECT_TIMEOUT_MS;
   return new Promise((resolve7, reject) => {
-    const socket = connect(path72);
+    const socket = connect(path74);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -53688,7 +54128,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path72}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path74}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -54431,9 +54871,9 @@ __export(graphMemory_exports, {
   toGraphSnapshot: () => toGraphSnapshot
 });
 import { promises as fs31 } from "node:fs";
-import path56 from "node:path";
+import path58 from "node:path";
 function snapshotPath(cwd) {
-  return path56.join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
+  return path58.join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
 }
 function toGraphSnapshot(graph, opts) {
   const unresolved = (opts.unresolvedFindings ?? []).map((u) => ({
@@ -54460,7 +54900,7 @@ async function saveGraphSnapshot(cwd, snapshot) {
   try {
     await fs31.access(cwd);
     const file2 = snapshotPath(cwd);
-    await fs31.mkdir(path56.dirname(file2), { recursive: true });
+    await fs31.mkdir(path58.dirname(file2), { recursive: true });
     await fs31.writeFile(file2, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
   } catch {
   }
@@ -54527,7 +54967,7 @@ var SNAPSHOT_DIR, SNAPSHOT_FILE, MAX_SNAPSHOT_FINDINGS_CHARS;
 var init_graphMemory = __esm({
   "src/cli/kraken/graphMemory.ts"() {
     "use strict";
-    SNAPSHOT_DIR = path56.join(".zelari", "kraken");
+    SNAPSHOT_DIR = path58.join(".zelari", "kraken");
     SNAPSHOT_FILE = "last-graph.json";
     MAX_SNAPSHOT_FINDINGS_CHARS = 400;
   }
@@ -54543,14 +54983,14 @@ var init_tentacle = __esm({
 
 // src/cli/kraken/workbench.ts
 import { promises as fs32 } from "node:fs";
-import path57 from "node:path";
+import path59 from "node:path";
 function isWorkbenchEnabled(env = process.env) {
   const v = (env.ZELARI_KRAKEN_WORKBENCH ?? "1").trim().toLowerCase();
   if (v === "0" || v === "false" || v === "no" || v === "off") return false;
   return true;
 }
 function workbenchPath(cwd, graphId) {
-  return path57.join(cwd, ".zelari", "radio", `workbench-${graphId}.md`);
+  return path59.join(cwd, ".zelari", "radio", `workbench-${graphId}.md`);
 }
 function countByStatus2(nodes) {
   const out = { pending: 0, running: 0, done: 0, error: 0, skipped: 0 };
@@ -54713,7 +55153,7 @@ var init_workbench = __esm({
         if (!this.enabled) return null;
         if (!this.dirty && this.lastWrite) return this.lastWrite;
         const out = workbenchPath(this.cwd, this.graphId);
-        await fs32.mkdir(path57.dirname(out), { recursive: true });
+        await fs32.mkdir(path59.dirname(out), { recursive: true });
         const body = this.render();
         const tmp = `${out}.${process.pid}.${Date.now()}.tmp`;
         await fs32.writeFile(tmp, body, "utf8");
@@ -54910,7 +55350,7 @@ __export(executor_exports, {
   thoroughnessForKind: () => thoroughnessForKind
 });
 import { existsSync as existsSync41 } from "node:fs";
-import path58 from "node:path";
+import path60 from "node:path";
 function resolveMaxParallel(env = process.env) {
   const raw = env.ZELARI_KRAKEN_MAX_PARALLEL;
   if (raw === void 0 || raw === "") return DEFAULT_MAX_PARALLEL;
@@ -54968,7 +55408,7 @@ function isWorldModelGateEnabled(cwd, env = process.env, checksExists = defaultC
 }
 function defaultChecksExists(cwd) {
   try {
-    return existsSync41(path58.join(cwd, ".zelari", "world", "checks.json"));
+    return existsSync41(path60.join(cwd, ".zelari", "world", "checks.json"));
   } catch {
     return false;
   }
@@ -56364,17 +56804,17 @@ var init_prereqChecks = __esm({
 });
 
 // src/cli/plugins/prefs.ts
-import { existsSync as existsSync43, readFileSync as readFileSync35, writeFileSync as writeFileSync22, mkdirSync as mkdirSync18 } from "node:fs";
-import path61 from "node:path";
+import { existsSync as existsSync43, readFileSync as readFileSync36, writeFileSync as writeFileSync22, mkdirSync as mkdirSync18 } from "node:fs";
+import path63 from "node:path";
 import os11 from "node:os";
 function getPluginPrefsPath() {
-  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path61.join(os11.homedir(), ".tmp", "zelari-code", "plugins.json");
+  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path63.join(os11.homedir(), ".tmp", "zelari-code", "plugins.json");
 }
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
   try {
     if (!existsSync43(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
-    const raw = readFileSync35(file2, "utf-8");
+    const raw = readFileSync36(file2, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && parsed.dontAskAgain && typeof parsed.dontAskAgain === "object") {
       const clean = {};
@@ -56389,7 +56829,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync18(path61.dirname(file2), { recursive: true });
+  mkdirSync18(path63.dirname(file2), { recursive: true });
   writeFileSync22(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -56426,7 +56866,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync44 } from "node:fs";
-import path62 from "node:path";
+import path64 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -56444,7 +56884,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync44;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path62.win32 : path62.posix;
+  const pathMod = platform === "win32" ? path64.win32 : path64.posix;
   const sep4 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep4).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -57176,7 +57616,7 @@ __export(atMentions_exports, {
   extractAtMentions: () => extractAtMentions,
   hasAtMentions: () => hasAtMentions
 });
-import { existsSync as existsSync47, readFileSync as readFileSync37, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync47, readFileSync as readFileSync38, statSync as statSync9 } from "node:fs";
 import { basename as basename4, isAbsolute as isAbsolute4, relative as relative5, resolve as resolve5, sep as sep2 } from "node:path";
 function isImagePath(abs) {
   const ext = abs.split(".").pop()?.toLowerCase() ?? "";
@@ -57282,7 +57722,7 @@ function resolveMention(token, cwd) {
         note: `image too large (${Math.round(st.size / 1024)} KB) \u2014 path only`
       };
     }
-    const dataBase64 = readFileSync37(abs).toString("base64");
+    const dataBase64 = readFileSync38(abs).toString("base64");
     return {
       raw: token,
       path: rel2,
@@ -57293,7 +57733,7 @@ function resolveMention(token, cwd) {
     };
   }
   try {
-    const buf = readFileSync37(abs);
+    const buf = readFileSync38(abs);
     const head = buf.subarray(0, 800).toString("utf8");
     if (!isProbablyText(abs, head)) {
       return {
@@ -58278,9 +58718,9 @@ __export(triggerLock_exports, {
   releaseLock: () => releaseLock
 });
 import { promises as fs40 } from "node:fs";
-import * as path67 from "node:path";
+import * as path69 from "node:path";
 function lockPath(projectRoot) {
-  return path67.join(projectRoot, ".zelari", "trigger.lock");
+  return path69.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -58293,7 +58733,7 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path67.dirname(lp);
+  const dir = path69.dirname(lp);
   await fs40.mkdir(dir, { recursive: true });
   try {
     const raw = await fs40.readFile(lp, "utf8");
@@ -58721,12 +59161,12 @@ import {
   existsSync as existsSync49,
   mkdirSync as mkdirSync21,
   readdirSync as readdirSync10,
-  readFileSync as readFileSync38,
+  readFileSync as readFileSync39,
   rmSync as rmSync4,
   writeFileSync as writeFileSync24
 } from "node:fs";
 import { dirname as dirname13, join as join45 } from "node:path";
-import { homedir as homedir12 } from "node:os";
+import { homedir as homedir13 } from "node:os";
 function ensureBuiltinSkillsLoadedSync() {
   if (builtinsLoaded) return;
   for (const spec of BUILTIN_SKILL_MODULES) {
@@ -58737,7 +59177,7 @@ function ensureBuiltinSkillsLoadedSync() {
   }
 }
 function getUserSkillsDir() {
-  return join45(homedir12(), ".zelari-code", "skills");
+  return join45(homedir13(), ".zelari-code", "skills");
 }
 function getProjectSkillsDir(projectRoot) {
   return join45(projectRoot, ".zelari", "skills");
@@ -58803,7 +59243,7 @@ function scanSkillsDir(dir, projectRoot, seen, out) {
     const skillPath = skillFilePath(dir, entry);
     if (!existsSync49(skillPath)) continue;
     try {
-      const parsed = parseSkillMd(readFileSync38(skillPath, "utf8"), skillPath);
+      const parsed = parseSkillMd(readFileSync39(skillPath, "utf8"), skillPath);
       if (!parsed) continue;
       if (seen.has(parsed.name)) continue;
       seen.add(parsed.name);
@@ -58887,7 +59327,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path72 = skillFilePath(dir, name);
+  const path74 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -58896,13 +59336,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path72);
+  const parsed = parseSkillMd(content, path74);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync21(dirname13(path72), { recursive: true });
-  writeFileSync24(path72, content, "utf8");
-  return { ok: true, path: path72 };
+  mkdirSync21(dirname13(path74), { recursive: true });
+  writeFileSync24(path74, content, "utf8");
+  return { ok: true, path: path74 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -58920,8 +59360,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join45(dir, name);
-  const path72 = skillFilePath(dir, name);
-  if (!existsSync49(path72) && !existsSync49(skillDir)) {
+  const path74 = skillFilePath(dir, name);
+  if (!existsSync49(path74) && !existsSync49(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -58932,7 +59372,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path72 };
+  return { ok: true, path: path74 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -59051,7 +59491,7 @@ var init_jsonApi = __esm({
 });
 
 // src/cli/memory/mcpAdapter.ts
-import * as path69 from "node:path";
+import * as path71 from "node:path";
 var id2, projectId, source, SearchSchema, AddSchema, LinkSchema, RetractSchema, MEMORY_MCP_TOOLS, MemoryMcpAdapter;
 var init_mcpAdapter = __esm({
   "src/cli/memory/mcpAdapter.ts"() {
@@ -59221,8 +59661,8 @@ var init_mcpAdapter = __esm({
         this.takeWrite();
         const externalFile = args.source?.file;
         if (externalFile) {
-          const normalized = path69.normalize(externalFile);
-          if (path69.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path69.sep}`)) {
+          const normalized = path71.normalize(externalFile);
+          if (path71.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path71.sep}`)) {
             throw new Error("source.file must be project-relative and cannot escape the project");
           }
         }
@@ -59728,14 +60168,14 @@ var init_permissionCli = __esm({
 import {
   existsSync as existsSync50,
   mkdirSync as mkdirSync22,
-  readFileSync as readFileSync39,
+  readFileSync as readFileSync40,
   writeFileSync as writeFileSync25
 } from "node:fs";
 import { join as join46 } from "node:path";
-import { homedir as homedir13 } from "node:os";
+import { homedir as homedir14 } from "node:os";
 import { createHash as createHash20, randomBytes as randomBytes6, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
-  return join46(homedir13(), ".zelari-code");
+  return join46(homedir14(), ".zelari-code");
 }
 function getCompanionConfigPath() {
   return join46(getZelariHome(), "companion.json");
@@ -59750,12 +60190,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path72 = getCompanionConfigPath();
-  if (!existsSync50(path72)) {
+  const path74 = getCompanionConfigPath();
+  if (!existsSync50(path74)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync39(path72, "utf8"));
+    const raw = JSON.parse(readFileSync40(path74, "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) => ({
@@ -59793,16 +60233,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path72 = getCompanionTokenPath();
-  if (existsSync50(path72)) {
-    const t = readFileSync39(path72, "utf8").trim();
+  const path74 = getCompanionTokenPath();
+  if (existsSync50(path74)) {
+    const t = readFileSync40(path74, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes6(24).toString("base64url");
-  writeFileSync25(path72, token + "\n", "utf8");
+  writeFileSync25(path74, token + "\n", "utf8");
   try {
     const fs42 = __require("node:fs");
-    fs42.chmodSync?.(path72, 384);
+    fs42.chmodSync?.(path74, 384);
   } catch {
   }
   return { token, created: true };
@@ -59827,17 +60267,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path72 = raw.trim();
-    if (!path72) continue;
-    let id3 = slugFromPath(path72);
+    const path74 = raw.trim();
+    if (!path74) continue;
+    let id3 = slugFromPath(path74);
     let n = 2;
-    while (byId.has(id3) && byId.get(id3).path !== path72) {
-      id3 = `${slugFromPath(path72)}-${n++}`;
+    while (byId.has(id3) && byId.get(id3).path !== path74) {
+      id3 = `${slugFromPath(path74)}-${n++}`;
     }
     byId.set(id3, {
       id: id3,
-      name: slugFromPath(path72),
-      path: path72
+      name: slugFromPath(path74),
+      path: path74
     });
   }
   return [...byId.values()];
@@ -60214,9 +60654,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path72 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path74 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path72 === "/health" || path72 === "/v1/health")) {
+      if (req.method === "GET" && (path74 === "/health" || path74 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -60228,18 +60668,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path72.startsWith("/v1")) {
+      if (path74.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path72 === "/v1/config") {
+      if (req.method === "GET" && path74 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path72 === "/v1/projects") {
+      if (req.method === "GET" && path74 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -60250,7 +60690,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path72 === "/v1/runs") {
+      if (req.method === "GET" && path74 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -60268,7 +60708,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path72 === "/v1/runs") {
+      if (req.method === "POST" && path74 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -60315,7 +60755,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path72);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path74);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -60380,7 +60820,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path72);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path74);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -60530,26 +60970,26 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync52, readFileSync as readFileSync40, readlinkSync, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync52, readFileSync as readFileSync41, readlinkSync, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path70 from "node:path";
+import path72 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path70.join(dir, "package.json");
+    const candidate = path72.join(dir, "package.json");
     if (existsSync52(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync40(candidate, "utf8"));
+        const pkg = JSON.parse(readFileSync41(candidate, "utf8"));
         if (pkg.name === "zelari-code") return dir;
       } catch {
       }
     }
-    const parent = path70.dirname(dir);
+    const parent = path72.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path70.resolve(__dirname3, "..", "..", "..");
+  return path72.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -60563,8 +61003,8 @@ function tryExec(cmd) {
 }
 function readPackageJson3() {
   try {
-    const pkgPath = path70.join(packageRoot, "package.json");
-    return JSON.parse(readFileSync40(pkgPath, "utf8"));
+    const pkgPath = path72.join(packageRoot, "package.json");
+    return JSON.parse(readFileSync41(pkgPath, "utf8"));
   } catch {
     return null;
   }
@@ -60579,7 +61019,7 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path70.join(prefix, shimName);
+  const shimPath = path72.join(prefix, shimName);
   if (!existsSync52(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
@@ -60589,7 +61029,7 @@ function checkShim(pkgName) {
   try {
     const st = statSync10(shimPath);
     if (isWin) {
-      const content = readFileSync40(shimPath, "utf8");
+      const content = readFileSync41(shimPath, "utf8");
       if (content.includes(`${pkgName}\\bin\\`) || content.includes(`${pkgName}/bin/`)) {
         return OK(`shim OK at ${shimPath} (${st.size} bytes)`);
       }
@@ -60607,8 +61047,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path70.resolve(path70.dirname(shimPath), target);
-    const expected = path70.join(
+    const resolved = path72.resolve(path72.dirname(shimPath), target);
+    const expected = path72.join(
       prefix,
       "node_modules",
       pkgName,
@@ -60647,7 +61087,7 @@ function checkNode(pkg) {
   return OK(`node ${raw}`);
 }
 function checkBundle() {
-  const bundle = path70.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path72.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync52(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -60668,7 +61108,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path70.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path72.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -60868,7 +61308,7 @@ var init_doctor = __esm({
     init_metrics3();
     init_contextGrowthSummary();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path70.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path72.dirname(fileURLToPath3(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -61052,15 +61492,15 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path71 from "node:path";
-import { existsSync as existsSync53, readFileSync as readFileSync41, readdirSync as readdirSync11 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
+import path73 from "node:path";
+import { existsSync as existsSync53, readFileSync as readFileSync42, readdirSync as readdirSync11 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
   const snap = listSkillsSnapshot(cwd);
   const mcp = listMcpServers(cwd);
-  const userMcpPath = path71.join(homedir14(), ".zelari-code", "mcp.json");
-  const projectMcpPath = path71.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path73.join(homedir15(), ".zelari-code", "mcp.json");
+  const projectMcpPath = path73.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -61088,9 +61528,9 @@ async function collectInspectReport(cwd = process.cwd()) {
     configSources: [
       { path: userMcpPath, exists: existsSync53(userMcpPath) },
       { path: projectMcpPath, exists: existsSync53(projectMcpPath) },
-      { path: path71.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync53(path71.join(homedir14(), ".zelari-code", "provider.json")) },
-      { path: path71.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync53(path71.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path71.join(cwd, "AGENTS.md"), exists: existsSync53(path71.join(cwd, "AGENTS.md")) }
+      { path: path73.join(homedir15(), ".zelari-code", "provider.json"), exists: existsSync53(path73.join(homedir15(), ".zelari-code", "provider.json")) },
+      { path: path73.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync53(path73.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path73.join(cwd, "AGENTS.md"), exists: existsSync53(path73.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -61130,14 +61570,14 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path71.join(cwd, "AGENTS.md"),
-    path71.join(cwd, ".zelari", "AGENTS.md")
+    path73.join(cwd, "AGENTS.md"),
+    path73.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
     if (existsSync53(c)) {
       try {
-        const text = readFileSync41(c, "utf8");
+        const text = readFileSync42(c, "utf8");
         found.push(`${c} (${text.length} bytes)`);
       } catch {
         found.push(`${c} (unreadable)`);
@@ -64431,10 +64871,11 @@ import { createHash as createHash14 } from "node:crypto";
 init_runtime2();
 init_verification2();
 import { readFile as readFile3 } from "node:fs/promises";
-import path42 from "node:path";
+import path43 from "node:path";
 function nativePackEnabled(env = process.env) {
   const v = env.ZELARI_VERIFY_PACK?.toLowerCase();
-  return v === "1" || v === "on" || v === "true";
+  if (v === "0" || v === "off" || v === "false") return false;
+  return true;
 }
 function resolvePackCommands(env, scripts) {
   const pick2 = (override, scriptName) => {
@@ -64458,7 +64899,7 @@ function packTimeoutMs(env = process.env) {
 }
 async function readPackageScripts(cwd = process.cwd()) {
   try {
-    const raw = await readFile3(path42.join(cwd, "package.json"), "utf-8");
+    const raw = await readFile3(path43.join(cwd, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && typeof parsed.scripts === "object") {
       return parsed.scripts;
@@ -64497,7 +64938,8 @@ function strictDoneEnabled(surface = "kraken") {
     return true;
   }
   const v = process.env.ZELARI_STRICT_DONE;
-  return v === "1" || v === "true";
+  if (v === "0" || v === "false") return false;
+  return true;
 }
 function criterionId(check2, index) {
   const slug = check2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
@@ -64734,6 +65176,145 @@ function strictGateEventPayload(evaluation) {
   };
 }
 
+// src/cli/kraken/completionProof.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import path44 from "node:path";
+function verdictOf(evaluation) {
+  return evaluation.evaluation?.verdict ?? (evaluation.blocked ? "BLOCKED" : "PASS");
+}
+function cell(text, max = 200) {
+  const flat = text.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function evidenceCell(result) {
+  if (!result || result.evidence.length === 0) return "\u2014";
+  return result.evidence.map((e) => {
+    const parts = [e.tier];
+    if (e.seq !== void 0) parts.push(`seq ${e.seq}`);
+    if (e.digest) parts.push(`digest ${e.digest.slice(0, 8)}\u2026`);
+    return parts.join(" \xB7 ");
+  }).join("; ");
+}
+function proofRows(evaluation) {
+  const nativeById = new Map(
+    (evaluation.native?.criteria ?? []).map((c) => [c.id, c])
+  );
+  const rows = /* @__PURE__ */ new Map();
+  for (const result of evaluation.results ?? []) {
+    const criterion = nativeById.get(result.criterionId);
+    rows.set(result.criterionId, {
+      id: result.criterionId,
+      text: criterion?.text ?? null,
+      required: criterion ? criterion.required : true,
+      status: result.status,
+      result
+    });
+  }
+  for (const unsatisfied of evaluation.evaluation?.unsatisfied ?? []) {
+    if (rows.has(unsatisfied.id)) continue;
+    const criterion = nativeById.get(unsatisfied.id);
+    rows.set(unsatisfied.id, {
+      id: unsatisfied.id,
+      text: criterion?.text ?? null,
+      required: true,
+      // satisfied/unsatisfied lists cover required criteria only
+      status: unsatisfied.status,
+      result: null
+    });
+  }
+  return [...rows.values()];
+}
+function renderMarkdown(evaluation, meta3) {
+  const lines = [
+    "# Completion Proof",
+    "",
+    "Strict build-gate proof-of-work (ADR-0023). The machine-readable twin of",
+    "this document \u2014 `completion-proof.json` \u2014 is the exact `verification.run`",
+    "payload sent to the session spine.",
+    "",
+    `- **Verdict**: **${verdictOf(evaluation)}**`,
+    `- **Strict gate**: ${evaluation.strict ? "on" : "off"}`,
+    `- **Turn blocked**: ${evaluation.blocked ? "yes" : "no"}`,
+    `- **Summary**: ${cell(evaluation.summary, 400)}`,
+    `- **Legacy selection gate**: ${evaluation.gate.passed}/${evaluation.gate.total} passed` + (evaluation.gate.failedChecks.length > 0 ? `; failed: ${evaluation.gate.failedChecks.length}` : "") + (evaluation.gate.unknownChecks.length > 0 ? `; unknown: ${evaluation.gate.unknownChecks.length}` : "")
+  ];
+  if (meta3.surface) lines.push(`- **Surface**: ${meta3.surface}`);
+  if (meta3.sessionId) lines.push(`- **Session**: ${meta3.sessionId} (session spine)`);
+  if (meta3.generatedAt !== void 0) {
+    lines.push(`- **Generated**: ${new Date(meta3.generatedAt).toISOString()}`);
+  }
+  const rows = proofRows(evaluation);
+  lines.push("", "## Criteria", "", "| Criterion | Required | Status | Evidence |", "| --- | --- | --- | --- |");
+  if (rows.length === 0) {
+    lines.push("| _none \u2014 no criteria joined this evaluation_ | \u2014 | \u2014 | \u2014 |");
+  }
+  for (const row of rows) {
+    const label = row.text ? `\`${row.id}\` \u2014 ${cell(row.text)}` : `\`${row.id}\``;
+    lines.push(`| ${label} | ${row.required ? "yes" : "no"} | ${row.status} | ${evidenceCell(row.result)} |`);
+  }
+  const unsatisfied = evaluation.evaluation?.unsatisfied ?? [];
+  if (unsatisfied.length > 0) {
+    lines.push("", "### Unsatisfied", "");
+    for (const u of unsatisfied) lines.push(`- \`${u.id}\`: **${u.status}** \u2014 ${cell(u.reason, 300)}`);
+  }
+  const native = evaluation.native;
+  if (native) {
+    lines.push(
+      "",
+      `## Native criteria pack \u2014 ${native.packId}`,
+      "",
+      "| Criterion | Command | Status | Detail |",
+      "| --- | --- | --- | --- |"
+    );
+    for (const result of native.results) {
+      const criterion = native.criteria.find((c) => c.id === result.criterionId);
+      const check2 = criterion?.check;
+      const command = check2?.kind === "command" ? check2.command : "\u2014";
+      const label = criterion?.text ? `\`${result.criterionId}\` \u2014 ${cell(criterion.text, 120)}` : `\`${result.criterionId}\``;
+      lines.push(`| ${label} | \`${cell(command, 120)}\` | ${result.status} | ${cell(result.detail ?? "\u2014")} |`);
+    }
+  }
+  const review = evaluation.review;
+  if (review) {
+    lines.push(
+      "",
+      "## Advisory verifier review",
+      "",
+      "_Advisory only \u2014 this review cannot change the gate verdict above._",
+      "",
+      `- **Verdict**: ${review.verdict}`
+    );
+    if (review.score !== void 0) lines.push(`- **Score**: ${review.score}`);
+    const model = review.effectiveModel.model ?? review.effectiveModel.provider ?? review.effectiveModel.mode;
+    lines.push(`- **Model**: ${model}${review.usedLogprobs ? " (logprobs)" : ""}`);
+    if (review.fallback) lines.push(`- **Fallback**: ${review.fallback}`);
+    if (review.rationale) lines.push(`- **Rationale**: ${cell(review.rationale, 400)}`);
+  }
+  lines.push("", "---", "", "Machine record: `completion-proof.json` (same directory).");
+  return `${lines.join("\n")}
+`;
+}
+function renderCompletionProof(evaluation, meta3 = {}) {
+  return {
+    markdown: renderMarkdown(evaluation, meta3),
+    json: JSON.stringify(strictGateEventPayload(evaluation), null, 2)
+  };
+}
+async function writeCompletionProof(evaluation, options = {}) {
+  try {
+    const dir = path44.join(options.baseDir ?? process.cwd(), ".zelari");
+    await mkdir2(dir, { recursive: true });
+    const { markdown, json: json3 } = renderCompletionProof(evaluation, options.meta);
+    const markdownPath = path44.join(dir, "completion-proof.md");
+    const jsonPath = path44.join(dir, "completion-proof.json");
+    await writeFile2(markdownPath, markdown, "utf8");
+    await writeFile2(jsonPath, json3, "utf8");
+    return { markdownPath, jsonPath };
+  } catch {
+    return null;
+  }
+}
+
 // src/cli/hooks/permissionPicker.ts
 init_toolPermissions();
 
@@ -65774,10 +66355,15 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
             if (event.type === "agent_end") {
               let krakenSuppressFinish = false;
               const krakenSpineEmit = (input) => writerRef.current?.spine?.appendEvent(input) ?? Promise.resolve(null);
+              const writeProofSafe2 = (gate) => writeCompletionProof(gate, { meta: { surface: "kraken", sessionId: sessionId2 } }).then(
+                () => void 0,
+                () => void 0
+              );
               if (event.reason === "completed" && !krakenRepairEnqueued && (isKrakenSelectionEnabled() || nativePackEnabled()) && workPhase === "build") {
                 const strictGate = await evaluateStrictBuildGate("build", { emit: krakenSpineEmit });
                 const krakenGate = strictGate.gate;
                 writerRef.current?.spine?.verificationRun(strictGateEventPayload(strictGate));
+                await writeProofSafe2(strictGate);
                 if (krakenGate.blocked) {
                   krakenRepairEnqueued = true;
                   markRepairTriggered();
@@ -65791,10 +66377,13 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
                   krakenSuppressFinish = true;
                 }
               }
-              if (event.reason === "completed" && krakenRepairEnqueued && !(await evaluateStrictBuildGate("build", { emit: krakenSpineEmit })).blocked) {
+              const repairCheck = event.reason === "completed" && krakenRepairEnqueued ? await evaluateStrictBuildGate("build", { emit: krakenSpineEmit }) : null;
+              if (repairCheck) await writeProofSafe2(repairCheck);
+              if (repairCheck && !repairCheck.blocked) {
                 markRepairSucceeded();
               } else if (event.reason === "completed" && krakenRepairEnqueued) {
                 const still = await evaluateStrictBuildGate("build", { emit: krakenSpineEmit });
+                await writeProofSafe2(still);
                 if (still.blocked) {
                   appendSystem(
                     setMessages,
@@ -67910,7 +68499,7 @@ init_sessionManager();
 // src/cli/gitOps.ts
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
-import path53 from "node:path";
+import path55 from "node:path";
 var execFileAsync3 = promisify3(execFile4);
 async function git4(cwd, args) {
   try {
@@ -67956,7 +68545,7 @@ async function undoWorkingChanges(opts = {}) {
   };
 }
 function defaultProjectRoot() {
-  return path53.resolve(__dirname, "..", "..", "..");
+  return path55.resolve(__dirname, "..", "..", "..");
 }
 
 // src/cli/slashHandlers/git.ts
@@ -68243,11 +68832,11 @@ function handleCacheStats(ctx) {
 init_messageHelpers();
 init_serviceFactory();
 import { promises as fs30 } from "node:fs";
-import * as path55 from "node:path";
+import * as path57 from "node:path";
 
 // src/cli/memory/promotion.ts
 import { promises as fs29 } from "node:fs";
-import * as path54 from "node:path";
+import * as path56 from "node:path";
 var START = "<!-- zelari:memory-promotions:start -->";
 var END = "<!-- zelari:memory-promotions:end -->";
 var DURABLE_KINDS = /* @__PURE__ */ new Set(["fact", "decision", "constraint", "preference", "procedure"]);
@@ -68258,13 +68847,13 @@ function lineFor(node) {
 }
 async function promoteMemoryToAgentsMd(projectRoot, node) {
   if (node.status !== "active") {
-    return { added: false, path: path54.join(projectRoot, "AGENTS.md"), reason: `memory is ${node.status}` };
+    return { added: false, path: path56.join(projectRoot, "AGENTS.md"), reason: `memory is ${node.status}` };
   }
   if (!DURABLE_KINDS.has(node.kind)) {
-    return { added: false, path: path54.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
+    return { added: false, path: path56.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
   }
-  const root = await fs29.realpath(projectRoot).catch(() => path54.resolve(projectRoot));
-  const target = path54.join(root, "AGENTS.md");
+  const root = await fs29.realpath(projectRoot).catch(() => path56.resolve(projectRoot));
+  const target = path56.join(root, "AGENTS.md");
   try {
     const stat2 = await fs29.lstat(target);
     if (stat2.isSymbolicLink() || !stat2.isFile()) throw new Error("AGENTS.md must be a regular project file.");
@@ -68329,22 +68918,22 @@ function sourceLine(source2) {
   return entries.length ? entries.map(([key, value]) => `${key}=${value}`).join(" \xB7 ") : "unknown";
 }
 function isInside(root, target) {
-  const relative6 = path55.relative(root, target);
-  return relative6 === "" || !relative6.startsWith("..") && !path55.isAbsolute(relative6);
+  const relative6 = path57.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path57.isAbsolute(relative6);
 }
 async function safeExportPath(cwd, requested) {
-  const lexicalRoot = path55.resolve(cwd);
+  const lexicalRoot = path57.resolve(cwd);
   const root = await fs30.realpath(lexicalRoot).catch(() => lexicalRoot);
-  const fallback = path55.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
-  const target = requested?.trim() ? path55.resolve(root, requested.trim()) : fallback;
+  const fallback = path57.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
+  const target = requested?.trim() ? path57.resolve(root, requested.trim()) : fallback;
   if (!isInside(root, target)) {
     throw new Error("Export path must stay inside the active project.");
   }
-  const parent = path55.dirname(target);
-  const relativeParent = path55.relative(root, parent);
+  const parent = path57.dirname(target);
+  const relativeParent = path57.relative(root, parent);
   let cursor = root;
-  for (const segment of relativeParent.split(path55.sep).filter(Boolean)) {
-    cursor = path55.join(cursor, segment);
+  for (const segment of relativeParent.split(path57.sep).filter(Boolean)) {
+    cursor = path57.join(cursor, segment);
     try {
       const stat2 = await fs30.lstat(cursor);
       if (stat2.isSymbolicLink()) {
@@ -68516,9 +69105,9 @@ ${message}` : message
       }
       case "export": {
         const target = await safeExportPath(ctx.cwd, args.join(" ").trim() || void 0);
-        await fs30.mkdir(path55.dirname(target), { recursive: true });
-        const root = await fs30.realpath(ctx.cwd).catch(() => path55.resolve(ctx.cwd));
-        const realParent = await fs30.realpath(path55.dirname(target));
+        await fs30.mkdir(path57.dirname(target), { recursive: true });
+        const root = await fs30.realpath(ctx.cwd).catch(() => path57.resolve(ctx.cwd));
+        const realParent = await fs30.realpath(path57.dirname(target));
         if (!isInside(root, realParent)) {
           throw new Error("Export path resolves outside the active project.");
         }
@@ -68714,7 +69303,7 @@ import { promises as fs34 } from "node:fs";
 init_zod();
 init_taskTool();
 import { promises as fs33 } from "node:fs";
-import path59 from "node:path";
+import path61 from "node:path";
 import { randomBytes as randomBytes5 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
@@ -68731,7 +69320,7 @@ var CsvFanoutArgsSchema = external_exports.object({
   scope_template: external_exports.array(external_exports.string()).optional(),
   /** Default: ZELARI_KRAKEN_MAX_PARALLEL. */
   max_concurrency: external_exports.number().int().positive().optional(),
-  /** Per-row timeout (ms). Default: 5 min for verify, 15 min for general. */
+  /** Per-row timeout (ms). Default: 5 min for verify, 45 min for general. */
   max_runtime_seconds: external_exports.number().int().positive().optional()
 });
 async function readCsv(filePath) {
@@ -68808,8 +69397,8 @@ function resolveMaxConcurrency(env = process.env) {
 }
 async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
-  const absCsv = path59.isAbsolute(args.csv_path) ? args.csv_path : path59.join(opts.parentCwd, args.csv_path);
-  const absOut = path59.isAbsolute(args.output_csv_path) ? args.output_csv_path : path59.join(opts.parentCwd, args.output_csv_path);
+  const absCsv = path61.isAbsolute(args.csv_path) ? args.csv_path : path61.join(opts.parentCwd, args.csv_path);
+  const absOut = path61.isAbsolute(args.output_csv_path) ? args.output_csv_path : path61.join(opts.parentCwd, args.output_csv_path);
   const { headers: headers2, rows } = await readCsv(absCsv);
   if (headers2.length === 0) {
     throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
@@ -68822,7 +69411,7 @@ async function runCsvFanout(args, deps, opts) {
   }
   const concurrency = args.max_concurrency ?? resolveMaxConcurrency();
   opts.onLog?.(`csv fanout: ${rows.length} rows \xD7 ${args.agent_kind} @ concurrency=${concurrency}`);
-  const perRowMs = args.max_runtime_seconds !== void 0 ? args.max_runtime_seconds * 1e3 : args.agent_kind === "general" ? 9e5 : 3e5;
+  const perRowMs = args.max_runtime_seconds !== void 0 ? args.max_runtime_seconds * 1e3 : args.agent_kind === "general" ? TASK_TOOL_TIMEOUT_MS : 3e5;
   const outputRecords = rows.map((r) => ({ ...r, status: "pending", result: "", error: "" }));
   const outHeaders = [...headers2, "status", "result", "error"];
   let writeChain2 = Promise.resolve();
@@ -68865,7 +69454,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs33.mkdir(path59.dirname(absOut), { recursive: true });
+      await fs33.mkdir(path61.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -69060,7 +69649,7 @@ function splitArgs(s) {
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
 import { promises as fs35 } from "node:fs";
-import path60 from "node:path";
+import path62 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
 var EMPTY = {
@@ -69177,14 +69766,14 @@ function formatWorkbenchForTerminal(p3) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 async function handleKrakenWorkbench(ctx) {
-  const dir = path60.join(ctx.cwd, ".zelari", "radio");
+  const dir = path62.join(ctx.cwd, ".zelari", "radio");
   let latest = null;
   let latestMtime = 0;
   try {
     const files = await fs35.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
-      const full = path60.join(dir, f);
+      const full = path62.join(dir, f);
       const stat2 = await fs35.stat(full);
       if (stat2.mtimeMs > latestMtime) {
         latestMtime = stat2.mtimeMs;
@@ -69201,10 +69790,10 @@ async function handleKrakenWorkbench(ctx) {
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
-    appendSystem(ctx.setMessages, `[kraken workbench] ${path60.basename(latest)}: (no nodes / no events yet)`);
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path62.basename(latest)}: (no nodes / no events yet)`);
     return;
   }
-  appendSystem(ctx.setMessages, `[kraken workbench] ${path60.basename(latest)}:
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path62.basename(latest)}:
 ${rendered}`);
 }
 
@@ -69511,15 +70100,15 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 // src/cli/slashHandlers/promoteMember.ts
 init_messageHelpers();
 import { promises as fs36 } from "node:fs";
-import path63 from "node:path";
+import path65 from "node:path";
 import os12 from "node:os";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
-    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path63.join(os12.homedir(), ".tmp", "zelari-code", "skills");
+    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path65.join(os12.homedir(), ".tmp", "zelari-code", "skills");
     await fs36.mkdir(skillDir, { recursive: true });
-    const filePath = path63.join(skillDir, `${skill.id}.md`);
+    const filePath = path65.join(skillDir, `${skill.id}.md`);
     await fs36.writeFile(filePath, markdown, "utf8");
     appendSystem(
       ctx.setMessages,
@@ -69536,25 +70125,25 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs37, existsSync as existsSync45, readFileSync as readFileSync36, writeFileSync as writeFileSync23, mkdirSync as mkdirSync19, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
-import path64 from "node:path";
+import { promises as fs37, existsSync as existsSync45, readFileSync as readFileSync37, writeFileSync as writeFileSync23, mkdirSync as mkdirSync19, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
+import path66 from "node:path";
 import os13 from "node:os";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
-  return process.env.ANATHEMA_BRANCHES_DIR ?? path64.join(os13.homedir(), ".tmp", "zelari-code", "branches");
+  return process.env.ANATHEMA_BRANCHES_DIR ?? path66.join(os13.homedir(), ".tmp", "zelari-code", "branches");
 }
 function getSessionsBaseDir() {
-  return process.env.ANATHEMA_SESSIONS_DIR ?? path64.join(os13.homedir(), ".tmp", "zelari-code", "sessions");
+  return process.env.ANATHEMA_SESSIONS_DIR ?? path66.join(os13.homedir(), ".tmp", "zelari-code", "sessions");
 }
 function branchPathFor(name, baseDir) {
-  return path64.join(baseDir, name);
+  return path66.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path64.join(baseDir, name, META_FILENAME);
+  return path66.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path64.join(baseDir, name, SESSIONS_SUBDIR);
+  return path66.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -69562,7 +70151,7 @@ function readBranchMeta(name, baseDir) {
     throw new BranchNotFoundError(`Branch "${name}" not found`);
   }
   try {
-    const raw = readFileSync36(metaPath, "utf-8");
+    const raw = readFileSync37(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`);
@@ -69579,7 +70168,7 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync19(path64.dirname(metaPath), { recursive: true });
+  mkdirSync19(path66.dirname(metaPath), { recursive: true });
   writeFileSync23(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
@@ -69630,14 +70219,14 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path64.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path66.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync45(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync19(branchSessionsPath, { recursive: true });
-  const destPath = path64.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  const destPath = path66.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs37.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
@@ -69741,14 +70330,14 @@ async function handleBranchCheckout(ctx, branchName) {
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
 import { promises as fs38 } from "node:fs";
-import path65 from "node:path";
+import path67 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path65.join(process.cwd(), ".zelari");
+    const zelari = path67.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path65.join(zelari, "plan.md");
+        const planPath = path67.join(zelari, "plan.md");
         try {
           content = await fs38.readFile(planPath, "utf-8");
         } catch {
@@ -69757,7 +70346,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "decisions": {
-        const decisionsDir = path65.join(zelari, "decisions");
+        const decisionsDir = path67.join(zelari, "decisions");
         try {
           const files = (await fs38.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
@@ -69767,7 +70356,7 @@ async function handleWorkspaceShow(ctx, what) {
 `];
             const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
             for (const f of files) {
-              const raw = await fs38.readFile(path65.join(decisionsDir, f), "utf-8");
+              const raw = await fs38.readFile(path67.join(decisionsDir, f), "utf-8");
               const { meta: meta3, body } = parseFrontmatter2(raw);
               const title = meta3.title ?? body.split("\n")[0]?.replace(/^#\s*/, "").trim() ?? f;
               lines.push(`- **${f.replace(/\.md$/, "")}** [${meta3.status ?? "unknown"}] ${title}`);
@@ -69780,7 +70369,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path65.join(zelari, "risks.md");
+        const risksPath = path67.join(zelari, "risks.md");
         try {
           content = await fs38.readFile(risksPath, "utf-8");
         } catch {
@@ -69789,7 +70378,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "agents": {
-        const agentsPath = path65.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path67.join(process.cwd(), "AGENTS.MD");
         try {
           content = await fs38.readFile(agentsPath, "utf-8");
         } catch {
@@ -69798,7 +70387,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "docs": {
-        const docsDir = path65.join(zelari, "docs");
+        const docsDir = path67.join(zelari, "docs");
         try {
           const files = (await fs38.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
@@ -69840,7 +70429,7 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path65.join(process.cwd(), ".zelari");
+    const target = path67.join(process.cwd(), ".zelari");
     await fs38.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
@@ -69852,7 +70441,7 @@ async function handleWorkspaceReset(ctx, force) {
 init_provider2();
 
 // src/cli/slashHandlers/skills.ts
-import path66 from "node:path";
+import path68 from "node:path";
 import os14 from "node:os";
 
 // src/cli/skillHistory.ts
@@ -69981,7 +70570,7 @@ function handleSkillPicker(ctx, skills, openPicker, fallbackMessage) {
   });
 }
 async function handleSkillStats(ctx, skillId) {
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path66.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path68.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const records = await readSkillHistory(historyFile);
     const stats = getSkillStats(records, skillId);
@@ -69997,7 +70586,7 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
     appendSystem(ctx.setMessages, fallbackMessage ?? "[skill-compare] missing args");
     return;
   }
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path66.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path68.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const formatted = await compareSkillsFromFile(ids[0], ids[1], historyFile);
     appendSystem(ctx.setMessages, formatted);
@@ -71512,6 +72101,54 @@ init_candidateRegistry();
 init_metrics2();
 init_completionGate();
 init_delegationPolicy();
+
+// src/cli/orchestration/policy.ts
+var DEFAULT_MAX_SOLO_CHARS = 300;
+var KRAKEN_SIGNALS = [
+  { re: /\bimplement(?:s|ed|ing)?\b/i, reason: "implementation signal" },
+  { re: /\brefactor(?:ing|ed)?\b/i, reason: "refactor signal" },
+  { re: /\bmigrat(?:e|es|ed|ion|ing)\b/i, reason: "migration signal" },
+  {
+    re: /\b(?:add|build|create|introduce)\b[^.?!]{0,48}\b(?:feature|endpoint|module|service|command|api|registry|runtime)\b/i,
+    reason: "new-capability signal"
+  },
+  {
+    re: /\b(?:unit|integration|e2e|end-to-end)\s+(?:tests?|testing|specs?)\b|\bwrite\s+(?:the\s+|some\s+)?tests?\b/i,
+    reason: "test-writing signal"
+  },
+  {
+    re: /\b\d+\s*-?\s*(?:files?|modules?|packages?|components?|services?|endpoints?|worktrees?)\b/i,
+    reason: "multi-artifact count"
+  },
+  {
+    re: /\b(?:across|spanning|between|touching)\s+(?:all\s+|the\s+)?(?:\w+\s+){0,2}(?:files|modules|packages|layers|surfaces)\b/i,
+    reason: "cross-cutting scope"
+  }
+];
+var QUESTION_RE = /\?\s*$|^(?:who|what|why|when|where|which|how|is|are|was|were|does|do|did|can|could|should|would|will)\b/i;
+var EXPLAIN_RE = /\b(?:explain|describe|summarize|summarise|clarify|walk\W*me\W*through)\b/i;
+var READONLY_RE = /\b(?:find|show|list|grep|search|locate|inspect|read|check|review|where\W+is)\b/i;
+function chooseOrchestration(task, opts = {}) {
+  const text = String(task ?? "").trim();
+  const failClosed = () => ({
+    surface: "solo",
+    reason: "fail-closed default"
+  });
+  if (!text) return failClosed();
+  for (const { re, reason } of KRAKEN_SIGNALS) {
+    if (re.test(text)) return { surface: "kraken", reason };
+  }
+  if (QUESTION_RE.test(text)) return { surface: "solo", reason: "question-shaped task" };
+  if (EXPLAIN_RE.test(text)) return { surface: "solo", reason: "explanation request" };
+  if (READONLY_RE.test(text)) return { surface: "solo", reason: "read-only request" };
+  const budget = opts.maxSoloChars ?? DEFAULT_MAX_SOLO_CHARS;
+  if (text.length <= budget) {
+    return { surface: "solo", reason: "small task, no heavy signals" };
+  }
+  return failClosed();
+}
+
+// src/cli/runHeadless.ts
 init_headless();
 init_claudeProvider();
 init_skills2();
@@ -71550,12 +72187,13 @@ function createStreamScrubber2() {
 init_taskTool();
 init_sessionTodos();
 import { promises as fs41 } from "node:fs";
-import path68 from "node:path";
+import path70 from "node:path";
 import { randomUUID as randomUUID8 } from "node:crypto";
 
 // src/cli/kraken/verifierLifecycle.ts
 init_verification2();
 init_krakenSelectTool();
+init_krakenModel();
 
 // src/cli/kraken/verifierResolution.ts
 init_providerConfig();
@@ -71599,18 +72237,61 @@ function makeVerifierCallModel(loadStream, identity, timeoutMs2 = 12e4) {
     return { text, provider: identity.provider, model: identity.model };
   };
 }
-function resolveIdentity(selection, session) {
+function resolveIdentity(selection, session, familyCandidates, env = process.env) {
   if (selection.mode === "fixed") {
     return { provider: selection.provider, model: selection.model };
   }
-  return session && session.provider && session.model ? session : null;
+  if (!session || !session.provider || !session.model) return null;
+  if (familyCandidates && familyCandidates.length > 0) {
+    const cross = resolveCrossModelVerifier(session, familyCandidates, env);
+    if (cross) return { provider: cross.provider, model: cross.model };
+  }
+  return session;
+}
+function isTestEvidenceCriterion(criterionId2) {
+  const id3 = criterionId2.toLowerCase();
+  return ["test", "typecheck", "build", "lint"].some((k) => id3.includes(k));
+}
+function extractTestOutputExcerpt(results, maxChars = 4e3) {
+  const lines = [];
+  for (const r of results) {
+    if (!isTestEvidenceCriterion(r.criterionId)) continue;
+    lines.push([r.criterionId, r.status, r.detail].filter(Boolean).join(" \u2014 "));
+  }
+  if (lines.length === 0) return "";
+  return lines.join("\n").slice(0, maxChars);
+}
+async function buildBlindReviewInput(evaluation, deps) {
+  const results = evaluation.results ?? [];
+  const passed = results.filter((r) => r.status === "pass").length;
+  const verdict = evaluation.evaluation?.verdict ?? "UNKNOWN";
+  const summary = `Kraken BUILD turn \u2014 deterministic evidence: ${passed}/${results.length} criteria pass, completion verdict ${verdict}.`;
+  const task = deps.task?.trim();
+  const testOutputExcerpt = extractTestOutputExcerpt(results);
+  let diffSummary;
+  try {
+    const res = await (deps.getDiff ?? getWorkingDiff)({
+      cwd: deps.cwd ?? process.cwd(),
+      maxChars: 8e3,
+      staged: true
+    });
+    if (res && !res.empty && res.diff) diffSummary = res.diff;
+  } catch {
+  }
+  return {
+    ...task ? { task } : {},
+    summary,
+    ...diffSummary !== void 0 ? { diffSummary } : {},
+    ...testOutputExcerpt ? { testOutputExcerpt } : {},
+    results
+  };
 }
 async function runAdvisoryVerifierReview(evaluation, deps = {}) {
   if (!evaluation.evaluation || !evaluation.results) return null;
   const env = deps.env ?? process.env;
   const selection = deps.selection ?? loadVerifierModelSelection();
   if (!verifierReviewEnabled(selection, env)) return null;
-  const identity = resolveIdentity(selection, deps.session);
+  const identity = resolveIdentity(selection, deps.session, deps.familyCandidates, env);
   let callModel = deps.callModel;
   if (!callModel) {
     if (!identity || !deps.loadStream) return null;
@@ -71627,11 +72308,9 @@ async function runAdvisoryVerifierReview(evaluation, deps = {}) {
     emit: deps.emit,
     env
   });
-  const passed = evaluation.results.filter((r) => r.status === "pass").length;
-  const summary = `Kraken BUILD turn \u2014 deterministic evidence: ${passed}/${evaluation.results.length} criteria pass, completion verdict ${evaluation.evaluation.verdict}.`;
+  const blind = await buildBlindReviewInput(evaluation, deps);
   const review = await service.reviewCompletion({
-    summary,
-    results: evaluation.results,
+    ...blind,
     session: deps.session
   });
   evaluation.review = review;
@@ -71945,6 +72624,13 @@ ${err.stack}` : "";
       model
     });
   }
+  if (opts.orchestrationAuto) {
+    const verdict = chooseOrchestration(opts.task ?? "");
+    const line = `[orchestration] --mode auto -> surface=${verdict.surface} (${verdict.reason})`;
+    if (opts.output === "json") emitEvent({ type: "log", message: line });
+    else process.stderr.write(`[zelari-code --headless] ${line}
+`);
+  }
   const mode = opts.mode ?? (opts.useCouncil ? "council" : "kraken");
   const profileId = resolveHeadlessProfileId(mode, opts.profile);
   if (opts.output === "json") {
@@ -72018,7 +72704,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   try {
     let preflightGraph;
     if (opts.runPlan && opts.runPlan.trim() !== "") {
-      const planPath = path68.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      const planPath = path70.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
@@ -72058,8 +72744,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
       const planId = randomUUID8();
-      const planDir = path68.join(cwd, ".zelari", "radio");
-      const planPath = path68.join(planDir, `plan-${planId}.json`);
+      const planDir = path70.join(cwd, ".zelari", "radio");
+      const planPath = path70.join(planDir, `plan-${planId}.json`);
       await fs41.mkdir(planDir, { recursive: true });
       await fs41.writeFile(
         planPath,
@@ -72087,6 +72773,18 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
           root: cwd,
           audit,
           sessionId: sessionId2,
+          // P0.4 capability inheritance: tentacles intersect the headless
+          // parent policy. Headless runs are auto-allow (the same literal
+          // the main headless registry below uses), so this is a no-op
+          // today — wired for correctness if that default ever tightens.
+          parentPolicy: {
+            read: "allow",
+            write: "allow",
+            execute: "allow",
+            network: "allow",
+            ui: "allow",
+            auto: true
+          },
           // Anchor every tentacle to the SAME provider/model this run
           // resolved (Desktop's selector, or --provider/--model), instead
           // of the persisted provider.json default the factory falls back
@@ -72179,6 +72877,12 @@ async function registerHeadlessMcp(toolRegistry, opts) {
     }
   }
 }
+function writeProofSafe(gate, meta3, baseDir = process.cwd()) {
+  return writeCompletionProof(gate, { baseDir, meta: meta3 }).then(
+    () => void 0,
+    () => void 0
+  );
+}
 async function runHeadlessSingle(opts, provider, model, providerStream) {
   const sessionId2 = crypto.randomUUID();
   const memoryFactory = await Promise.resolve().then(() => (init_serviceFactory(), serviceFactory_exports));
@@ -72517,6 +73221,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   let strictExit = 0;
   const verifierReviewDeps = {
     session: { provider, model },
+    task: effectiveTask,
     loadStream: async (providerId, modelId) => {
       if (providerId === provider) return providerStream;
       try {
@@ -72544,6 +73249,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     if (opts.output === "json") {
       emitEvent({ type: "verification_run", ...verificationPayload });
     }
+    await writeProofSafe(strictGate, { surface: "kraken", sessionId: spine.sessionId });
     if (strictGate.blocked) {
       const repairPrompt = buildKrakenRepairPrompt(gate);
       if (opts.output === "json") {
@@ -72577,6 +73283,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       if (opts.output === "json") {
         emitEvent({ type: "verification_run", ...afterPayload });
       }
+      await writeProofSafe(after, { surface: "kraken", sessionId: spine.sessionId });
       if (!after.blocked) markRepairSucceeded();
       else {
         strictExit = strictGateExitCode(after);
@@ -72610,7 +73317,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs41.mkdir(path68.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs41.mkdir(path70.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs41.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
@@ -72839,7 +73546,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs41.mkdir(path68.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs41.mkdir(path70.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs41.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
@@ -73219,6 +73926,7 @@ ${ragContext}` : slicePrompt;
       if (opts.output === "json") {
         emitEvent({ type: "verification_run", ...missionVerificationPayload });
       }
+      await writeProofSafe(missionGate, { surface: "mission", sessionId: spine.sessionId }, projectRoot);
       if (missionGate.blocked) {
         exitCode = strictGateExitCode(missionGate);
         spine.missionPhase("verification", "mission-strict-blocked");
@@ -73253,7 +73961,7 @@ ${ragContext}` : slicePrompt;
         if (json3) {
           if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
           else {
-            await fs41.mkdir(path68.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs41.mkdir(path70.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
             await fs41.writeFile(opts.exportSessionPath, json3, "utf8");
           }
         }
@@ -73455,8 +74163,8 @@ function normalizeDraft(raw, sourceUrl, provider, model) {
   let name = String(o.name ?? "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
   if (!name || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
     try {
-      const path72 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
-      name = path72 && /^[a-z0-9]/.test(path72) ? path72 : "imported-skill";
+      const path74 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+      name = path74 && /^[a-z0-9]/.test(path74) ? path74 : "imported-skill";
     } catch {
       name = "imported-skill";
     }