zelari-code 2.38.0 → 2.39.0

package/dist/cli/main.bundled.js

@@ -3482,10 +3482,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path101) {
-  if (!path101)
+function getElementAtPath(obj, path102) {
+  if (!path102)
     return obj;
-  return path101.reduce((acc, key) => acc?.[key], obj);
+  return path102.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3813,11 +3813,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path101, issues) {
+function prefixIssues(path102, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path101);
+    iss.path.unshift(path102);
     return iss;
   });
 }
@@ -4035,16 +4035,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path101 = []) => {
+  const processError = (error52, path102 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path101, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path102, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path101, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path102, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path101, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path102, ...issue2.path]);
       } else {
-        const fullpath = [...path101, ...issue2.path];
+        const fullpath = [...path102, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -4071,17 +4071,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path101 = []) => {
+  const processError = (error52, path102 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path101, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path102, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path101, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path102, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path101, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path102, ...issue2.path]);
       } else {
-        const fullpath = [...path101, ...issue2.path];
+        const fullpath = [...path102, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4113,8 +4113,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path101 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path101) {
+  const path102 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path102) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17617,13 +17617,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path101 = ref.slice(1).split("/").filter(Boolean);
-  if (path101.length === 0) {
+  const path102 = ref.slice(1).split("/").filter(Boolean);
+  if (path102.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path101[0] === defsKey) {
-    const key = path101[1];
+  if (path102[0] === defsKey) {
+    const key = path102[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18457,17 +18457,17 @@ var init_newlines = __esm({
 });
 
 // packages/core/dist/core/tools/builtin/fileEvents.js
-function fileReadEvent(path101, snapshotId) {
-  return { kind: "file.read", actor: { type: "tool" }, data: { path: path101, snapshotId } };
+function fileReadEvent(path102, snapshotId) {
+  return { kind: "file.read", actor: { type: "tool" }, data: { path: path102, snapshotId } };
 }
-function fileAppliedEvent(path101, snapshotId, bytes) {
-  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path101, snapshotId, bytes } };
+function fileAppliedEvent(path102, snapshotId, bytes) {
+  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path102, snapshotId, bytes } };
 }
-function fileRejectedEvent(path101, reason, hint) {
+function fileRejectedEvent(path102, reason, hint) {
   return {
     kind: "file.rejected",
     actor: { type: "tool" },
-    data: hint === void 0 ? { path: path101, reason } : { path: path101, reason, hint }
+    data: hint === void 0 ? { path: path102, reason } : { path: path102, reason, hint }
   };
 }
 function reReadHint(reject) {
@@ -20336,11 +20336,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path101 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path102 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path101,
+            path: path102,
             title,
             content,
             format: "markdown",
@@ -20349,7 +20349,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path101}".`;
+          return `Document "${title}" created at "${path102}".`;
         }
       }
     ];
@@ -25287,16 +25287,16 @@ function runRetentionFromEnv() {
     maxTotalBytes: Number.isFinite(parseMb) && parseMb > 0 ? Math.round(parseMb * 1024 * 1024) : DEFAULT_RUN_RETENTION_MAX_MB * 1024 * 1024
   };
 }
-async function dirSize(path101) {
+async function dirSize(path102) {
   let total = 0;
   let entries;
   try {
-    entries = await readdir(path101, { withFileTypes: true });
+    entries = await readdir(path102, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child = join3(path101, entry.name);
+    const child = join3(path102, entry.name);
     if (entry.isDirectory())
       total += await dirSize(child);
     else {
@@ -25323,19 +25323,19 @@ async function enforceRunRetention(runsDir, options = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const path101 = join3(runsDir, entry.name);
+    const path102 = join3(runsDir, entry.name);
     let startedAt = 0;
     let endedAt;
     let completed = false;
     try {
-      const manifest = JSON.parse(await readFile(join3(path101, "manifest.json"), "utf8"));
+      const manifest = JSON.parse(await readFile(join3(path102, "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: path101, startedAt, endedAt, completed, bytes: await dirSize(path101) });
+    infos.push({ name: entry.name, path: path102, startedAt, endedAt, completed, bytes: await dirSize(path102) });
   }
   const remove = async (info) => {
     await rm(info.path, { recursive: true, force: true });
@@ -25893,12 +25893,12 @@ var init_engine = __esm({
        * content digest) and the returned ref carries the event seq when the
        * emitter resolved one.
        */
-      async fsEvidence(observation, path101, sha2562, content, extra = {}) {
+      async fsEvidence(observation, path102, sha2562, content, extra = {}) {
         const digest = sha2562 && content !== void 0 ? sha2562(content) : void 0;
-        const seq = await this.emitEvidence({ observation, path: path101, ...extra, ...digest ? { digest } : {} });
+        const seq = await this.emitEvidence({ observation, path: path102, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
-          ref: path101,
+          ref: path102,
           capturedAt: Date.now(),
           ...digest ? { digest } : {},
           ...seq !== void 0 ? { seq } : {}
@@ -32107,11 +32107,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join5 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path101 = join5(zelariRoot, "nfr-spec.json");
-  if (!existsSync10(path101))
+  const path102 = join5(zelariRoot, "nfr-spec.json");
+  if (!existsSync10(path102))
     return null;
   try {
-    const raw = JSON.parse(readFileSync9(path101, "utf8"));
+    const raw = JSON.parse(readFileSync9(path102, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -34512,9 +34512,9 @@ var init_types9 = __esm({
 import { readFileSync as readFileSync14 } from "node:fs";
 import { join as join11 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path101 = join11(zelariRoot, LESSONS_FILE);
+  const path102 = join11(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync14(path101, "utf8");
+    const raw = readFileSync14(path102, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -34615,8 +34615,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path101 = join12(zelariRoot, LESSONS_FILE);
-  appendFileSync(path101, `${JSON.stringify(lesson)}
+  const path102 = join12(zelariRoot, LESSONS_FILE);
+  appendFileSync(path102, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -36584,9 +36584,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path101 = [];
+    const path102 = [];
     color.set(start, GRAY);
-    path101.push(start);
+    path102.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id3, idx] = top;
@@ -36599,17 +36599,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path101.indexOf(dep);
-          return [...path101.slice(at), dep];
+          const at = path102.indexOf(dep);
+          return [...path102.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path101.push(dep);
+          path102.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id3, BLACK);
-        path101.pop();
+        path102.pop();
         stack.pop();
       }
     }
@@ -37529,8 +37529,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path101 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path101}`);
+        const path102 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path102}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -37559,18 +37559,22 @@ var init_runner = __esm({
         if (opts.cancelled)
           this.cancelled = true;
         const failed = [...this.tentaclesById.values()].filter((r) => r.status === "error");
+        const unresolvedFindings = failed.map((r) => ({
+          nodeId: r.id,
+          label: r.label,
+          reason: r.status === "error" ? "fail" : "unknown",
+          findings: r.findings
+        }));
         return {
           tentacles: this.tentaclesById,
           mergeCount: this.mergeCount,
           converged: opts.converged,
+          // t55: distinguish "converged clean" from "converged degraded" — the
+          // merge/exit semantics stay on `converged`; this is presentation data.
+          convergedClean: opts.converged && unresolvedFindings.length === 0,
           cancelled: this.cancelled,
           durationMs: Date.now() - this.startTime,
-          unresolvedFindings: failed.map((r) => ({
-            nodeId: r.id,
-            label: r.label,
-            reason: r.status === "error" ? "fail" : "unknown",
-            findings: r.findings
-          }))
+          unresolvedFindings
         };
       }
     };
@@ -38822,7 +38826,7 @@ var CORE_VERSION;
 var init_version = __esm({
   "packages/core/dist/version.js"() {
     "use strict";
-    CORE_VERSION = "2.38.0";
+    CORE_VERSION = "2.39.0";
   }
 });
 
@@ -41304,9 +41308,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 path101 = join14(dir, file2);
-    writeFileSync12(path101, fullText, "utf8");
-    return path101;
+    const path102 = join14(dir, file2);
+    writeFileSync12(path102, fullText, "utf8");
+    return path102;
   } catch {
     return null;
   }
@@ -41352,10 +41356,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path101 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path101) {
+    const path102 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path102) {
       const spillNote = `
-\u2026 [full output spilled to: ${path101} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path102} \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}
 `);
@@ -42158,28 +42162,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path101) {
-        if (!existsSync19(path101)) {
-          throw new Error(`File not found: ${path101}`);
+      read(path102) {
+        if (!existsSync19(path102)) {
+          throw new Error(`File not found: ${path102}`);
         }
-        const md = readFileSync17(path101, "utf8");
+        const md = readFileSync17(path102, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path101) {
-        if (!existsSync19(path101)) return null;
-        return this.read(path101);
+      readIfExists(path102) {
+        if (!existsSync19(path102)) return null;
+        return this.read(path102);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path101, meta3, body) {
-        mkdirSync10(dirname2(path101), { recursive: true });
-        const tmp = path101 + ".tmp-" + process.pid;
+      write(path102, meta3, body) {
+        mkdirSync10(dirname2(path102), { recursive: true });
+        const tmp = path102 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync14(tmp, md, "utf8");
-        renameSync2(tmp, path101);
+        renameSync2(tmp, path102);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -42290,8 +42294,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path101 = join17(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync11(dirname3(path101), { recursive: true });
+  const path102 = join17(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync11(dirname3(path102), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -42312,7 +42316,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path101, meta3, body);
+  new Storage().write(path102, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join17(rootDir, "plan.json");
@@ -45422,6 +45426,220 @@ var init_verifierRouting = __esm({
   }
 });
 
+// src/cli/kraken/exploreCoverage.ts
+var exploreCoverage_exports = {};
+__export(exploreCoverage_exports, {
+  TENTACLE_SIDECAR_SEGMENTS: () => TENTACLE_SIDECAR_SEGMENTS,
+  computeAndStoreExploreCoverage: () => computeAndStoreExploreCoverage,
+  computeCoverage: () => computeCoverage,
+  extractMentionedPaths: () => extractMentionedPaths,
+  normalizePathToken: () => normalizePathToken,
+  sanitizeNodeId: () => sanitizeNodeId,
+  writeTentacleSidecar: () => writeTentacleSidecar
+});
+import { mkdir as mkdir3, readdir as readdir3, readFile as readFile7, writeFile as writeFile3 } from "node:fs/promises";
+import path48 from "node:path";
+function sanitizeNodeId(id3) {
+  return id3.replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 80) || "node";
+}
+async function writeTentacleSidecar(cwd, sessionId2, nodeId, info) {
+  try {
+    const dir = sidecarDir(cwd, sessionId2);
+    await mkdir3(dir, { recursive: true });
+    const header = [
+      `# tentacle ${nodeId}`,
+      `agent: ${info.agent}`,
+      info.thoroughness ? `thoroughness: ${info.thoroughness}` : null,
+      info.model ? `model: ${info.model}` : null,
+      typeof info.durationMs === "number" ? `durationMs: ${info.durationMs}` : null,
+      info.worktree ? `worktree: ${info.worktree}` : null,
+      ""
+    ].filter((line) => line !== null).join("\n");
+    const body = info.result.length > SIDECAR_CAP_CHARS ? info.result.slice(0, SIDECAR_CAP_CHARS) : info.result;
+    await writeFile3(path48.join(dir, `${sanitizeNodeId(nodeId)}.md`), `${header}
+${body}
+`, "utf8");
+  } catch {
+  }
+}
+function sidecarDir(cwd, sessionId2) {
+  return path48.join(cwd, ...TENTACLE_SIDECAR_SEGMENTS, sanitizeNodeId(sessionId2));
+}
+function normalizePathToken(token, cwd) {
+  if (!token) return null;
+  let p3 = token.replace(/^[(`'"<[{]+/, "").replace(/[)`'"\]}>.,:;]+$/, "");
+  p3 = p3.replace(/\\/g, "/");
+  if (p3.length === 0) return null;
+  if (p3.includes("://")) return null;
+  if (!/\.[A-Za-z0-9]{1,8}$/.test(p3)) return null;
+  const low = p3.toLowerCase();
+  if (low.startsWith("node_modules/") || low.includes("/node_modules/")) return null;
+  if (path48.isAbsolute(p3)) {
+    const rel2 = path48.relative(cwd, p3);
+    if (!rel2 || rel2.startsWith("..") || path48.isAbsolute(rel2)) return null;
+    return rel2.split(path48.sep).join("/").toLowerCase();
+  }
+  return low.replace(/^[./]+/, "");
+}
+function extractMentionedPaths(text, cwd) {
+  const out = /* @__PURE__ */ new Set();
+  for (const match of text.match(PATH_TOKEN_RE) ?? []) {
+    const normalized = normalizePathToken(match, cwd);
+    if (normalized) out.add(normalized);
+  }
+  return out;
+}
+function computeCoverage(mentioned, touched) {
+  if (touched.size === 0) return null;
+  let covered = 0;
+  for (const t of touched) if (mentioned.has(t)) covered += 1;
+  return {
+    mentionedCount: mentioned.size,
+    touchedCount: touched.size,
+    coveredCount: covered,
+    ratio: covered / touched.size
+  };
+}
+function declaredThoroughness(raw) {
+  return /^thoroughness:\s*(\S+)/m.exec(raw)?.[1]?.trim().toLowerCase() ?? null;
+}
+async function computeAndStoreExploreCoverage(cwd, sessionId2) {
+  try {
+    const dir = sidecarDir(cwd, sessionId2);
+    const files = await readdir3(dir).catch(() => []);
+    const mentioned = /* @__PURE__ */ new Set();
+    const touched = /* @__PURE__ */ new Set();
+    const exploreModes = /* @__PURE__ */ new Set();
+    let exploreModesUnknown = 0;
+    for (const file2 of files) {
+      if (!file2.endsWith(".md")) continue;
+      const raw = await readFile7(path48.join(dir, file2), "utf8");
+      const agent = /^agent:\s*(\S+)/m.exec(raw)?.[1] ?? "unknown";
+      const paths = extractMentionedPaths(raw, cwd);
+      if (agent === "explore") {
+        for (const p3 of paths) mentioned.add(p3);
+        const mode = declaredThoroughness(raw);
+        if (mode) exploreModes.add(mode);
+        else exploreModesUnknown += 1;
+      } else if (agent === "general" || agent === "fix" || agent === "verify") {
+        for (const p3 of paths) touched.add(p3);
+      }
+    }
+    const coverage = computeCoverage(mentioned, touched);
+    if (!coverage) return null;
+    const report = {
+      sessionId: sessionId2,
+      mentioned: [...mentioned].sort(),
+      touched: [...touched].sort(),
+      covered: [...touched].filter((t) => mentioned.has(t)).sort(),
+      ratio: coverage.ratio,
+      computedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      // Additive: absent when nothing was declared (legacy sidecar headers).
+      ...exploreModes.size > 0 ? { exploreModes: [...exploreModes].sort() } : {},
+      ...exploreModesUnknown > 0 ? { exploreModesUnknown } : {}
+    };
+    await writeFile3(path48.join(dir, "coverage.json"), JSON.stringify(report, null, 2), "utf8");
+    return report;
+  } catch {
+    return null;
+  }
+}
+var TENTACLE_SIDECAR_SEGMENTS, SIDECAR_CAP_CHARS, PATH_TOKEN_RE;
+var init_exploreCoverage = __esm({
+  "src/cli/kraken/exploreCoverage.ts"() {
+    "use strict";
+    TENTACLE_SIDECAR_SEGMENTS = [".zelari", "radio", "tentacles"];
+    SIDECAR_CAP_CHARS = 16 * 1024;
+    PATH_TOKEN_RE = /(?:[A-Za-z]:)?(?:[\w.-]*\/)+[\w.-]+\.[A-Za-z0-9]{1,8}/g;
+  }
+});
+
+// src/cli/kraken/verifyReask.ts
+var verifyReask_exports = {};
+__export(verifyReask_exports, {
+  VERIFY_REASK_ENV: () => VERIFY_REASK_ENV,
+  isVerifyReaskEnabled: () => isVerifyReaskEnabled,
+  reaskVerifyTrailer: () => reaskVerifyTrailer
+});
+function isVerifyReaskEnabled(env = process.env) {
+  const raw = env[VERIFY_REASK_ENV];
+  if (raw === void 0 || raw === "") return true;
+  return !(raw === "0" || raw === "false" || raw === "no");
+}
+async function reaskVerifyTrailer(priorOutput, options = {}) {
+  const env = options.env ?? process.env;
+  if (!isVerifyReaskEnabled(env)) return null;
+  if (typeof priorOutput !== "string" || priorOutput.trim() === "") return null;
+  const provider = options.providerOverride ?? await resolveActiveProvider(env);
+  if (!provider) return null;
+  const capped = priorOutput.length > PRIOR_OUTPUT_CAP_CHARS ? priorOutput.slice(priorOutput.length - PRIOR_OUTPUT_CAP_CHARS) : priorOutput;
+  try {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), REASK_TIMEOUT_MS);
+    let response;
+    try {
+      response = await fetchImpl(provider.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${provider.apiKey}`
+        },
+        body: JSON.stringify({
+          model: provider.model,
+          messages: [
+            { role: "system", content: REASK_SYSTEM_PROMPT },
+            { role: "user", content: capped }
+          ],
+          temperature: 0,
+          stream: false
+        }),
+        signal: ac.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!response.ok) return null;
+    const json3 = await response.json();
+    const raw = json3.choices?.[0]?.message?.content;
+    if (typeof raw !== "string") return null;
+    const { verdict } = parseVerifyVerdict(raw);
+    return verdict === "pass" || verdict === "fail" ? verdict : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveActiveProvider(env) {
+  const cfg = await getProviderConfig();
+  if (!cfg) return null;
+  const providerId = cfg.activeProviderId;
+  const key = await resolveApiKeyWithMeta(providerId, env);
+  if (!key?.apiKey) return null;
+  const model = getModelForProvider(providerId) ?? cfg.modelByProvider[providerId] ?? "";
+  const endpoint = getCustomEndpoint(providerId) ?? `https://api.openai.com/v1/chat/completions`;
+  return { providerId, model, endpoint, apiKey: key.apiKey };
+}
+var VERIFY_REASK_ENV, REASK_TIMEOUT_MS, PRIOR_OUTPUT_CAP_CHARS, REASK_SYSTEM_PROMPT;
+var init_verifyReask = __esm({
+  "src/cli/kraken/verifyReask.ts"() {
+    "use strict";
+    init_dist();
+    init_providerConfig();
+    init_keyStore();
+    VERIFY_REASK_ENV = "ZELARI_KRAKEN_VERIFY_REASK";
+    REASK_TIMEOUT_MS = 12e3;
+    PRIOR_OUTPUT_CAP_CHARS = 8e3;
+    REASK_SYSTEM_PROMPT = [
+      "You are a verdict-normalization helper.",
+      "The message below is a code-review verify report whose final verdict trailer line is missing or malformed.",
+      "Re-read the report and emit, as the LAST line, ONLY the verdict the report already supports:",
+      "`VERDICT: PASS` or `VERDICT: FAIL`.",
+      "Do not re-review the work, do not add commentary.",
+      "If the report genuinely supports neither verdict, emit `VERDICT: UNKNOWN`."
+    ].join(" ");
+  }
+});
+
 // src/cli/kraken/weaknessMeter.ts
 var weaknessMeter_exports = {};
 __export(weaknessMeter_exports, {
@@ -45449,7 +45667,7 @@ async function measureWeaknessViaLLM(text, options = {}) {
   const env = options.env ?? process.env;
   if (!isWeaknessMeterEnabled(env)) return null;
   if (typeof text !== "string" || text.trim() === "") return null;
-  const provider = options.providerOverride ?? await resolveActiveProvider(env);
+  const provider = options.providerOverride ?? await resolveActiveProvider2(env);
   if (!provider) return null;
   const model = options.modelOverride ?? resolveMeterModel(env, provider.model);
   const userPayload = JSON.stringify({
@@ -45515,7 +45733,7 @@ function parseMeterContent(raw, model, durationMs) {
     model
   };
 }
-async function resolveActiveProvider(env) {
+async function resolveActiveProvider2(env) {
   const cfg = await getProviderConfig();
   if (!cfg) return null;
   const providerId = cfg.activeProviderId;
@@ -45569,7 +45787,7 @@ __export(executor_exports, {
   thoroughnessForKind: () => thoroughnessForKind
 });
 import { existsSync as existsSync25 } from "node:fs";
-import path48 from "node:path";
+import path49 from "node:path";
 async function defaultSymbolExtractor(file2) {
   if (!isAstSupported(file2)) return null;
   const r = await parseFileSymbolsDiag(file2);
@@ -45635,7 +45853,7 @@ function isWorldModelGateEnabled(cwd, env = process.env, checksExists = defaultC
 }
 function defaultChecksExists(cwd) {
   try {
-    return existsSync25(path48.join(cwd, ".zelari", "world", "checks.json"));
+    return existsSync25(path49.join(cwd, ".zelari", "world", "checks.json"));
   } catch {
     return false;
   }
@@ -45921,13 +46139,13 @@ var init_executor = __esm({
           const { id: id3, res } = await Promise.race(inFlight.values());
           inFlight.delete(id3);
           const settledNode = graph.nodes.get(id3);
-          if (settledNode) this.applyResult(graph, settledNode, res);
+          if (settledNode) await this.applyResultWithReask(graph, settledNode, res);
           updateKrakenGraphLive(graph);
         }
         if (inFlight.size > 0) {
           for (const { id: id3, res } of await Promise.all(inFlight.values())) {
             const node = graph.nodes.get(id3);
-            if (node) this.applyResult(graph, node, res);
+            if (node) await this.applyResultWithReask(graph, node, res);
           }
           inFlight.clear();
         }
@@ -45939,6 +46157,8 @@ var init_executor = __esm({
         }
         let backtest;
         const converged = !this.aborted && isConverged(graph);
+        const unresolvedCount = this.unresolved.length;
+        const convergedClean = converged && unresolvedCount === 0;
         if (converged) {
           const gateOn = this.worldModelGateOverride ?? isWorldModelGateEnabled(this.parentCwd);
           if (gateOn) {
@@ -45946,7 +46166,10 @@ var init_executor = __esm({
           }
           this.radio("graph_converged", {
             description: "graph executor",
-            detail: backtest ? `backtest: ${backtest.passed}/${backtest.total} passed` : void 0,
+            detail: [
+              backtest ? `backtest: ${backtest.passed}/${backtest.total} passed` : void 0,
+              convergedClean ? void 0 : `degraded: ${unresolvedCount} unresolved`
+            ].filter((part) => part !== void 0).join(" \u2014 ") || void 0,
             ok: backtest ? backtest.ok : true
           });
         } else {
@@ -45958,7 +46181,7 @@ var init_executor = __esm({
         }
         endKrakenGraphLive(graph, converged);
         this.wb?.logEvent(
-          converged ? "graph_converged" : `graph_failed: ${this.aborted ? "cancelled" : failedNodeIds(graph).join(", ") || "none"}`
+          converged ? convergedClean ? "graph_converged" : `graph_converged (degraded: ${unresolvedCount} unresolved)` : `graph_failed: ${this.aborted ? "cancelled" : failedNodeIds(graph).join(", ") || "none"}`
         );
         await this.wb?.flush();
         this.wb?.close();
@@ -45971,9 +46194,25 @@ var init_executor = __esm({
             unresolvedFindings: this.unresolved
           })
         );
+        void (async () => {
+          try {
+            const { computeAndStoreExploreCoverage: computeAndStoreExploreCoverage2 } = await Promise.resolve().then(() => (init_exploreCoverage(), exploreCoverage_exports));
+            const report = await computeAndStoreExploreCoverage2(this.parentCwd, this.sessionId);
+            if (report) {
+              this.radio("node_meter", {
+                description: "explore coverage",
+                agent: "coverage",
+                detail: `touched=${report.touched.length} covered=${report.covered.length} ratio=${report.ratio.toFixed(2)}`,
+                ok: true
+              });
+            }
+          } catch {
+          }
+        })();
         return {
           graph,
           converged,
+          convergedClean,
           failedNodeIds: failedNodeIds(graph),
           counts: countByStatus(graph),
           durationsMs: Object.fromEntries(this.durationsMs),
@@ -46146,7 +46385,7 @@ var init_executor = __esm({
         try {
           const summary = aggregate(
             records,
-            { repo: path48.basename(this.parentCwd), role: agentForNode(node) },
+            { repo: path49.basename(this.parentCwd), role: agentForNode(node) },
             now
           );
           sample = summary.sample;
@@ -46507,12 +46746,29 @@ ${upstream}` : node.prompt,
           worktreeHandle: null
         };
       }
+      /**
+       * t56: settle a node, running the minimal one-shot trailer re-ask FIRST
+       * when a verify's verdict failed to parse. The re-ask is a single
+       * no-tools completion on the reviewer's own prior output (weaknessMeter
+       * pattern), so "one re-ask" costs a trailer line, not a second verify.
+       * Every non-unknown path is byte-identical to the old `applyResult`.
+       */
+      async applyResultWithReask(graph, node, res) {
+        let verifyOverride;
+        if (node.kind === "verify" && res.ok && typeof res.result === "string") {
+          const pre = parseVerifyVerdict(res.result);
+          if (pre.verdict === "unknown") {
+            verifyOverride = await this.maybeReaskUnknownVerdict(node);
+          }
+        }
+        this.applyResult(graph, node, res, verifyOverride);
+      }
       /** Apply a tentacle result to its node: success, retry, fix-spawn, or terminal failure. */
-      applyResult(graph, node, res) {
-        this.applyResultInner(graph, node, res);
+      applyResult(graph, node, res, verifyOverride) {
+        this.applyResultInner(graph, node, res, verifyOverride);
         this.recordNodeReputation(node, res);
       }
-      applyResultInner(graph, node, res) {
+      applyResultInner(graph, node, res, verifyOverride) {
         if (res.ok) {
           if (res.memoryId) this.memoryIds.set(node.id, res.memoryId);
           node.status = "done";
@@ -46526,7 +46782,7 @@ ${upstream}` : node.prompt,
             ...res.model && res.model !== "n/a" ? { model: res.model } : {}
           });
           this.reconcileRepairedNode(graph, node);
-          if (node.kind === "verify") this.applyVerifyVerdict(graph, node);
+          if (node.kind === "verify") this.applyVerifyVerdict(graph, node, verifyOverride);
           return;
         }
         node.error = res.error;
@@ -46623,7 +46879,7 @@ ${upstream}` : node.prompt,
           const model = res.ok && res.model && res.model !== "n/a" ? res.model : null;
           const reviewerVerdict = res.ok && this.isReviewerKind(node.kind) && typeof node.result === "string" && node.result.length > 0 ? parseVerifyVerdict(node.result).verdict : null;
           const record2 = reputationRecordFromNodeRun({
-            repo: path48.basename(this.parentCwd),
+            repo: path49.basename(this.parentCwd),
             role: agentForNode(node),
             kind: node.kind,
             ok: res.ok,
@@ -46763,8 +47019,37 @@ ${upstream}` : node.prompt,
        * every graph — but it is recorded, because a gate that has silently stopped
        * working is worse than no gate.
        */
-      applyVerifyVerdict(graph, verify) {
-        const { verdict, findings } = parseVerifyVerdict(verify.result);
+      /**
+       * t56 — ONE minimal re-ask for an `unknown` verify verdict: a single
+       * no-tools completion on the reviewer's own prior output (weaknessMeter
+       * pattern), parsed with the SAME single-source parser. Default ON,
+       * opt-out ZELARI_KRAKEN_VERIFY_REASK=0. Returns undefined when disabled
+       * or failed — the existing unknown-flow is then unchanged. The node's
+       * raw result is never rewritten; audit sees the original verbatim.
+       */
+      async maybeReaskUnknownVerdict(verify) {
+        let reask;
+        try {
+          reask = await Promise.resolve().then(() => (init_verifyReask(), verifyReask_exports));
+        } catch {
+          return void 0;
+        }
+        const text = typeof verify.result === "string" ? verify.result : "";
+        if (text.length === 0) return void 0;
+        const verdict = await reask.reaskVerifyTrailer(text);
+        if (verdict !== "pass" && verdict !== "fail") return void 0;
+        this.radio("node_end", {
+          description: verify.label,
+          agent: "verify",
+          detail: `unknown verdict recovered via one-shot re-ask \u2192 ${verdict.toUpperCase()}`,
+          ok: true
+        });
+        return verdict;
+      }
+      applyVerifyVerdict(graph, verify, reaskedVerdict) {
+        const parsed = parseVerifyVerdict(verify.result);
+        const verdict = parsed.verdict === "unknown" && (reaskedVerdict === "pass" || reaskedVerdict === "fail") ? reaskedVerdict : parsed.verdict;
+        const findings = parsed.findings;
         if (verdict === "pass") return;
         const writer = this.writerBehind(verify, graph);
         if (!writer) return;
@@ -47653,6 +47938,18 @@ ${verifyHintForGeneral(args.acceptance)}`;
     durationMs,
     ok: true
   });
+  try {
+    const { writeTentacleSidecar: writeTentacleSidecar2 } = await Promise.resolve().then(() => (init_exploreCoverage(), exploreCoverage_exports));
+    await writeTentacleSidecar2(parentCwd, sessionId2, opts.nodeId ?? liveId, {
+      agent,
+      thoroughness,
+      model: sub.model,
+      durationMs,
+      result,
+      worktree: worktree?.path ?? null
+    });
+  } catch {
+  }
   let memoryId;
   if (deps.memoryService && deps.memoryAutoWrite !== false) {
     try {
@@ -49792,7 +50089,7 @@ var init_planTaskTools = __esm({
 
 // src/cli/tools/inspectTypecheckSafety.ts
 import { promises as fs21 } from "node:fs";
-import path49 from "node:path";
+import path50 from "node:path";
 import { spawn as spawn9 } from "node:child_process";
 async function scanTsbuildinfo(root) {
   const found = [];
@@ -49806,11 +50103,11 @@ async function scanTsbuildinfo(root) {
       continue;
     }
     for (const entry of entries) {
-      const p3 = path49.join(dir, entry.name);
+      const p3 = path50.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SCAN_SKIP.has(entry.name)) stack.push(p3);
       } else if (entry.name.endsWith(".tsbuildinfo")) {
-        found.push(path49.relative(root, p3).split(path49.sep).join("/"));
+        found.push(path50.relative(root, p3).split(path50.sep).join("/"));
       }
     }
   }
@@ -49846,7 +50143,7 @@ async function cleanupArtifacts(root, relPaths) {
   const failed = [];
   for (const rel2 of relPaths) {
     try {
-      await fs21.unlink(path49.join(root, rel2));
+      await fs21.unlink(path50.join(root, rel2));
       cleaned.push(rel2);
     } catch {
       failed.push(rel2);
@@ -49873,13 +50170,13 @@ import { spawn as spawn10 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
 import { existsSync as existsSync28, promises as fs22 } from "node:fs";
 import os2 from "node:os";
-import path50 from "node:path";
+import path51 from "node:path";
 function resolveNodeModuleBin(start, rel2) {
-  let dir = path50.resolve(start);
+  let dir = path51.resolve(start);
   for (; ; ) {
-    const candidate = path50.join(dir, "node_modules", rel2);
+    const candidate = path51.join(dir, "node_modules", rel2);
     if (existsSync28(candidate)) return candidate;
-    const parent = path50.dirname(dir);
+    const parent = path51.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -49947,7 +50244,7 @@ function buildInspectCommand(op, ctx) {
     case "npm_ls":
     case "npm_outdated":
     case "npm_view": {
-      const npmCli = ctx.npmCliPath ?? resolveNodeModuleBin(ctx.root, path50.join("npm", "bin", "npm-cli.js")) ?? path50.join(ctx.root, "node_modules", "npm", "bin", "npm-cli.js");
+      const npmCli = ctx.npmCliPath ?? resolveNodeModuleBin(ctx.root, path51.join("npm", "bin", "npm-cli.js")) ?? path51.join(ctx.root, "node_modules", "npm", "bin", "npm-cli.js");
       if (op.operation === "npm_view") {
         const err = rejectFlagLike("package", op.package);
         if (err) return { ok: false, reason: err };
@@ -49956,14 +50253,14 @@ function buildInspectCommand(op, ctx) {
       return { ok: true, command: process.execPath, argv: [npmCli, ...sub], inspectionClass: "env-info" };
     }
     case "typecheck": {
-      const project = path50.resolve(ctx.cwd, op.project ?? "tsconfig.json");
+      const project = path51.resolve(ctx.cwd, op.project ?? "tsconfig.json");
       const hash3 = createHash14("sha256").update(project).digest("hex").slice(0, 16);
-      const tsBuildInfoFile = path50.join(os2.tmpdir(), "zelari-inspect", `${hash3}.tsbuildinfo`);
+      const tsBuildInfoFile = path51.join(os2.tmpdir(), "zelari-inspect", `${hash3}.tsbuildinfo`);
       return {
         ok: true,
         command: process.execPath,
         argv: [
-          ctx.tscPath ?? resolveNodeModuleBin(ctx.root, path50.join("typescript", "bin", "tsc")) ?? resolveNodeModuleBin(ctx.cwd, path50.join("typescript", "bin", "tsc")) ?? path50.join(ctx.root, "node_modules", "typescript", "bin", "tsc"),
+          ctx.tscPath ?? resolveNodeModuleBin(ctx.root, path51.join("typescript", "bin", "tsc")) ?? resolveNodeModuleBin(ctx.cwd, path51.join("typescript", "bin", "tsc")) ?? path51.join(ctx.root, "node_modules", "typescript", "bin", "tsc"),
           "--noEmit",
           // S3.5 primary mechanism: redirect, never disable — composite forces
           // incremental (TS#30661), so --incremental false would break on the
@@ -50931,9 +51228,9 @@ var init_client = __esm({
 });
 
 // src/cli/lsp/servers.ts
-import path51 from "node:path";
+import path52 from "node:path";
 function languageIdForFile(file2) {
-  const ext = path51.extname(file2).toLowerCase();
+  const ext = path52.extname(file2).toLowerCase();
   const map2 = {
     ".ts": "typescript",
     ".tsx": "typescriptreact",
@@ -50948,7 +51245,7 @@ function languageIdForFile(file2) {
   return map2[ext] ?? "plaintext";
 }
 function serverForFile(file2, servers = LSP_SERVERS) {
-  const ext = path51.extname(file2).toLowerCase();
+  const ext = path52.extname(file2).toLowerCase();
   return servers.find((s) => s.extensions.includes(ext)) ?? null;
 }
 function resolveServerCommand(file2, cwd, servers = LSP_SERVERS) {
@@ -50999,7 +51296,7 @@ var init_servers = __esm({
 // src/cli/lsp/manager.ts
 import { spawn as spawn11 } from "node:child_process";
 import { readFileSync as readFileSync20 } from "node:fs";
-import path52 from "node:path";
+import path53 from "node:path";
 function processTransport(child) {
   return {
     send: (data) => {
@@ -51016,7 +51313,7 @@ function processTransport(child) {
   };
 }
 function getSharedLspManager(cwd = process.cwd()) {
-  const key = path52.resolve(cwd);
+  const key = path53.resolve(cwd);
   const existing = sharedByRoot.get(key);
   if (existing) return existing;
   const manager = new LspManager({ cwd });
@@ -51493,11 +51790,11 @@ var init_store2 = __esm({
 
 // src/cli/semantic/index.ts
 import { promises as fs23, existsSync as existsSync29, readFileSync as readFileSync21 } from "node:fs";
-import path53 from "node:path";
+import path54 from "node:path";
 import { createHash as createHash15 } from "node:crypto";
 function getIndexPath(root) {
-  const hash3 = createHash15("sha1").update(path53.resolve(root)).digest("hex").slice(0, 16);
-  return process.env.ZELARI_SEMANTIC_FILE ?? path53.join(semanticStateDir(), `${hash3}.json`);
+  const hash3 = createHash15("sha1").update(path54.resolve(root)).digest("hex").slice(0, 16);
+  return process.env.ZELARI_SEMANTIC_FILE ?? path54.join(semanticStateDir(), `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
   const out = [];
@@ -51515,11 +51812,11 @@ async function collectSourceFiles(root, maxFiles = 1500) {
         if (entry.isDirectory() && IGNORE_DIRS.has(entry.name)) continue;
         if (entry.isDirectory()) continue;
       }
-      const full = path53.join(dir, entry.name);
+      const full = path54.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
         await walk2(full);
-      } else if (SOURCE_EXTENSIONS.has(path53.extname(entry.name).toLowerCase())) {
+      } else if (SOURCE_EXTENSIONS.has(path54.extname(entry.name).toLowerCase())) {
         out.push(full);
       }
     }
@@ -51568,7 +51865,7 @@ async function buildIndex(files, embed, options) {
 }
 async function saveIndex(root, data) {
   const file2 = getIndexPath(root);
-  await fs23.mkdir(path53.dirname(file2), { recursive: true });
+  await fs23.mkdir(path54.dirname(file2), { recursive: true });
   const tmp = `${file2}.tmp-${process.pid}`;
   await fs23.writeFile(tmp, JSON.stringify(data), "utf8");
   await fs23.rename(tmp, file2);
@@ -51661,7 +51958,7 @@ __export(openai_compatible_exports, {
   providerFromEnv: () => providerFromEnv,
   readChunkWithTimeout: () => readChunkWithTimeout,
   resetTextOnlyVisionMemory: () => resetTextOnlyVisionMemory,
-  resolveActiveProvider: () => resolveActiveProvider2,
+  resolveActiveProvider: () => resolveActiveProvider3,
   resolveBaseUrl: () => resolveBaseUrl,
   resolveStreamTimeouts: () => resolveStreamTimeouts
 });
@@ -51801,7 +52098,7 @@ function modelSupportsVision(model, probe) {
 function dataUriFromImage(img) {
   return `data:${img.mime};base64,${img.dataBase64}`;
 }
-function resolveActiveProvider2() {
+function resolveActiveProvider3() {
   return getProviderConfig().activeProviderId;
 }
 function parseCachedPromptTokens(usage) {
@@ -52273,7 +52570,7 @@ function extraFromStored(providerId) {
   };
 }
 async function providerFromEnv() {
-  const providerId = resolveActiveProvider2();
+  const providerId = resolveActiveProvider3();
   const apiKey = await resolveApiKeyWithMeta(providerId);
   if (!apiKey) return null;
   return {
@@ -52450,7 +52747,7 @@ var init_provider = __esm({
 });
 
 // src/cli/semantic/tools.ts
-import path54 from "node:path";
+import path55 from "node:path";
 function createSemanticTool(deps) {
   const buildEmbedFn = deps.buildEmbedFn ?? buildProviderEmbedFn;
   return {
@@ -52477,7 +52774,7 @@ function createSemanticTool(deps) {
       return typedOk({
         count: res.hits.length,
         results: res.hits.map((h) => ({
-          location: `${path54.relative(deps.root, h.file) || h.file}:${h.startLine}-${h.endLine}`,
+          location: `${path55.relative(deps.root, h.file) || h.file}:${h.startLine}-${h.endLine}`,
           score: Number(h.score.toFixed(3)),
           preview: h.text.length > 400 ? `${h.text.slice(0, 400)}\u2026` : h.text
         }))
@@ -52497,7 +52794,7 @@ var init_tools4 = __esm({
 
 // src/cli/browser/driver.ts
 import { createRequire as createRequire2 } from "node:module";
-import path55 from "node:path";
+import path56 from "node:path";
 import { pathToFileURL } from "node:url";
 function asPlaywright(mod) {
   if (!mod || typeof mod !== "object") return null;
@@ -52508,10 +52805,10 @@ function asPlaywright(mod) {
   return null;
 }
 async function loadPlaywright(cwd) {
-  const base2 = cwd && cwd.length > 0 ? path55.resolve(cwd) : void 0;
+  const base2 = cwd && cwd.length > 0 ? path56.resolve(cwd) : void 0;
   if (base2) {
     try {
-      const req = createRequire2(path55.join(base2, "package.json"));
+      const req = createRequire2(path56.join(base2, "package.json"));
       const resolved = req.resolve("playwright");
       const mod = await import(pathToFileURL(resolved).href);
       const pw = asPlaywright(mod);
@@ -52726,14 +53023,14 @@ var init_driver = __esm({
 });
 
 // src/cli/browser/tools.ts
-import path56 from "node:path";
+import path57 from "node:path";
 import os3 from "node:os";
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 async function loadImageBlock(filePath) {
   try {
-    const buf = await readFile7(filePath);
+    const buf = await readFile8(filePath);
     if (buf.byteLength > SCREENSHOT_MAX_BYTES) return void 0;
-    return { mime: "image/png", dataBase64: buf.toString("base64"), alt: path56.basename(filePath) };
+    return { mime: "image/png", dataBase64: buf.toString("base64"), alt: path57.basename(filePath) };
   } catch {
     return void 0;
   }
@@ -52755,7 +53052,7 @@ function createBrowserTool(deps = {}) {
     execute: async (args, ctx) => {
       const a = args;
       const dir = deps.screenshotDir ?? os3.tmpdir();
-      const screenshotPath = a.screenshot === false ? void 0 : path56.join(dir, `zelari-browser-${Date.now()}.png`);
+      const screenshotPath = a.screenshot === false ? void 0 : path57.join(dir, `zelari-browser-${Date.now()}.png`);
       const result = await runBrowserCheck(
         {
           url: a.url,
@@ -52833,8 +53130,8 @@ var init_tools5 = __esm({
 
 // src/cli/tools/screenshotTool.ts
 import { execFile as execFile6 } from "node:child_process";
-import { mkdir as mkdir3, readFile as readFile8, stat as stat7 } from "node:fs/promises";
-import path57 from "node:path";
+import { mkdir as mkdir4, readFile as readFile9, stat as stat7 } from "node:fs/promises";
+import path58 from "node:path";
 import { promisify as promisify5 } from "node:util";
 async function captureWindows(target) {
   const script = `Add-Type -AssemblyName System.Windows.Forms,System.Drawing;$b=[System.Windows.Forms.SystemInformation]::VirtualScreen;$bmp=New-Object System.Drawing.Bitmap $b.Width,$b.Height;$g=[System.Drawing.Graphics]::FromImage($bmp);$g.CopyFromScreen($b.Left,$b.Top,0,0,$bmp.Size);$g.Dispose(); $bmp.Save('${target.replace(/'/g, "''")}'); $bmp.Dispose();`;
@@ -52871,20 +53168,20 @@ function createScreenshotTool(deps = {}) {
     }),
     execute: async (args, ctx) => {
       const a = args;
-      const dir = deps.outDir ?? path57.join(ctx.cwd ?? process.cwd(), ".zelari", "screenshots");
+      const dir = deps.outDir ?? path58.join(ctx.cwd ?? process.cwd(), ".zelari", "screenshots");
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const target = path57.join(dir, `screenshot-${stamp}.png`);
+      const target = path58.join(dir, `screenshot-${stamp}.png`);
       const capture = deps.capture ?? (process.platform === "win32" ? captureWindows : captureUnixLike);
       try {
-        await mkdir3(dir, { recursive: true });
+        await mkdir4(dir, { recursive: true });
         await capture(target);
         const meta3 = await stat7(target);
         if (meta3.size === 0) return typedErr(`capture produced an empty file: ${target}`);
-        const buf = await readFile8(target);
+        const buf = await readFile9(target);
         const image = {
           mime: "image/png",
           dataBase64: buf.toString("base64"),
-          alt: path57.basename(target)
+          alt: path58.basename(target)
         };
         const attachable = meta3.size <= SCREENSHOT_MAX_BYTES2;
         return typedOk(
@@ -52958,21 +53255,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path101 = getSshSecretsPath();
-  if (!existsSync30(path101)) return {};
+  const path102 = getSshSecretsPath();
+  if (!existsSync30(path102)) return {};
   try {
-    return JSON.parse(readFileSync22(path101, "utf8"));
+    return JSON.parse(readFileSync22(path102, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path101 = getSshSecretsPath();
-  mkdirSync13(dirname4(path101), { recursive: true });
-  writeFileSync16(path101, `${JSON.stringify(data, null, 2)}
+  const path102 = getSshSecretsPath();
+  mkdirSync13(dirname4(path102), { recursive: true });
+  writeFileSync16(path102, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path101, 384);
+    chmodSync(path102, 384);
   } catch {
   }
 }
@@ -53001,10 +53298,10 @@ function deleteSshPassword(id3) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path101 = getSshTargetsPath();
-  if (!existsSync30(path101)) return [];
+  const path102 = getSshTargetsPath();
+  if (!existsSync30(path102)) return [];
   try {
-    const parsed = JSON.parse(readFileSync22(path101, "utf8"));
+    const parsed = JSON.parse(readFileSync22(path102, "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"
@@ -53019,11 +53316,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path101 = getSshTargetsPath();
-  mkdirSync13(dirname4(path101), { recursive: true });
+  const path102 = getSshTargetsPath();
+  mkdirSync13(dirname4(path102), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync16(
-    path101,
+    path102,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -53269,11 +53566,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path101 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path102 = 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}${path101}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path102}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -54659,12 +54956,12 @@ __export(folderTrust_exports, {
   untrustFolder: () => untrustFolder
 });
 import { existsSync as existsSync31, mkdirSync as mkdirSync14, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "node:fs";
-import path58 from "node:path";
+import path59 from "node:path";
 function trustStorePath() {
   return _overrideStorePath ?? trustConfigPath();
 }
 function normalize6(p3) {
-  const resolved = path58.resolve(p3);
+  const resolved = path59.resolve(p3);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function readStore3() {
@@ -54680,7 +54977,7 @@ function readStore3() {
 function writeStore3(store6) {
   const p3 = trustStorePath();
   try {
-    mkdirSync14(path58.dirname(p3), { recursive: true });
+    mkdirSync14(path59.dirname(p3), { recursive: true });
     writeFileSync17(p3, JSON.stringify(store6, null, 2), "utf8");
   } catch (err) {
     throw new Error(
@@ -54706,7 +55003,7 @@ function isFolderTrusted(folderPath) {
 }
 function trustFolder(folderPath) {
   const store6 = readStore3();
-  const normalized = path58.resolve(folderPath);
+  const normalized = path59.resolve(folderPath);
   if (!store6.folders.some((f) => normalize6(f.path) === normalize6(normalized))) {
     store6.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
     writeStore3(store6);
@@ -54832,7 +55129,7 @@ var init_lifecycleHooks = __esm({
 
 // src/cli/safety/astGate.ts
 import { promises as fs24 } from "node:fs";
-import path59 from "node:path";
+import path60 from "node:path";
 function astGateEnabled() {
   return process.env.ZELARI_AST_GATE !== "0";
 }
@@ -54867,9 +55164,9 @@ function wrapWithAstGate(original, opts) {
   const containedPathOf = (args) => {
     const raw = args["path"];
     if (typeof raw !== "string" || raw.length === 0) return null;
-    const absPath = path59.isAbsolute(raw) ? raw : path59.join(opts.root, raw);
-    const rel2 = path59.relative(opts.root, absPath);
-    if (rel2.startsWith("..") || path59.isAbsolute(rel2)) return null;
+    const absPath = path60.isAbsolute(raw) ? raw : path60.join(opts.root, raw);
+    const rel2 = path60.relative(opts.root, absPath);
+    if (rel2.startsWith("..") || path60.isAbsolute(rel2)) return null;
     return absPath;
   };
   return {
@@ -54894,7 +55191,7 @@ function wrapWithAstGate(original, opts) {
       if (!result.ok) return result;
       if (gateTarget !== null && !isAstSupported(gateTarget)) {
         process.stderr.write(
-          `[ast_gate] LOUD SKIP (unsupported-extension): ${original.name} ${gateTarget} \u2014 ${path59.extname(gateTarget) || "(no extension)"} is outside the AST surface; write KEPT, NOT syntax-gated.
+          `[ast_gate] LOUD SKIP (unsupported-extension): ${original.name} ${gateTarget} \u2014 ${path60.extname(gateTarget) || "(no extension)"} is outside the AST surface; write KEPT, NOT syntax-gated.
 `
         );
         return result;
@@ -54911,7 +55208,7 @@ function wrapWithAstGate(original, opts) {
           return result;
         }
         const post = await fs24.readFile(absPath, "utf8");
-        const syntaxError = firstSyntaxError(ts, path59.basename(absPath), post);
+        const syntaxError = firstSyntaxError(ts, path60.basename(absPath), post);
         if (!syntaxError) return result;
         const parseError = `${syntaxError.message} (line ${syntaxError.line}, col ${syntaxError.character})`;
         let revertedTo;
@@ -54922,7 +55219,7 @@ function wrapWithAstGate(original, opts) {
           await fs24.writeFile(absPath, preContent, "utf8");
           revertedTo = snapshotIdOf(preContent);
         }
-        const relLabel = path59.relative(opts.root, absPath) || path59.basename(absPath);
+        const relLabel = path60.relative(opts.root, absPath) || path60.basename(absPath);
         return typedErr(
           `[ast_gate_reverted] ${original.name}: ${absPath} written but the file no longer parses \u2014 write REVERTED (revertedTo=${revertedTo}). ${parseError}. Fix the syntax and re-apply (read_file first for a fresh snapshotId).`,
           {
@@ -55347,7 +55644,7 @@ var init_resourceClaims = __esm({
 // src/cli/toolResultCache.ts
 import { createHash as createHash16 } from "node:crypto";
 import { promises as fs25 } from "node:fs";
-import path60 from "node:path";
+import path61 from "node:path";
 function isToolCacheEnabled() {
   const raw = process.env.ZELARI_TOOL_CACHE;
   return raw !== "0" && raw !== "false" && raw !== "off";
@@ -55432,7 +55729,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 = path60.isAbsolute(rawPath) ? rawPath : path60.join(ctx.cwd, rawPath);
+  const abs = path61.isAbsolute(rawPath) ? rawPath : path61.join(ctx.cwd, rawPath);
   try {
     const st = await fs25.stat(abs);
     return hashKey({
@@ -55488,7 +55785,7 @@ __export(toolRegistry_exports, {
   wrapWithSandbox: () => wrapWithSandbox
 });
 import { existsSync as existsSync32 } from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 function createBuiltinToolRegistry(options = {}) {
   const root = options.root ?? process.cwd();
   const audit = options.audit ?? new AuditLogger();
@@ -56124,14 +56421,14 @@ function wrapWithDiagnostics(original, root, runner) {
 function claimedSourcePath(token, args, root) {
   const cleaned = token.replace(/^["']|["']$/g, "");
   if (!cleaned || cleaned.startsWith("-")) return null;
-  if (!DIAG_SOURCE_EXTENSIONS.has(path61.extname(cleaned).toLowerCase())) return null;
+  if (!DIAG_SOURCE_EXTENSIONS.has(path62.extname(cleaned).toLowerCase())) return null;
   const bases = [root];
   const cwd = args["cwd"];
   if (typeof cwd === "string" && cwd.length > 0) {
-    bases.unshift(path61.isAbsolute(cwd) ? cwd : path61.resolve(root, cwd));
+    bases.unshift(path62.isAbsolute(cwd) ? cwd : path62.resolve(root, cwd));
   }
   for (const base2 of bases) {
-    const candidate = path61.isAbsolute(cleaned) ? path61.normalize(cleaned) : path61.resolve(base2, cleaned);
+    const candidate = path62.isAbsolute(cleaned) ? path62.normalize(cleaned) : path62.resolve(base2, cleaned);
     try {
       const contained = resolveSandboxedPath(candidate, { root });
       if (existsSync32(contained)) return contained;
@@ -56450,7 +56747,7 @@ var init_toolRegistry = __esm({
 
 // src/cli/metrics.ts
 import { promises as fs26, existsSync as existsSync33, statSync as statSync4, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync15 } from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 async function readMetrics(file2) {
   let raw = "";
   try {
@@ -56500,7 +56797,7 @@ var init_metrics3 = __esm({
       writeQueue = Promise.resolve();
       constructor(file2) {
         this.file = file2 ?? metricsPath();
-        mkdirSync15(path62.dirname(this.file), { recursive: true });
+        mkdirSync15(path63.dirname(this.file), { recursive: true });
       }
       /** Metrics file path — doctor/summary readers use this. */
       get filePath() {
@@ -56837,10 +57134,10 @@ import { promisify as promisify6 } from "node:util";
 async function readHarnessVersion() {
   if (cachedHarnessVersion !== null) return cachedHarnessVersion;
   try {
-    const { readFile: readFile11 } = await import("node:fs/promises");
+    const { readFile: readFile12 } = await import("node:fs/promises");
     const { fileURLToPath: fileURLToPath4 } = await import("node:url");
     const pkgPath = fileURLToPath4(new URL("../../../package.json", import.meta.url));
-    const parsed = JSON.parse(await readFile11(pkgPath, "utf8"));
+    const parsed = JSON.parse(await readFile12(pkgPath, "utf8"));
     if (typeof parsed.version === "string" && parsed.version.length > 0) {
       return cachedHarnessVersion = parsed.version;
     }
@@ -57018,7 +57315,7 @@ var init_completionProofAttestation = __esm({
 // src/cli/kraken/completionProofPersist.ts
 import { open, rename as rename2, rm as rm2 } from "node:fs/promises";
 import { randomBytes as randomBytes5 } from "node:crypto";
-import path63 from "node:path";
+import path64 from "node:path";
 function isTruthyFlag2(v) {
   const n = v?.trim().toLowerCase();
   return n === "1" || n === "true" || n === "yes" || n === "on";
@@ -57060,8 +57357,8 @@ function isWindowsRenameBlock(err) {
   return code === "EPERM" || code === "ENOTEMPTY" || code === "EEXIST";
 }
 async function writeFileAtomic(target, data) {
-  const dir = path63.dirname(target);
-  const tmp = path63.join(dir, `.${path63.basename(target)}.${randomBytes5(6).toString("hex")}.tmp`);
+  const dir = path64.dirname(target);
+  const tmp = path64.join(dir, `.${path64.basename(target)}.${randomBytes5(6).toString("hex")}.tmp`);
   let fh = null;
   try {
     fh = await open(tmp, "w");
@@ -57106,8 +57403,8 @@ var init_completionProofPersist = __esm({
 });
 
 // src/cli/kraken/completionProof.ts
-import { mkdir as mkdir4 } from "node:fs/promises";
-import path64 from "node:path";
+import { mkdir as mkdir5 } from "node:fs/promises";
+import path65 from "node:path";
 function verdictOf(evaluation) {
   return evaluation.evaluation?.verdict ?? (evaluation.blocked ? "BLOCKED" : "PASS");
 }
@@ -57252,8 +57549,8 @@ async function writeCompletionProofDetailed(evaluation, options = {}) {
   const mode = options.persistenceMode ?? activeProofPersistenceMode();
   try {
     const baseDir = options.baseDir ?? process.cwd();
-    const dir = path64.join(baseDir, ".zelari");
-    await mkdir4(dir, { recursive: true });
+    const dir = path65.join(baseDir, ".zelari");
+    await mkdir5(dir, { recursive: true });
     const requested = options.attestation ?? {};
     const plan = requested.skipProbes || requested.verificationPlan !== void 0 ? void 0 : await defaultVerificationPlanSnapshot(baseDir);
     const wrapper = await buildAttestedWrapper(
@@ -57272,8 +57569,8 @@ async function writeCompletionProofDetailed(evaluation, options = {}) {
       baseDir
     );
     const rendered = renderCompletionProof(evaluation, options.meta ?? {}, wrapper.attestation);
-    const markdownPath = path64.join(dir, "completion-proof.md");
-    const jsonPath = path64.join(dir, "completion-proof.json");
+    const markdownPath = path65.join(dir, "completion-proof.md");
+    const jsonPath = path65.join(dir, "completion-proof.json");
     await writeFileAtomic(markdownPath, rendered.markdown);
     await writeFileAtomic(jsonPath, rendered.json);
     return { paths: { markdownPath, jsonPath }, mode, requiredBlockReason: null };
@@ -57383,12 +57680,12 @@ var init_askUserTimeout = __esm({
 // src/cli/state/fileStateStore.ts
 import { createHash as createHash18, randomUUID as randomUUID5 } from "node:crypto";
 import { promises as fs27 } from "node:fs";
-import * as path65 from "node:path";
+import * as path66 from "node:path";
 function shortId() {
   return randomUUID5().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs27.mkdir(path65.dirname(filePath), { recursive: true });
+  await fs27.mkdir(path66.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   await fs27.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
   await fs27.rename(tmp, filePath);
@@ -57449,11 +57746,11 @@ var init_fileStateStore = __esm({
       indexPath = "";
       async init(projectRoot) {
         this.root = projectRoot;
-        this.stateDir = path65.join(projectRoot, ".zelari", "state");
-        this.commitsDir = path65.join(this.stateDir, "commits");
-        this.artifactsDir = path65.join(this.stateDir, "artifacts");
-        this.headPath = path65.join(this.stateDir, "HEAD.json");
-        this.indexPath = path65.join(this.stateDir, "index.jsonl");
+        this.stateDir = path66.join(projectRoot, ".zelari", "state");
+        this.commitsDir = path66.join(this.stateDir, "commits");
+        this.artifactsDir = path66.join(this.stateDir, "artifacts");
+        this.headPath = path66.join(this.stateDir, "HEAD.json");
+        this.indexPath = path66.join(this.stateDir, "index.jsonl");
         await fs27.mkdir(this.commitsDir, { recursive: true });
         await fs27.mkdir(this.artifactsDir, { recursive: true });
       }
@@ -57466,13 +57763,13 @@ var init_fileStateStore = __esm({
         const discoveries = input.discoveries ?? [];
         const parent = await this.head();
         const id3 = shortId();
-        const artifactRel = path65.join("artifacts", id3);
-        const artifactAbs = path65.join(this.artifactsDir, id3);
+        const artifactRel = path66.join("artifacts", id3);
+        const artifactAbs = path66.join(this.artifactsDir, id3);
         await fs27.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs27.writeFile(path65.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
-        await writeJsonAtomic(path65.join(artifactAbs, "discoveries.json"), discoveries);
-        await writeJsonAtomic(path65.join(artifactAbs, "verification.json"), input.verification);
+        await fs27.writeFile(path66.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await writeJsonAtomic(path66.join(artifactAbs, "discoveries.json"), discoveries);
+        await writeJsonAtomic(path66.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
           id: id3,
           parentId: parent?.id ?? null,
@@ -57484,14 +57781,14 @@ var init_fileStateStore = __esm({
           workspaceCheckpointId: input.workspaceCheckpointId,
           verification: {
             ...input.verification,
-            reportPath: input.verification.reportPath ?? path65.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
+            reportPath: input.verification.reportPath ?? path66.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
           },
           changedPaths: input.changedPaths ?? [],
           stablePromptHash: input.stablePromptHash,
           discoveryCount: discoveries.length,
           artifactDir: artifactRel.replace(/\\/g, "/")
         };
-        await writeJsonAtomic(path65.join(this.commitsDir, `${id3}.json`), meta3);
+        await writeJsonAtomic(path66.join(this.commitsDir, `${id3}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id: id3, updatedAt: meta3.createdAt });
         await fs27.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
@@ -57502,7 +57799,7 @@ var init_fileStateStore = __esm({
         return this.get(head.id);
       }
       async get(id3) {
-        const stored = await readJsonFile(path65.join(this.commitsDir, `${id3}.json`));
+        const stored = await readJsonFile(path66.join(this.commitsDir, `${id3}.json`));
         return stored ? stripStored(stored) : null;
       }
       async list(limit = 20) {
@@ -57541,9 +57838,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(path65.join(this.commitsDir, `${meta3.id}.json`));
+        const stored = await readJsonFile(path66.join(this.commitsDir, `${meta3.id}.json`));
         if (!stored?.artifactDir) return [];
-        const discPath = path65.join(this.stateDir, stored.artifactDir, "discoveries.json");
+        const discPath = path66.join(this.stateDir, stored.artifactDir, "discoveries.json");
         return await readJsonFile(discPath) ?? [];
       }
       async materializeContext(id3, maxChars = DEFAULT_MATERIALIZE_CHARS) {
@@ -58146,10 +58443,10 @@ var init_mode = __esm({
 
 // src/cli/headless.ts
 import { readFileSync as readFileSync24 } from "node:fs";
-import path66 from "node:path";
+import path67 from "node:path";
 function resolveHeadlessCwd(opts) {
   const raw = typeof opts.cwd === "string" ? opts.cwd.trim() : "";
-  return path66.resolve(raw.length > 0 ? raw : process.cwd());
+  return path67.resolve(raw.length > 0 ? raw : process.cwd());
 }
 function defaultProfileForMode(mode) {
   switch (mode) {
@@ -58465,7 +58762,7 @@ __export(headlessSpine_exports, {
   seedHeadlessModelHistory: () => seedHeadlessModelHistory,
   sessionStartedEvent: () => sessionStartedEvent
 });
-import path67 from "node:path";
+import path68 from "node:path";
 function sessionStartedEvent(handle) {
   return {
     type: "session_started",
@@ -58482,7 +58779,7 @@ async function countVerificationEvidenceInLog(mirror, sessionId2) {
   try {
     await mirror.flush().catch(() => void 0);
     const report = await readSessionLogCached(
-      path67.join(mirror.sessionsDir, sessionId2, "events.jsonl"),
+      path68.join(mirror.sessionsDir, sessionId2, "events.jsonl"),
       mirror.replayCache
     );
     return report.events.filter((e) => e.kind === "verification.evidence").length;
@@ -59279,7 +59576,7 @@ var init_planDetect = __esm({
 // src/cli/memory/legacyImport.ts
 import { createHash as createHash19 } from "node:crypto";
 import { promises as fs28 } from "node:fs";
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 function sourceId(fact, line) {
   return `jsonl:${fact.id ?? createHash19("sha256").update(line).digest("hex")}`;
 }
@@ -59317,12 +59614,12 @@ async function markImportComplete(markerPath, found) {
 }
 async function importLegacyMemoryLog(backend, service) {
   const result = { found: 0, imported: 0, skipped: 0, corrupt: 0 };
-  const memoryDir = path68.dirname(backend.databasePath);
-  const markerPath = path68.join(memoryDir, LEGACY_IMPORT_MARKER);
+  const memoryDir = path69.dirname(backend.databasePath);
+  const markerPath = path69.join(memoryDir, LEGACY_IMPORT_MARKER);
   if (await isImportComplete(markerPath)) return result;
   let raw;
   try {
-    raw = await fs28.readFile(path68.join(memoryDir, "log.jsonl"), "utf8");
+    raw = await fs28.readFile(path69.join(memoryDir, "log.jsonl"), "utf8");
   } catch {
     return result;
   }
@@ -59514,7 +59811,7 @@ var init_sqliteCodec = __esm({
 // src/cli/memory/sqliteRpc.ts
 import { existsSync as existsSync36 } from "node:fs";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
-import * as path69 from "node:path";
+import * as path70 from "node:path";
 import { Worker } from "node:worker_threads";
 function isBusy(error51) {
   const candidate = error51;
@@ -59523,10 +59820,10 @@ function isBusy(error51) {
   );
 }
 function resolveWorkerUrl() {
-  const here = path69.dirname(fileURLToPath2(import.meta.url));
-  const direct = path69.join(here, "sqliteWorker.mjs");
+  const here = path70.dirname(fileURLToPath2(import.meta.url));
+  const direct = path70.join(here, "sqliteWorker.mjs");
   if (existsSync36(direct)) return pathToFileURL2(direct);
-  return pathToFileURL2(path69.join(here, "memory", "sqliteWorker.mjs"));
+  return pathToFileURL2(path70.join(here, "memory", "sqliteWorker.mjs"));
 }
 var SqliteWorkerRpc;
 var init_sqliteRpc = __esm({
@@ -59815,7 +60112,7 @@ WHERE NOT EXISTS (SELECT 1 FROM memory_fts f WHERE f.node_id = n.id);
 // src/cli/memory/sqliteBackend.ts
 import { createHash as createHash20, randomUUID as randomUUID6 } from "node:crypto";
 import { promises as fs29 } from "node:fs";
-import * as path70 from "node:path";
+import * as path71 from "node:path";
 function boundedLimit(value, fallback = 50) {
   return Math.max(1, Math.min(Math.floor(value ?? fallback), 1e5));
 }
@@ -59878,16 +60175,16 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         try {
           resolved = await fs29.realpath(projectRoot);
         } catch {
-          resolved = path70.resolve(projectRoot);
+          resolved = path71.resolve(projectRoot);
         }
         if (this.initialized && resolved === this.projectRoot) return;
         if (this.initialized) await this.close();
         const filename = this.options.filename ?? "memory.db";
-        if (path70.basename(filename) !== filename || filename === "." || filename === "..") {
+        if (path71.basename(filename) !== filename || filename === "." || filename === "..") {
           throw new Error("SQLite memory filename must not contain a path.");
         }
-        const zelariDirectory = path70.join(resolved, ".zelari");
-        const directory = path70.join(zelariDirectory, "memory");
+        const zelariDirectory = path71.join(resolved, ".zelari");
+        const directory = path71.join(zelariDirectory, "memory");
         for (const candidate of [zelariDirectory, directory]) {
           let stat8;
           try {
@@ -59906,12 +60203,12 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           }
         }
         const canonicalDirectory = await fs29.realpath(directory);
-        const relativeDirectory = path70.relative(resolved, canonicalDirectory);
-        if (relativeDirectory.startsWith("..") || path70.isAbsolute(relativeDirectory)) {
+        const relativeDirectory = path71.relative(resolved, canonicalDirectory);
+        if (relativeDirectory.startsWith("..") || path71.isAbsolute(relativeDirectory)) {
           throw new Error("SQLite memory directory resolves outside the active project.");
         }
         this.projectRoot = resolved;
-        this.databasePath = path70.join(canonicalDirectory, filename);
+        this.databasePath = path71.join(canonicalDirectory, filename);
         const opened = await this.rpc.open({
           dbPath: this.databasePath,
           schemaSql: SQLITE_MEMORY_BASE_SCHEMA,
@@ -60454,7 +60751,7 @@ __export(serviceFactory_exports, {
 });
 import { createHash as createHash21 } from "node:crypto";
 import { promises as fs30 } from "node:fs";
-import * as path71 from "node:path";
+import * as path72 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;
@@ -60475,7 +60772,7 @@ async function canonicalProjectId(projectRoot) {
   try {
     canonical = await fs30.realpath(projectRoot);
   } catch {
-    canonical = path71.resolve(projectRoot);
+    canonical = path72.resolve(projectRoot);
   }
   canonical = canonical.replace(/\\/g, "/").replace(/\/$/, "");
   if (process.platform === "win32") canonical = canonical.toLocaleLowerCase("en-US");
@@ -61177,8 +61474,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path101 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path101);
+  const path102 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path102);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -61359,7 +61656,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path101 = join31(ctx.rootDir, "milestones", `${id3}.md`);
+  const path102 = join31(ctx.rootDir, "milestones", `${id3}.md`);
   const meta3 = {
     kind: "milestone",
     id: id3,
@@ -61376,7 +61673,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path101, meta3, body);
+  ctx.storage.write(path102, meta3, body);
   return { id: id3, created: true };
 }
 function readPlanSummary(ctx) {
@@ -61580,7 +61877,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id3 = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path101 = workspaceArtifact(ctx.rootDir, "decisions", id3);
+        const path102 = workspaceArtifact(ctx.rootDir, "decisions", id3);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -61606,7 +61903,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path101, meta3, body);
+        ctx.storage.write(path102, meta3, body);
         return `ADR ${id3} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -61688,14 +61985,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path101 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path102 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path101, meta3, content);
+        ctx.storage.write(path102, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -62320,10 +62617,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join32(projectRoot, ".zelari", "mcp.json");
 }
-function readFile9(path101) {
-  if (!existsSync42(path101)) return {};
+function readFile10(path102) {
+  if (!existsSync42(path102)) return {};
   try {
-    const parsed = JSON.parse(readFileSync30(path101, "utf8"));
+    const parsed = JSON.parse(readFileSync30(path102, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       const hasCommand = !!cfg && typeof cfg.command === "string" && !!cfg.command.trim();
@@ -62345,17 +62642,17 @@ function readFile9(path101) {
     return {};
   }
 }
-function writeFile3(path101, servers) {
-  mkdirSync17(dirname9(path101), { recursive: true });
+function writeFile4(path102, servers) {
+  mkdirSync17(dirname9(path102), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync19(path101, `${JSON.stringify(body, null, 2)}
+  writeFileSync19(path102, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
   const userPath = getUserMcpPath();
-  const userServers = readFile9(userPath);
+  const userServers = readFile10(userPath);
   const projectPath = projectRoot && projectRoot.trim() ? getProjectMcpPath(projectRoot.trim()) : null;
-  const projectServers = projectPath ? readFile9(projectPath) : {};
+  const projectServers = projectPath ? readFile10(projectPath) : {};
   const servers = [];
   for (const [name, cfg] of Object.entries(userServers)) {
     servers.push({ name, ...cfg, scope: "user", path: userPath });
@@ -62386,9 +62683,9 @@ function upsertMcpServer(opts) {
       error: "either command (stdio) or url (http) is required"
     };
   }
-  let path101;
+  let path102;
   if (opts.scope === "user") {
-    path101 = getUserMcpPath();
+    path102 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -62397,9 +62694,9 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path101 = getProjectMcpPath(root);
+    path102 = getProjectMcpPath(root);
   }
-  const current = readFile9(path101);
+  const current = readFile10(path102);
   current[name] = {
     command: hasCommand ? opts.config.command.trim() : void 0,
     args: opts.config.args,
@@ -62410,21 +62707,21 @@ function upsertMcpServer(opts) {
     serial: opts.config.serial,
     enabled: opts.config.enabled !== false
   };
-  writeFile3(path101, current);
-  return { ok: true, path: path101 };
+  writeFile4(path102, current);
+  return { ok: true, path: path102 };
 }
 function removeMcpServer(opts) {
-  const path101 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path101) {
+  const path102 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path102) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile9(path101);
+  const current = readFile10(path102);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path101}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path102}` };
   }
   delete current[opts.name];
-  writeFile3(path101, current);
-  return { ok: true, path: path101 };
+  writeFile4(path102, current);
+  return { ok: true, path: path102 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -62893,12 +63190,12 @@ __export(agentsMd_exports, {
 import { existsSync as existsSync44, readFileSync as readFileSync32, writeFileSync as writeFileSync20 } from "node:fs";
 import { createHash as createHash22 } from "node:crypto";
 import { join as join34 } from "node:path";
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 async function readPackageJson3(projectRoot) {
-  const path101 = join34(projectRoot, "package.json");
-  if (!existsSync44(path101)) return null;
+  const path102 = join34(projectRoot, "package.json");
+  if (!existsSync44(path102)) return null;
   try {
-    return JSON.parse(await readFile10(path101, "utf8"));
+    return JSON.parse(await readFile11(path102, "utf8"));
   } catch {
     return null;
   }
@@ -62980,9 +63277,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path101 = join34(ctx.rootDir, "risks.md");
-  if (!existsSync44(path101)) return "_No open questions._";
-  const content = readFileSync32(path101, "utf8");
+  const path102 = join34(ctx.rootDir, "risks.md");
+  if (!existsSync44(path102)) return "_No open questions._";
+  const content = readFileSync32(path102, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -63256,9 +63553,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path101) {
+function readFileSyncSafe(path102) {
   try {
-    return readFileSync33(path101, "utf8");
+    return readFileSync33(path102, "utf8");
   } catch {
     return null;
   }
@@ -63506,7 +63803,7 @@ __export(evidenceFromSpine_exports, {
   evidenceRefsFromEventLines: () => evidenceRefsFromEventLines
 });
 import { existsSync as existsSync47, readFileSync as readFileSync35 } from "node:fs";
-import path72 from "node:path";
+import path73 from "node:path";
 function asRecord2(v) {
   return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
 }
@@ -63544,7 +63841,7 @@ function evidenceRefsFromEventLines(lines) {
 }
 function collectSessionEvidenceRefs(sessionId2) {
   try {
-    const file2 = path72.join(sessionsDir(), sessionId2, "events.jsonl");
+    const file2 = path73.join(sessionsDir(), sessionId2, "events.jsonl");
     if (!existsSync47(file2)) return [];
     return evidenceRefsFromEventLines(readFileSync35(file2, "utf8").split("\n"));
   } catch {
@@ -63794,8 +64091,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path101 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path101, completion };
+      const path102 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path102, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -63840,7 +64137,7 @@ import {
   writeFileSync as writeFileSync22,
   mkdirSync as mkdirSync18
 } from "node:fs";
-import path73 from "node:path";
+import path74 from "node:path";
 var FeedbackStore;
 var init_councilFeedback = __esm({
   "src/cli/councilFeedback.ts"() {
@@ -63957,7 +64254,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync18(path73.dirname(this.file), { recursive: true });
+        mkdirSync18(path74.dirname(this.file), { recursive: true });
         writeFileSync22(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -64032,12 +64329,12 @@ __export(ledger_exports, {
   readLedger: () => readLedger
 });
 import { appendFileSync as appendFileSync4, existsSync as existsSync50, mkdirSync as mkdirSync19, readFileSync as readFileSync38 } from "node:fs";
-import path74 from "node:path";
+import path75 from "node:path";
 function evolutionMode(env = process.env) {
   return env[EVOLUTION_ENV] === "shadow" ? "shadow" : "0";
 }
 function ledgerPath(cwd) {
-  return path74.join(cwd, LEDGER_REL);
+  return path75.join(cwd, LEDGER_REL);
 }
 function appendLedgerEntry(cwd, entry) {
   if (evolutionMode() === "0") {
@@ -64045,7 +64342,7 @@ function appendLedgerEntry(cwd, entry) {
   }
   try {
     const file2 = ledgerPath(cwd);
-    mkdirSync19(path74.dirname(file2), { recursive: true });
+    mkdirSync19(path75.dirname(file2), { recursive: true });
     appendFileSync4(file2, `${JSON.stringify(entry)}
 `, "utf8");
     return { written: true, path: file2 };
@@ -64146,7 +64443,7 @@ var init_ledger = __esm({
   "src/cli/evolution/ledger.ts"() {
     "use strict";
     EVOLUTION_ENV = "ZELARI_EVOLUTION";
-    LEDGER_REL = path74.join(".zelari", "evolution", "ledger.jsonl");
+    LEDGER_REL = path75.join(".zelari", "evolution", "ledger.jsonl");
     TIER_WEIGHTS = {
       build: 1,
       "tool-output": 1,
@@ -64288,7 +64585,7 @@ __export(fileBackend_exports, {
 });
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { promises as fs32 } from "node:fs";
-import * as path75 from "node:path";
+import * as path76 from "node:path";
 function tokenize2(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -64341,8 +64638,8 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path75.join(projectRoot, ".zelari", "memory");
-        this.logPath = path75.join(this.memoryDir, "log.jsonl");
+        this.memoryDir = path76.join(projectRoot, ".zelari", "memory");
+        this.logPath = path76.join(this.memoryDir, "log.jsonl");
         await fs32.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata2 = {}, graph) {
@@ -64415,12 +64712,12 @@ var init_fileBackend = __esm({
 
 // src/cli/traceStore.ts
 import { promises as fs33 } from "node:fs";
-import * as path76 from "node:path";
+import * as path77 from "node:path";
 function traceDir(projectRoot) {
-  return path76.join(projectRoot, ".zelari", "trace");
+  return path77.join(projectRoot, ".zelari", "trace");
 }
 function tracePath(projectRoot, missionId) {
-  return path76.join(traceDir(projectRoot), `${missionId}.json`);
+  return path77.join(traceDir(projectRoot), `${missionId}.json`);
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
@@ -64462,7 +64759,7 @@ __export(zelariMission_exports, {
 });
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { promises as fs34 } from "node:fs";
-import * as path77 from "node:path";
+import * as path78 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;
@@ -64505,10 +64802,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state3) {
-  const dir = path77.join(projectRoot, ".zelari");
+  const dir = path78.join(projectRoot, ".zelari");
   await fs34.mkdir(dir, { recursive: true });
   await fs34.writeFile(
-    path77.join(dir, "mission-state.json"),
+    path78.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
   );
@@ -64522,7 +64819,7 @@ async function writeMissionState(projectRoot, state3) {
 async function loadMissionState(projectRoot) {
   try {
     const raw = await fs34.readFile(
-      path77.join(projectRoot, ".zelari", "mission-state.json"),
+      path78.join(projectRoot, ".zelari", "mission-state.json"),
       "utf8"
     );
     const parsed = JSON.parse(raw);
@@ -65281,7 +65578,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path101 = safeSocketPath(socketPath);
+  const path102 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -65381,10 +65678,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve9, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path101, () => {
+    server.listen(path102, () => {
       server.removeListener("error", onError);
       resolve9({
-        socketPath: path101,
+        socketPath: path102,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -65395,7 +65692,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path101, () => res());
+              unlink(path102, () => res());
             } else {
               res();
             }
@@ -65408,11 +65705,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path101 = safeSocketPath(socketPath);
+  const path102 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const connectTimeoutMs = opts?.connectTimeoutMs ?? PERMISSION_BROKER_DEFAULT_CONNECT_TIMEOUT_MS;
   return new Promise((resolve9, reject) => {
-    const socket = connect(path101);
+    const socket = connect(path102);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -65427,7 +65724,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path101}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path102}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -66616,7 +66913,7 @@ var init_prereqChecks = __esm({
 
 // src/cli/plugins/prefs.ts
 import { existsSync as existsSync53, readFileSync as readFileSync40, writeFileSync as writeFileSync23, mkdirSync as mkdirSync20 } from "node:fs";
-import path83 from "node:path";
+import path84 from "node:path";
 function getPluginPrefsPath() {
   return pluginsPrefsPath();
 }
@@ -66639,7 +66936,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync20(path83.dirname(file2), { recursive: true });
+  mkdirSync20(path84.dirname(file2), { recursive: true });
   writeFileSync23(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -66677,7 +66974,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync54 } from "node:fs";
-import path84 from "node:path";
+import path85 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -66695,7 +66992,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync54;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path84.win32 : path84.posix;
+  const pathMod = platform === "win32" ? path85.win32 : path85.posix;
   const sep4 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep4).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -67800,7 +68097,7 @@ var init_policy = __esm({
 
 // src/cli/orchestration/facts.ts
 import { promises as fs44 } from "node:fs";
-import path88 from "node:path";
+import path89 from "node:path";
 async function collectRepoFileCount(root = process.cwd()) {
   try {
     await fs44.readdir(root);
@@ -67820,7 +68117,7 @@ async function collectRepoFileCount(root = process.cwd()) {
       }
       for (const e of entries) {
         if (e.isDirectory()) {
-          if (!SKIP_DIRS.has(e.name)) queue.push(path88.join(dir, e.name));
+          if (!SKIP_DIRS.has(e.name)) queue.push(path89.join(dir, e.name));
         } else if (e.isFile()) {
           count++;
           if (count > MAX_WALK_FILES) return count;
@@ -67918,7 +68215,7 @@ var init_streamScrub = __esm({
 });
 
 // src/cli/harnessState.ts
-import path89 from "node:path";
+import path90 from "node:path";
 function asString4(v) {
   return typeof v === "string" ? v : "";
 }
@@ -68093,7 +68390,7 @@ function contractFor(t) {
   };
 }
 async function readHarnessState(sessionDir, cache4) {
-  const report = await readSessionLogCached(path89.join(sessionDir, "events.jsonl"), cache4);
+  const report = await readSessionLogCached(path90.join(sessionDir, "events.jsonl"), cache4);
   return deriveHarnessState(report.events);
 }
 var init_harnessState = __esm({
@@ -68104,12 +68401,12 @@ var init_harnessState = __esm({
 });
 
 // src/cli/headless/harnessStateEmit.ts
-import path90 from "node:path";
+import path91 from "node:path";
 async function emitHarnessStateEvent(opts) {
   if (opts.output !== "json") return;
   try {
     const sessionsDir2 = resolveSessionsDir({ workspaceRoot: opts.workspaceRoot });
-    const state3 = await readHarnessState(path90.join(sessionsDir2, opts.spine.sessionId));
+    const state3 = await readHarnessState(path91.join(sessionsDir2, opts.spine.sessionId));
     opts.emitEvent({ type: "harness_state", ...state3 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -68666,13 +68963,13 @@ var init_verifierLifecycle = __esm({
 
 // src/cli/extensions/sandboxedFs.ts
 import { promises as fsp } from "node:fs";
-import path91 from "node:path";
+import path92 from "node:path";
 function errText(prefix, p3, err) {
   const msg = err instanceof Error ? err.message : String(err);
   return `[extension-fs] ${prefix} "${p3}": ${msg}`;
 }
 function bindSandboxedFs(root) {
-  const resolvedRoot = path91.resolve(root);
+  const resolvedRoot = path92.resolve(root);
   return {
     root: resolvedRoot,
     async readFile(relativePath) {
@@ -68688,7 +68985,7 @@ function bindSandboxedFs(root) {
       try {
         const target = resolveSandboxedPath(relativePath, { root: resolvedRoot });
         verifyContainment(target, { root: resolvedRoot });
-        await fsp.mkdir(path91.dirname(target), { recursive: true });
+        await fsp.mkdir(path92.dirname(target), { recursive: true });
         await fsp.writeFile(target, data, "utf8");
         return typedOk({ path: target });
       } catch (err) {
@@ -68873,7 +69170,7 @@ var init_loader = __esm({
 
 // src/cli/headless/runOneTurn.ts
 import { promises as fs45 } from "node:fs";
-import path92 from "node:path";
+import path93 from "node:path";
 function planModeFromOpts(opts) {
   return (opts.phase ?? "build") === "plan";
 }
@@ -69443,7 +69740,7 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs45.mkdir(path92.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs45.mkdir(path93.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs45.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
@@ -70492,9 +70789,9 @@ __export(triggerLock_exports, {
   releaseLock: () => releaseLock
 });
 import { promises as fs46 } from "node:fs";
-import * as path93 from "node:path";
+import * as path94 from "node:path";
 function lockPath(projectRoot) {
-  return path93.join(projectRoot, ".zelari", "trigger.lock");
+  return path94.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -70507,7 +70804,7 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path93.dirname(lp);
+  const dir = path94.dirname(lp);
   await fs46.mkdir(dir, { recursive: true });
   try {
     const raw = await fs46.readFile(lp, "utf8");
@@ -70539,7 +70836,7 @@ var init_triggerLock = __esm({
 
 // src/cli/runHeadless.ts
 import { promises as fs47 } from "node:fs";
-import path94 from "node:path";
+import path95 from "node:path";
 import { randomUUID as randomUUID10 } from "node:crypto";
 async function runHeadless(opts) {
   resetTaskSpawnCount();
@@ -70813,7 +71110,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   try {
     let preflightGraph;
     if (opts.runPlan && opts.runPlan.trim() !== "") {
-      const planPath = path94.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      const planPath = path95.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
@@ -70856,8 +71153,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
       const planId = randomUUID10();
-      const planDir = path94.join(cwd, ".zelari", "radio");
-      const planPath = path94.join(planDir, `plan-${planId}.json`);
+      const planDir = path95.join(cwd, ".zelari", "radio");
+      const planPath = path95.join(planDir, `plan-${planId}.json`);
       await fs47.mkdir(planDir, { recursive: true });
       await fs47.writeFile(
         planPath,
@@ -71248,7 +71545,7 @@ async function runHeadlessCouncilBody(opts, provider, model, providerStream, ext
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs47.mkdir(path94.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs47.mkdir(path95.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs47.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
@@ -71720,7 +72017,7 @@ ${ragContext}` : slicePrompt;
         if (json3) {
           if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
           else {
-            await fs47.mkdir(path94.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs47.mkdir(path95.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
             await fs47.writeFile(opts.exportSessionPath, json3, "utf8");
           }
         }
@@ -72345,7 +72642,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path101 = skillFilePath(dir, name);
+  const path102 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -72354,13 +72651,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path101);
+  const parsed = parseSkillMd(content, path102);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync23(dirname13(path101), { recursive: true });
-  writeFileSync25(path101, content, "utf8");
-  return { ok: true, path: path101 };
+  mkdirSync23(dirname13(path102), { recursive: true });
+  writeFileSync25(path102, content, "utf8");
+  return { ok: true, path: path102 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -72378,8 +72675,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join46(dir, name);
-  const path101 = skillFilePath(dir, name);
-  if (!existsSync59(path101) && !existsSync59(skillDir)) {
+  const path102 = skillFilePath(dir, name);
+  if (!existsSync59(path102) && !existsSync59(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -72390,7 +72687,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path101 };
+  return { ok: true, path: path102 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -72511,7 +72808,7 @@ var init_jsonApi = __esm({
 });
 
 // src/cli/memory/mcpAdapter.ts
-import * as path95 from "node:path";
+import * as path96 from "node:path";
 var id2, projectId, source, SearchSchema, AddSchema, LinkSchema, RetractSchema, MEMORY_MCP_TOOLS, MemoryMcpAdapter;
 var init_mcpAdapter = __esm({
   "src/cli/memory/mcpAdapter.ts"() {
@@ -72681,8 +72978,8 @@ var init_mcpAdapter = __esm({
         this.takeWrite();
         const externalFile = args.source?.file;
         if (externalFile) {
-          const normalized = path95.normalize(externalFile);
-          if (path95.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path95.sep}`)) {
+          const normalized = path96.normalize(externalFile);
+          if (path96.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path96.sep}`)) {
             throw new Error("source.file must be project-relative and cannot escape the project");
           }
         }
@@ -73209,12 +73506,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path101 = getCompanionConfigPath();
-  if (!existsSync60(path101)) {
+  const path102 = getCompanionConfigPath();
+  if (!existsSync60(path102)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync45(path101, "utf8"));
+    const raw = JSON.parse(readFileSync45(path102, "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) => ({
@@ -73252,16 +73549,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path101 = getCompanionTokenPath();
-  if (existsSync60(path101)) {
-    const t = readFileSync45(path101, "utf8").trim();
+  const path102 = getCompanionTokenPath();
+  if (existsSync60(path102)) {
+    const t = readFileSync45(path102, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes7(24).toString("base64url");
-  writeFileSync26(path101, token + "\n", "utf8");
+  writeFileSync26(path102, token + "\n", "utf8");
   try {
     const fs49 = __require("node:fs");
-    fs49.chmodSync?.(path101, 384);
+    fs49.chmodSync?.(path102, 384);
   } catch {
   }
   return { token, created: true };
@@ -73286,17 +73583,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path101 = raw.trim();
-    if (!path101) continue;
-    let id3 = slugFromPath(path101);
+    const path102 = raw.trim();
+    if (!path102) continue;
+    let id3 = slugFromPath(path102);
     let n = 2;
-    while (byId.has(id3) && byId.get(id3).path !== path101) {
-      id3 = `${slugFromPath(path101)}-${n++}`;
+    while (byId.has(id3) && byId.get(id3).path !== path102) {
+      id3 = `${slugFromPath(path102)}-${n++}`;
     }
     byId.set(id3, {
       id: id3,
-      name: slugFromPath(path101),
-      path: path101
+      name: slugFromPath(path102),
+      path: path102
     });
   }
   return [...byId.values()];
@@ -73539,7 +73836,7 @@ var init_askUserBridge = __esm({
 
 // src/cli/serve/spineLockSweep.ts
 import { promises as fs48 } from "node:fs";
-import path96 from "node:path";
+import path97 from "node:path";
 async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
   const dir = sessionsDir2 ?? resolveSessionsDir();
   const onSwept = options.onSwept ?? ((sessionId2, reason) => {
@@ -73557,7 +73854,7 @@ async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
     return result;
   }
   for (const sessionId2 of entries) {
-    const lockPath2 = path96.join(dir, sessionId2, "writer.lock");
+    const lockPath2 = path97.join(dir, sessionId2, "writer.lock");
     try {
       const raw = await fs48.readFile(lockPath2, "utf-8");
       let lockInfo = {};
@@ -74555,9 +74852,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path101 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path102 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path101 === "/health" || path101 === "/v1/health")) {
+      if (req.method === "GET" && (path102 === "/health" || path102 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -74569,18 +74866,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path101.startsWith("/v1")) {
+      if (path102.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path101 === "/v1/config") {
+      if (req.method === "GET" && path102 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path101 === "/v1/projects") {
+      if (req.method === "GET" && path102 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -74591,7 +74888,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path101 === "/v1/runs") {
+      if (req.method === "GET" && path102 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -74609,7 +74906,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path101 === "/v1/runs") {
+      if (req.method === "POST" && path102 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -74657,7 +74954,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path101);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path102);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -74722,7 +75019,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path101);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path102);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -74733,7 +75030,7 @@ async function runCompanionServe(opts = {}) {
         sendJson2(res, 200, { ok: true, cancelled: runId });
         return;
       }
-      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path101);
+      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path102);
       if (req.method === "POST" && steerMatch) {
         const runId = steerMatch[1];
         const raw = await readBody(req);
@@ -74902,11 +75199,11 @@ import { execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync62, readFileSync as readFileSync46, readlinkSync, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path97 from "node:path";
+import path98 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path97.join(dir, "package.json");
+    const candidate = path98.join(dir, "package.json");
     if (existsSync62(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync46(candidate, "utf8"));
@@ -74914,11 +75211,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path97.dirname(dir);
+    const parent = path98.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path97.resolve(__dirname3, "..", "..", "..");
+  return path98.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -74932,7 +75229,7 @@ function tryExec(cmd) {
 }
 function readPackageJson4() {
   try {
-    const pkgPath = path97.join(packageRoot, "package.json");
+    const pkgPath = path98.join(packageRoot, "package.json");
     return JSON.parse(readFileSync46(pkgPath, "utf8"));
   } catch {
     return null;
@@ -74944,7 +75241,7 @@ function getGlobalPrefix() {
   return (process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || "").trim();
 }
 function isSourceCheckout() {
-  return existsSync62(path97.join(packageRoot, "src", "cli", "main.ts")) && existsSync62(path97.join(packageRoot, "apps", "desktop", "package.json"));
+  return existsSync62(path98.join(packageRoot, "src", "cli", "main.ts")) && existsSync62(path98.join(packageRoot, "apps", "desktop", "package.json"));
 }
 function checkShim(pkgName) {
   const prefix = getGlobalPrefix();
@@ -74953,9 +75250,9 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path97.join(prefix, shimName);
+  const shimPath = path98.join(prefix, shimName);
   if (!existsSync62(shimPath)) {
-    const localBin = path97.join(packageRoot, "bin", "zelari-code.js");
+    const localBin = path98.join(packageRoot, "bin", "zelari-code.js");
     if (isSourceCheckout() && existsSync62(localBin)) {
       return WARN(
         `global shim not found at ${shimPath}
@@ -74989,8 +75286,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path97.resolve(path97.dirname(shimPath), target);
-    const expected = path97.join(
+    const resolved = path98.resolve(path98.dirname(shimPath), target);
+    const expected = path98.join(
       prefix,
       "node_modules",
       pkgName,
@@ -75032,7 +75329,7 @@ function checkNode(pkg) {
   return OK(`node ${raw} (engines.node ${enginesNode ?? ">= 20.0.0"})`);
 }
 function checkBundle() {
-  const bundle = path97.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path98.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync62(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -75053,7 +75350,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path97.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path98.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -75330,7 +75627,7 @@ var init_doctor = __esm({
     init_metrics3();
     init_contextGrowthSummary();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path97.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path98.dirname(fileURLToPath3(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -75439,7 +75736,7 @@ __export(userSettings_exports, {
   settingsOverrides: () => settingsOverrides
 });
 import { existsSync as existsSync63, readFileSync as readFileSync47 } from "node:fs";
-import path98 from "node:path";
+import path99 from "node:path";
 function parseBool(raw) {
   const v = raw.trim().toLowerCase();
   if (["1", "true", "yes", "on"].includes(v)) return true;
@@ -75506,8 +75803,8 @@ function envValueFor(key, env) {
 function resolveUserSettings(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const env = opts.env ?? process.env;
-  const userPath = path98.join(zelariHome(), SETTINGS_FILE_NAME);
-  const projectPath = path98.join(cwd, ".zelari", SETTINGS_FILE_NAME);
+  const userPath = path99.join(zelariHome(), SETTINGS_FILE_NAME);
+  const projectPath = path99.join(cwd, ".zelari", SETTINGS_FILE_NAME);
   const warnings = [];
   const userLayer = loadFileLayer(userPath, "user", warnings);
   const projectLayer = loadFileLayer(projectPath, "project", warnings);
@@ -75721,7 +76018,7 @@ __export(inspectSession_exports, {
   renderInspectReport: () => renderInspectReport,
   runInspectSession: () => runInspectSession
 });
-import path99 from "node:path";
+import path100 from "node:path";
 import { existsSync as existsSync64 } from "node:fs";
 function formatLimit(limit) {
   return `${Math.round(limit / 1e3)}k`;
@@ -75755,8 +76052,8 @@ function renderInspectReport(state3) {
 }
 async function runInspectSession(opts) {
   const sessionsDir2 = resolveSessionsDir({ workspaceRoot: opts.cwd ?? process.cwd() });
-  const sessionDir = path99.join(sessionsDir2, opts.sessionId);
-  const eventsPath = path99.join(sessionDir, "events.jsonl");
+  const sessionDir = path100.join(sessionsDir2, opts.sessionId);
+  const eventsPath = path100.join(sessionDir, "events.jsonl");
   if (!existsSync64(sessionDir)) {
     console.error(`zelari-code inspect: no session directory at ${sessionDir}`);
     return 1;
@@ -75790,14 +76087,14 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path100 from "node:path";
+import path101 from "node:path";
 import { existsSync as existsSync65, readFileSync as readFileSync48, readdirSync as readdirSync13 } from "node:fs";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
   const snap = listSkillsSnapshot(cwd);
   const mcp = listMcpServers(cwd);
-  const userMcpPath = path100.join(zelariHome(), "mcp.json");
-  const projectMcpPath = path100.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path101.join(zelariHome(), "mcp.json");
+  const projectMcpPath = path101.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -75825,9 +76122,9 @@ async function collectInspectReport(cwd = process.cwd()) {
     configSources: [
       { path: userMcpPath, exists: existsSync65(userMcpPath) },
       { path: projectMcpPath, exists: existsSync65(projectMcpPath) },
-      { path: path100.join(zelariHome(), "provider.json"), exists: existsSync65(path100.join(zelariHome(), "provider.json")) },
-      { path: path100.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync65(path100.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path100.join(cwd, "AGENTS.md"), exists: existsSync65(path100.join(cwd, "AGENTS.md")) }
+      { path: path101.join(zelariHome(), "provider.json"), exists: existsSync65(path101.join(zelariHome(), "provider.json")) },
+      { path: path101.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync65(path101.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path101.join(cwd, "AGENTS.md"), exists: existsSync65(path101.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -75867,8 +76164,8 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path100.join(cwd, "AGENTS.md"),
-    path100.join(cwd, ".zelari", "AGENTS.md")
+    path101.join(cwd, "AGENTS.md"),
+    path101.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
@@ -79085,7 +79382,7 @@ function useChatTurn(params) {
         } else {
           envConfig = await providerFromEnv();
           if (!envConfig) {
-            const active = resolveActiveProvider2();
+            const active = resolveActiveProvider3();
             const spec = PROVIDERS.find((p3) => p3.id === active);
             appendSystem(
               setMessages,
@@ -79999,7 +80296,7 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
   const useLiveModel = !!(setLive && liveRef);
   const envConfig = await providerFromEnv();
   if (!envConfig) {
-    const active = resolveActiveProvider2();
+    const active = resolveActiveProvider3();
     const spec = PROVIDERS.find((p3) => p3.id === active);
     appendSystem(
       setMessages,
@@ -80761,7 +81058,7 @@ async function runZelariMissionInTui(userMessage, deps, emit) {
   const { setMessages } = deps;
   const envConfig = await providerFromEnv();
   if (!envConfig) {
-    const active = resolveActiveProvider2();
+    const active = resolveActiveProvider3();
     const spec = PROVIDERS.find((p3) => p3.id === active);
     emit(
       `No API key for the active provider "${active}". Set ${spec?.envVar ?? "the provider API key env var"} or run /login ${active} before starting a Zelari mission.`
@@ -81036,10 +81333,10 @@ init_ledger();
 
 // src/cli/evolution/proposals.ts
 import { existsSync as existsSync51, readFileSync as readFileSync39 } from "node:fs";
-import path78 from "node:path";
-var PROPOSALS_REL = path78.join(".zelari", "evolution", "proposals.jsonl");
+import path79 from "node:path";
+var PROPOSALS_REL = path79.join(".zelari", "evolution", "proposals.jsonl");
 function proposalsPath(cwd) {
-  return path78.join(cwd, PROPOSALS_REL);
+  return path79.join(cwd, PROPOSALS_REL);
 }
 function readProposalStore(cwd) {
   const file2 = proposalsPath(cwd);
@@ -82149,11 +82446,11 @@ function handleCacheStats(ctx) {
 init_messageHelpers();
 init_serviceFactory();
 import { promises as fs36 } from "node:fs";
-import * as path80 from "node:path";
+import * as path81 from "node:path";
 
 // src/cli/memory/promotion.ts
 import { promises as fs35 } from "node:fs";
-import * as path79 from "node:path";
+import * as path80 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"]);
@@ -82164,13 +82461,13 @@ function lineFor(node) {
 }
 async function promoteMemoryToAgentsMd(projectRoot, node) {
   if (node.status !== "active") {
-    return { added: false, path: path79.join(projectRoot, "AGENTS.md"), reason: `memory is ${node.status}` };
+    return { added: false, path: path80.join(projectRoot, "AGENTS.md"), reason: `memory is ${node.status}` };
   }
   if (!DURABLE_KINDS.has(node.kind)) {
-    return { added: false, path: path79.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
+    return { added: false, path: path80.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
   }
-  const root = await fs35.realpath(projectRoot).catch(() => path79.resolve(projectRoot));
-  const target = path79.join(root, "AGENTS.md");
+  const root = await fs35.realpath(projectRoot).catch(() => path80.resolve(projectRoot));
+  const target = path80.join(root, "AGENTS.md");
   try {
     const stat8 = await fs35.lstat(target);
     if (stat8.isSymbolicLink() || !stat8.isFile()) throw new Error("AGENTS.md must be a regular project file.");
@@ -82235,22 +82532,22 @@ function sourceLine(source2) {
   return entries.length ? entries.map(([key, value]) => `${key}=${value}`).join(" \xB7 ") : "unknown";
 }
 function isInside(root, target) {
-  const relative6 = path80.relative(root, target);
-  return relative6 === "" || !relative6.startsWith("..") && !path80.isAbsolute(relative6);
+  const relative6 = path81.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path81.isAbsolute(relative6);
 }
 async function safeExportPath(cwd, requested) {
-  const lexicalRoot = path80.resolve(cwd);
+  const lexicalRoot = path81.resolve(cwd);
   const root = await fs36.realpath(lexicalRoot).catch(() => lexicalRoot);
-  const fallback = path80.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
-  const target = requested?.trim() ? path80.resolve(root, requested.trim()) : fallback;
+  const fallback = path81.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
+  const target = requested?.trim() ? path81.resolve(root, requested.trim()) : fallback;
   if (!isInside(root, target)) {
     throw new Error("Export path must stay inside the active project.");
   }
-  const parent = path80.dirname(target);
-  const relativeParent = path80.relative(root, parent);
+  const parent = path81.dirname(target);
+  const relativeParent = path81.relative(root, parent);
   let cursor = root;
-  for (const segment of relativeParent.split(path80.sep).filter(Boolean)) {
-    cursor = path80.join(cursor, segment);
+  for (const segment of relativeParent.split(path81.sep).filter(Boolean)) {
+    cursor = path81.join(cursor, segment);
     try {
       const stat8 = await fs36.lstat(cursor);
       if (stat8.isSymbolicLink()) {
@@ -82422,9 +82719,9 @@ ${message}` : message
       }
       case "export": {
         const target = await safeExportPath(ctx.cwd, args.join(" ").trim() || void 0);
-        await fs36.mkdir(path80.dirname(target), { recursive: true });
-        const root = await fs36.realpath(ctx.cwd).catch(() => path80.resolve(ctx.cwd));
-        const realParent = await fs36.realpath(path80.dirname(target));
+        await fs36.mkdir(path81.dirname(target), { recursive: true });
+        const root = await fs36.realpath(ctx.cwd).catch(() => path81.resolve(ctx.cwd));
+        const realParent = await fs36.realpath(path81.dirname(target));
         if (!isInside(root, realParent)) {
           throw new Error("Export path resolves outside the active project.");
         }
@@ -82639,7 +82936,7 @@ import { promises as fs38 } from "node:fs";
 init_zod();
 init_taskTool();
 import { promises as fs37 } from "node:fs";
-import path81 from "node:path";
+import path82 from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
@@ -82733,8 +83030,8 @@ function resolveMaxConcurrency(env = process.env) {
 }
 async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
-  const absCsv = path81.isAbsolute(args.csv_path) ? args.csv_path : path81.join(opts.parentCwd, args.csv_path);
-  const absOut = path81.isAbsolute(args.output_csv_path) ? args.output_csv_path : path81.join(opts.parentCwd, args.output_csv_path);
+  const absCsv = path82.isAbsolute(args.csv_path) ? args.csv_path : path82.join(opts.parentCwd, args.csv_path);
+  const absOut = path82.isAbsolute(args.output_csv_path) ? args.output_csv_path : path82.join(opts.parentCwd, args.output_csv_path);
   const { headers: headers3, rows } = await readCsv(absCsv);
   if (headers3.length === 0) {
     throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
@@ -82790,7 +83087,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs37.mkdir(path81.dirname(absOut), { recursive: true });
+      await fs37.mkdir(path82.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -82985,7 +83282,7 @@ function splitArgs(s) {
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
 import { promises as fs39 } from "node:fs";
-import path82 from "node:path";
+import path83 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
 var EMPTY = {
@@ -83102,14 +83399,14 @@ function formatWorkbenchForTerminal(p3) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 async function handleKrakenWorkbench(ctx) {
-  const dir = path82.join(ctx.cwd, ".zelari", "radio");
+  const dir = path83.join(ctx.cwd, ".zelari", "radio");
   let latest = null;
   let latestMtime = 0;
   try {
     const files = await fs39.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
-      const full = path82.join(dir, f);
+      const full = path83.join(dir, f);
       const stat8 = await fs39.stat(full);
       if (stat8.mtimeMs > latestMtime) {
         latestMtime = stat8.mtimeMs;
@@ -83126,10 +83423,10 @@ async function handleKrakenWorkbench(ctx) {
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
-    appendSystem(ctx.setMessages, `[kraken workbench] ${path82.basename(latest)}: (no nodes / no events yet)`);
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path83.basename(latest)}: (no nodes / no events yet)`);
     return;
   }
-  appendSystem(ctx.setMessages, `[kraken workbench] ${path82.basename(latest)}:
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path83.basename(latest)}:
 ${rendered}`);
 }
 
@@ -83437,14 +83734,14 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 init_messageHelpers();
 init_paths();
 import { promises as fs40 } from "node:fs";
-import path85 from "node:path";
+import path86 from "node:path";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
     const skillDir = skillsDir();
     await fs40.mkdir(skillDir, { recursive: true });
-    const filePath = path85.join(skillDir, `${skill.id}.md`);
+    const filePath = path86.join(skillDir, `${skill.id}.md`);
     const previous = await fs40.readFile(filePath, "utf8").catch(() => null);
     const { createHash: createHash25 } = await import("node:crypto");
     const sha = (s) => createHash25("sha256").update(s, "utf8").digest("hex");
@@ -83470,7 +83767,7 @@ ${lineage}
 // src/cli/branchManager.ts
 init_paths();
 import { promises as fs41, existsSync as existsSync55, readFileSync as readFileSync41, writeFileSync as writeFileSync24, mkdirSync as mkdirSync21, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
-import path86 from "node:path";
+import path87 from "node:path";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
@@ -83480,13 +83777,13 @@ function getSessionsBaseDir() {
   return sessionsDir();
 }
 function branchPathFor(name, baseDir) {
-  return path86.join(baseDir, name);
+  return path87.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path86.join(baseDir, name, META_FILENAME);
+  return path87.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path86.join(baseDir, name, SESSIONS_SUBDIR);
+  return path87.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -83511,7 +83808,7 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync21(path86.dirname(metaPath), { recursive: true });
+  mkdirSync21(path87.dirname(metaPath), { recursive: true });
   writeFileSync24(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
@@ -83562,14 +83859,14 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path86.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path87.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync55(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync21(branchSessionsPath, { recursive: true });
-  const destPath = path86.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  const destPath = path87.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs41.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
@@ -83673,14 +83970,14 @@ async function handleBranchCheckout(ctx, branchName) {
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
 import { promises as fs42 } from "node:fs";
-import path87 from "node:path";
+import path88 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path87.join(process.cwd(), ".zelari");
+    const zelari = path88.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path87.join(zelari, "plan.md");
+        const planPath = path88.join(zelari, "plan.md");
         try {
           content = await fs42.readFile(planPath, "utf-8");
         } catch {
@@ -83689,7 +83986,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "decisions": {
-        const decisionsDir = path87.join(zelari, "decisions");
+        const decisionsDir = path88.join(zelari, "decisions");
         try {
           const files = (await fs42.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
@@ -83699,7 +83996,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 fs42.readFile(path87.join(decisionsDir, f), "utf-8");
+              const raw = await fs42.readFile(path88.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}`);
@@ -83712,7 +84009,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path87.join(zelari, "risks.md");
+        const risksPath = path88.join(zelari, "risks.md");
         try {
           content = await fs42.readFile(risksPath, "utf-8");
         } catch {
@@ -83721,7 +84018,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "agents": {
-        const agentsPath = path87.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path88.join(process.cwd(), "AGENTS.MD");
         try {
           content = await fs42.readFile(agentsPath, "utf-8");
         } catch {
@@ -83730,7 +84027,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "docs": {
-        const docsDir = path87.join(zelari, "docs");
+        const docsDir = path88.join(zelari, "docs");
         try {
           const files = (await fs42.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
@@ -83772,7 +84069,7 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path87.join(process.cwd(), ".zelari");
+    const target = path88.join(process.cwd(), ".zelari");
     await fs42.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
@@ -85656,8 +85953,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 path101 = 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 = path101 && /^[a-z0-9]/.test(path101) ? path101 : "imported-skill";
+      const path102 = 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 = path102 && /^[a-z0-9]/.test(path102) ? path102 : "imported-skill";
     } catch {
       name = "imported-skill";
     }