zelari-code 2.40.0 → 2.41.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, path102) {
-  if (!path102)
+function getElementAtPath(obj, path103) {
+  if (!path103)
     return obj;
-  return path102.reduce((acc, key) => acc?.[key], obj);
+  return path103.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(path102, issues) {
+function prefixIssues(path103, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path102);
+    iss.path.unshift(path103);
     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, path102 = []) => {
+  const processError = (error52, path103 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path102, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path103, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path102, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path103, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path102, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path103, ...issue2.path]);
       } else {
-        const fullpath = [...path102, ...issue2.path];
+        const fullpath = [...path103, ...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, path102 = []) => {
+  const processError = (error52, path103 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path102, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path103, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path102, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path103, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path102, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path103, ...issue2.path]);
       } else {
-        const fullpath = [...path102, ...issue2.path];
+        const fullpath = [...path103, ...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 path102 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path102) {
+  const path103 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path103) {
     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 path102 = ref.slice(1).split("/").filter(Boolean);
-  if (path102.length === 0) {
+  const path103 = ref.slice(1).split("/").filter(Boolean);
+  if (path103.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path102[0] === defsKey) {
-    const key = path102[1];
+  if (path103[0] === defsKey) {
+    const key = path103[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(path102, snapshotId) {
-  return { kind: "file.read", actor: { type: "tool" }, data: { path: path102, snapshotId } };
+function fileReadEvent(path103, snapshotId) {
+  return { kind: "file.read", actor: { type: "tool" }, data: { path: path103, snapshotId } };
 }
-function fileAppliedEvent(path102, snapshotId, bytes) {
-  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path102, snapshotId, bytes } };
+function fileAppliedEvent(path103, snapshotId, bytes) {
+  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path103, snapshotId, bytes } };
 }
-function fileRejectedEvent(path102, reason, hint) {
+function fileRejectedEvent(path103, reason, hint) {
   return {
     kind: "file.rejected",
     actor: { type: "tool" },
-    data: hint === void 0 ? { path: path102, reason } : { path: path102, reason, hint }
+    data: hint === void 0 ? { path: path103, reason } : { path: path103, 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 path102 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path103 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path102,
+            path: path103,
             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 "${path102}".`;
+          return `Document "${title}" created at "${path103}".`;
         }
       }
     ];
@@ -23878,7 +23878,7 @@ async function createExecutionContext(options = {}) {
       workspaceKind: workspace.kind
     }
   });
-  const fs49 = options.fs ?? new NodeFsProvider(workspace);
+  const fs50 = options.fs ?? new NodeFsProvider(workspace);
   const shell = options.shell ?? new NodeShellProvider(workspace);
   const subagent = options.subagent ?? NOOP_SUBAGENT_PROVIDER;
   const env = options.env ?? process.env;
@@ -23886,7 +23886,7 @@ async function createExecutionContext(options = {}) {
     sessionId: sessionId2,
     profile,
     workspace,
-    fs: fs49,
+    fs: fs50,
     shell,
     subagent,
     appendSessionEvent: (input) => writer.append(input),
@@ -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(path102) {
+async function dirSize(path103) {
   let total = 0;
   let entries;
   try {
-    entries = await readdir(path102, { withFileTypes: true });
+    entries = await readdir(path103, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child = join3(path102, entry.name);
+    const child = join3(path103, 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 path102 = join3(runsDir, entry.name);
+    const path103 = join3(runsDir, entry.name);
     let startedAt = 0;
     let endedAt;
     let completed = false;
     try {
-      const manifest = JSON.parse(await readFile(join3(path102, "manifest.json"), "utf8"));
+      const manifest = JSON.parse(await readFile(join3(path103, "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: path102, startedAt, endedAt, completed, bytes: await dirSize(path102) });
+    infos.push({ name: entry.name, path: path103, startedAt, endedAt, completed, bytes: await dirSize(path103) });
   }
   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, path102, sha2562, content, extra = {}) {
+      async fsEvidence(observation, path103, sha2562, content, extra = {}) {
         const digest = sha2562 && content !== void 0 ? sha2562(content) : void 0;
-        const seq = await this.emitEvidence({ observation, path: path102, ...extra, ...digest ? { digest } : {} });
+        const seq = await this.emitEvidence({ observation, path: path103, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
-          ref: path102,
+          ref: path103,
           capturedAt: Date.now(),
           ...digest ? { digest } : {},
           ...seq !== void 0 ? { seq } : {}
@@ -25906,25 +25906,25 @@ var init_engine = __esm({
       }
       async evalFileExists(check2, done) {
         const sha2562 = this.options.sha256 ?? defaultSha256;
-        const fs49 = this.services.fs;
-        if (!fs49)
+        const fs50 = this.services.fs;
+        if (!fs50)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs49.exists(check2.path);
+        const exists = await fs50.exists(check2.path);
         if (!exists) {
           await this.emitEvidence({ observation: "file-exists", path: check2.path, exists: false });
           return done({ status: "fail", evidence: [], detail: `file not found: ${check2.path}` });
         }
-        const content = await fs49.readFile(check2.path).catch(() => "");
+        const content = await fs50.readFile(check2.path).catch(() => "");
         return done({
           status: "pass",
           evidence: [await this.fsEvidence("file-exists", check2.path, sha2562, content, { exists: true })]
         });
       }
       async evalFileAbsent(check2, done) {
-        const fs49 = this.services.fs;
-        if (!fs49)
+        const fs50 = this.services.fs;
+        if (!fs50)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs49.exists(check2.path);
+        const exists = await fs50.exists(check2.path);
         if (exists) {
           await this.emitEvidence({ observation: "file-absent", path: check2.path, exists: true });
           return done({ status: "fail", evidence: [], detail: `file still present: ${check2.path}` });
@@ -25936,12 +25936,12 @@ var init_engine = __esm({
       }
       async evalFileContains(check2, done) {
         const sha2562 = this.options.sha256 ?? defaultSha256;
-        const fs49 = this.services.fs;
-        if (!fs49)
+        const fs50 = this.services.fs;
+        if (!fs50)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
         let content;
         try {
-          content = await fs49.readFile(check2.path);
+          content = await fs50.readFile(check2.path);
         } catch {
           await this.emitEvidence({ observation: "file-contains", path: check2.path, readable: false });
           return done({ status: "fail", evidence: [], detail: `file not readable: ${check2.path}` });
@@ -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 path102 = join5(zelariRoot, "nfr-spec.json");
-  if (!existsSync10(path102))
+  const path103 = join5(zelariRoot, "nfr-spec.json");
+  if (!existsSync10(path103))
     return null;
   try {
-    const raw = JSON.parse(readFileSync9(path102, "utf8"));
+    const raw = JSON.parse(readFileSync9(path103, "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 path102 = join11(zelariRoot, LESSONS_FILE);
+  const path103 = join11(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync14(path102, "utf8");
+    const raw = readFileSync14(path103, "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 path102 = join12(zelariRoot, LESSONS_FILE);
-  appendFileSync(path102, `${JSON.stringify(lesson)}
+  const path103 = join12(zelariRoot, LESSONS_FILE);
+  appendFileSync(path103, `${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 path102 = [];
+    const path103 = [];
     color.set(start, GRAY);
-    path102.push(start);
+    path103.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 = path102.indexOf(dep);
-          return [...path102.slice(at), dep];
+          const at = path103.indexOf(dep);
+          return [...path103.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path102.push(dep);
+          path103.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id3, BLACK);
-        path102.pop();
+        path103.pop();
         stack.pop();
       }
     }
@@ -37529,8 +37529,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path102 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path102}`);
+        const path103 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path103}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -38826,7 +38826,7 @@ var CORE_VERSION;
 var init_version = __esm({
   "packages/core/dist/version.js"() {
     "use strict";
-    CORE_VERSION = "2.39.0";
+    CORE_VERSION = "2.41.0";
   }
 });
 
@@ -41308,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 path102 = join14(dir, file2);
-    writeFileSync12(path102, fullText, "utf8");
-    return path102;
+    const path103 = join14(dir, file2);
+    writeFileSync12(path103, fullText, "utf8");
+    return path103;
   } catch {
     return null;
   }
@@ -41356,10 +41356,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path102 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path102) {
+    const path103 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path103) {
       const spillNote = `
-\u2026 [full output spilled to: ${path102} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path103} \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}
 `);
@@ -42162,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(path102) {
-        if (!existsSync19(path102)) {
-          throw new Error(`File not found: ${path102}`);
+      read(path103) {
+        if (!existsSync19(path103)) {
+          throw new Error(`File not found: ${path103}`);
         }
-        const md = readFileSync17(path102, "utf8");
+        const md = readFileSync17(path103, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path102) {
-        if (!existsSync19(path102)) return null;
-        return this.read(path102);
+      readIfExists(path103) {
+        if (!existsSync19(path103)) return null;
+        return this.read(path103);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path102, meta3, body) {
-        mkdirSync10(dirname2(path102), { recursive: true });
-        const tmp = path102 + ".tmp-" + process.pid;
+      write(path103, meta3, body) {
+        mkdirSync10(dirname2(path103), { recursive: true });
+        const tmp = path103 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync14(tmp, md, "utf8");
-        renameSync2(tmp, path102);
+        renameSync2(tmp, path103);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -42294,8 +42294,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path102 = join17(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync11(dirname3(path102), { recursive: true });
+  const path103 = join17(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync11(dirname3(path103), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -42316,7 +42316,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path102, meta3, body);
+  new Storage().write(path103, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join17(rootDir, "plan.json");
@@ -43721,6 +43721,46 @@ function formatPromoteNotice(node) {
   const preview = node.content.replace(/\s+/g, " ").trim().slice(0, 120);
   return `[memory] candidato AGENTS.MD: ${node.kind} \u201C${preview}\u201D \u2014 /memory promote ${node.id}`;
 }
+function parsePromoteArgs(args = []) {
+  const result = { asCheck: false };
+  const tokens = [...args];
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i] ?? "";
+    const inline = token.startsWith("--") && token.includes("=") ? token.split("=") : null;
+    const flag = inline ? inline[0] ?? "" : token;
+    const inlineValue = inline ? inline.slice(1).join("=") : void 0;
+    if (flag === "--as-check") {
+      result.asCheck = true;
+      continue;
+    }
+    if (COMMAND_FLAGS.has(flag) || EXIT_FLAGS.has(flag)) {
+      const parts = [];
+      if (inlineValue !== void 0 && inlineValue !== "") parts.push(inlineValue);
+      else {
+        while (i + 1 < tokens.length && !(tokens[i + 1] ?? "").startsWith("-")) {
+          parts.push(tokens[i + 1] ?? "");
+          i += 1;
+        }
+      }
+      const value = parts.join(" ").replace(/^\s*["']|["']\s*$/g, "").trim();
+      if (EXIT_FLAGS.has(flag)) {
+        const exit = Number(value);
+        if (!value || !Number.isInteger(exit)) {
+          return { ...result, error: `expect-exit must be an integer, got \u201C${value}\u201D.` };
+        }
+        result.expectExit = exit;
+        continue;
+      }
+      if (!value) return { ...result, error: "missing value for --command." };
+      result.command = value;
+      continue;
+    }
+    if (token.startsWith("-")) return { ...result, error: `unknown flag \u201C${token}\u201D.` };
+    if (!result.id) result.id = token;
+    else if (!result.command) return { ...result, error: `unexpected argument \u201C${token}\u201D.` };
+  }
+  return result;
+}
 function lineFor(node) {
   const content = node.content.replace(/\s+/g, " ").replace(/-->/g, "\u2014>").trim().slice(0, 2e3);
   const provenance = node.source.agent ? `; source=${node.source.agent}` : "";
@@ -43778,7 +43818,7 @@ ${END}
   }
   return { added: true, path: target };
 }
-var START, END, DURABLE_KINDS, PROMOTE_MIN_IMPORTANCE, PROMOTE_MIN_CONFIDENCE;
+var START, END, DURABLE_KINDS, PROMOTE_MIN_IMPORTANCE, PROMOTE_MIN_CONFIDENCE, PROMOTE_USAGE, COMMAND_FLAGS, EXIT_FLAGS;
 var init_promotion = __esm({
   "src/cli/memory/promotion.ts"() {
     "use strict";
@@ -43787,6 +43827,9 @@ var init_promotion = __esm({
     DURABLE_KINDS = /* @__PURE__ */ new Set(["fact", "decision", "constraint", "preference", "procedure"]);
     PROMOTE_MIN_IMPORTANCE = 0.7;
     PROMOTE_MIN_CONFIDENCE = 0.8;
+    PROMOTE_USAGE = 'Usage: /memory promote <id> [--as-check --command "<comando>" [--expect-exit N]]';
+    COMMAND_FLAGS = /* @__PURE__ */ new Set(["--command", "-c"]);
+    EXIT_FLAGS = /* @__PURE__ */ new Set(["--expect-exit", "-e", "--expectExit"]);
   }
 });
 
@@ -44133,6 +44176,48 @@ async function runBacktest(cwd, signal) {
   await appendTimeline(cwd, { kind: "backtest", ok: summary.ok, passed, failed, total: results.length });
   return summary;
 }
+async function readChecksStrict(cwd) {
+  const p3 = path44.join(worldDir(cwd), CHECKS_FILE);
+  let raw;
+  try {
+    raw = await fs19.readFile(p3, "utf8");
+  } catch (error51) {
+    if (error51.code === "ENOENT") return [];
+    throw error51;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`${p3} is not valid JSON \u2014 refusing to overwrite it.`);
+  }
+  if (!parsed || !Array.isArray(parsed.checks)) {
+    throw new Error(`${p3} has no "checks" array \u2014 refusing to overwrite it.`);
+  }
+  return parsed.checks;
+}
+async function appendWorldCheck(cwd, check2) {
+  const dir = await ensureWorldDir(cwd);
+  const file2 = path44.join(dir, CHECKS_FILE);
+  const checks = await readChecksStrict(cwd);
+  if (checks.some((entry) => entry?.id === check2.id)) {
+    return { added: false, count: checks.length, path: file2, reason: "duplicate" };
+  }
+  const next = { checks: [...checks, check2] };
+  const temporary = `${file2}.tmp-${process.pid}-${Date.now()}`;
+  await fs19.writeFile(temporary, JSON.stringify(next, null, 2) + "\n", {
+    encoding: "utf8",
+    flag: "wx"
+  });
+  try {
+    await fs19.rename(temporary, file2);
+  } catch (error51) {
+    await fs19.unlink(temporary).catch(() => void 0);
+    throw error51;
+  }
+  await appendTimeline(cwd, { kind: "world_check_appended", id: check2.id, count: next.checks.length });
+  return { added: true, count: next.checks.length, path: file2 };
+}
 function createWorldModelTools() {
   if (process.env["ZELARI_SCHEMA_LOOP"] === "0") return [];
   return [
@@ -53356,21 +53441,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path102 = getSshSecretsPath();
-  if (!existsSync30(path102)) return {};
+  const path103 = getSshSecretsPath();
+  if (!existsSync30(path103)) return {};
   try {
-    return JSON.parse(readFileSync22(path102, "utf8"));
+    return JSON.parse(readFileSync22(path103, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path102 = getSshSecretsPath();
-  mkdirSync13(dirname4(path102), { recursive: true });
-  writeFileSync16(path102, `${JSON.stringify(data, null, 2)}
+  const path103 = getSshSecretsPath();
+  mkdirSync13(dirname4(path103), { recursive: true });
+  writeFileSync16(path103, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path102, 384);
+    chmodSync(path103, 384);
   } catch {
   }
 }
@@ -53399,10 +53484,10 @@ function deleteSshPassword(id3) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path102 = getSshTargetsPath();
-  if (!existsSync30(path102)) return [];
+  const path103 = getSshTargetsPath();
+  if (!existsSync30(path103)) return [];
   try {
-    const parsed = JSON.parse(readFileSync22(path102, "utf8"));
+    const parsed = JSON.parse(readFileSync22(path103, "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"
@@ -53417,11 +53502,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path102 = getSshTargetsPath();
-  mkdirSync13(dirname4(path102), { recursive: true });
+  const path103 = getSshTargetsPath();
+  mkdirSync13(dirname4(path103), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync16(
-    path102,
+    path103,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -53667,11 +53752,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path102 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path103 = 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}${path102}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path103}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -57697,6 +57782,162 @@ var init_completionProof = __esm({
   }
 });
 
+// src/cli/memory/howWeTest.ts
+import { promises as fs28 } from "node:fs";
+import * as path67 from "node:path";
+function metaString(node, key) {
+  const value = node.metadata?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function metaNumber(node, key) {
+  const value = node.metadata?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function rowFromNode(node) {
+  if (node.kind !== "procedure" || node.status !== "active") return null;
+  if (node.metadata?.verified !== true) return null;
+  const key = metaString(node, "opsKnowledgeKey");
+  const command = metaString(node, "command");
+  const digest = metaString(node, "digest");
+  if (!key || !command || !digest) return null;
+  const seq = metaNumber(node, "seq");
+  return {
+    key,
+    criterionId: metaString(node, "criterionId") ?? "unknown",
+    command,
+    digest,
+    ...seq === void 0 ? {} : { seq }
+  };
+}
+function collectHowWeTestRows(nodes) {
+  const rows = nodes.map(rowFromNode).filter((row) => row !== null);
+  rows.sort((a, b) => a.key.localeCompare(b.key) || (a.seq ?? -1) - (b.seq ?? -1));
+  const byKey = /* @__PURE__ */ new Map();
+  for (const row of rows) byKey.set(row.key, row);
+  return [...byKey.values()].sort(
+    (a, b) => a.criterionId.localeCompare(b.criterionId) || a.command.localeCompare(b.command)
+  );
+}
+function shortDigest(digest) {
+  return digest.length <= 8 ? digest : digest.slice(0, 8);
+}
+function escapeCell(value) {
+  return value.replace(/\r?\n/g, " ").replace(/`/g, "'").trim();
+}
+function projectHowWeTest(rows) {
+  const lines = [
+    "# How we test",
+    "",
+    HOW_WE_TEST_HEADER,
+    "",
+    "Procedure verificate (deterministiche, evidence-backed): quello che una run",
+    "ha dimostrato resta qui per gli agenti e per gli umani che vengono dopo.",
+    "Generato da zelari \u2014 rigenera con `/memory how-we-test`.",
+    ""
+  ];
+  if (rows.length === 0) {
+    lines.push("_Nessuna procedura verificata ancora: niente da proiettare._", "");
+    return lines.join("\n");
+  }
+  let current = null;
+  for (const row of rows) {
+    if (row.criterionId !== current) {
+      current = row.criterionId;
+      lines.push(`## ${current}`, "");
+    }
+    const seq = row.seq === void 0 ? "\u2014" : `seq ${row.seq}`;
+    lines.push(`- \`${escapeCell(row.command)}\` \u2014 exit 0 \u2014 digest \`${shortDigest(row.digest)}\` \u2014 ultima osservazione ${seq}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function isMissing(error51) {
+  return error51?.code === "ENOENT";
+}
+async function writeHowWeTest(projectRoot, rows) {
+  const target = path67.join(projectRoot, HOW_WE_TEST_RELATIVE);
+  try {
+    if ((await fs28.lstat(target)).isSymbolicLink()) {
+      return { written: false, path: target, rows: rows.length, reason: "target is a symbolic link" };
+    }
+  } catch (error51) {
+    if (!isMissing(error51)) {
+      return {
+        written: false,
+        path: target,
+        rows: rows.length,
+        reason: error51 instanceof Error ? error51.message : String(error51)
+      };
+    }
+  }
+  await fs28.mkdir(path67.dirname(target), { recursive: true });
+  const temporary = `${target}.tmp-${process.pid}-${Date.now()}`;
+  await fs28.writeFile(temporary, projectHowWeTest(rows), { encoding: "utf8", flag: "wx" });
+  try {
+    await fs28.rename(temporary, target);
+  } catch (error51) {
+    await fs28.unlink(temporary).catch(() => void 0);
+    throw error51;
+  }
+  return { written: true, path: target, rows: rows.length };
+}
+function nodesFromDump(dump) {
+  if (Array.isArray(dump)) return dump;
+  const nodes = dump?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+}
+async function listNodes(source2) {
+  if (typeof source2.export !== "function") return null;
+  try {
+    return nodesFromDump(await source2.export());
+  } catch {
+    return null;
+  }
+}
+async function listVerifiedProcedureNodes(source2) {
+  const nodes = await listNodes(source2);
+  if (!nodes) return null;
+  return nodes.filter((node) => node.kind === "procedure" && node.metadata?.verified === true);
+}
+async function regenerateHowWeTest(source2, projectRoot) {
+  const nodes = await listVerifiedProcedureNodes(source2);
+  if (!nodes) {
+    return {
+      written: false,
+      path: path67.join(projectRoot, HOW_WE_TEST_RELATIVE),
+      rows: 0,
+      reason: "memory backend cannot enumerate procedures"
+    };
+  }
+  try {
+    return await writeHowWeTest(projectRoot, collectHowWeTestRows(nodes));
+  } catch (error51) {
+    return {
+      written: false,
+      path: path67.join(projectRoot, HOW_WE_TEST_RELATIVE),
+      rows: 0,
+      reason: error51 instanceof Error ? error51.message : String(error51)
+    };
+  }
+}
+async function regenerateHowWeTestSafe(source2, projectRoot) {
+  const nodes = await listVerifiedProcedureNodes(source2);
+  if (!nodes) return null;
+  try {
+    return await writeHowWeTest(projectRoot, collectHowWeTestRows(nodes));
+  } catch {
+    return null;
+  }
+}
+var HOW_WE_TEST_RELATIVE, HOW_WE_TEST_HEADER;
+var init_howWeTest = __esm({
+  "src/cli/memory/howWeTest.ts"() {
+    "use strict";
+    HOW_WE_TEST_RELATIVE = path67.join(".zelari", "how-we-test.md");
+    HOW_WE_TEST_HEADER = "<!-- generato \u2014 non editare (rigenera con /memory how-we-test) -->";
+  }
+});
+
 // src/cli/memory/repeatFailure.ts
 import { createHash as createHash18 } from "node:crypto";
 function failureFingerprint(command, exitCode, digest) {
@@ -57731,10 +57972,102 @@ var init_repeatFailure = __esm({
   }
 });
 
+// src/cli/memory/repeatCheck.ts
+function metaString2(node, key) {
+  const value = node.metadata?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function metaNumber2(node, key) {
+  const value = node.metadata?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function checkIdForFingerprint(fingerprint) {
+  return `con-${fingerprint}`;
+}
+function constraintFromNode(node) {
+  if (!node) return null;
+  const fingerprint = metaString2(node, "fingerprint");
+  const command = metaString2(node, "command");
+  const digest = metaString2(node, "digest");
+  if (!fingerprint || !command || !digest) return null;
+  const criterionId2 = metaString2(node, "criterionId");
+  return {
+    fingerprint,
+    command,
+    digest,
+    exitCode: metaNumber2(node, "exitCode") ?? guessExitCode(command),
+    ...criterionId2 ? { criterionId: criterionId2 } : {}
+  };
+}
+function sameCommand(a, b) {
+  return failureCommandLabel(a).toLowerCase() === failureCommandLabel(b).toLowerCase();
+}
+function pickFixProcedure(constraint, procedures = []) {
+  return procedures.find((node) => {
+    if (node.kind !== "procedure" || node.status !== "active") return false;
+    if (node.metadata?.verified !== true) return false;
+    const digest = metaString2(node, "digest");
+    const command = metaString2(node, "command");
+    if (!digest || digest !== constraint.digest || !command) return false;
+    return !sameCommand(command, constraint.command);
+  });
+}
+function commandFromProcedure(procedure) {
+  return metaString2(procedure, "command") ?? PLACEHOLDER_COMMAND;
+}
+function proposalFromConstraint(constraint, procedures = []) {
+  const fix = pickFixProcedure(constraint, procedures);
+  const command = fix ? commandFromProcedure(fix) : PLACEHOLDER_COMMAND;
+  return {
+    fp: constraint.fingerprint,
+    command: constraint.command,
+    exit: constraint.exitCode,
+    digest: constraint.digest,
+    checkId: checkIdForFingerprint(constraint.fingerprint),
+    derivedFromProcedure: fix !== void 0,
+    suggestedCheck: {
+      id: checkIdForFingerprint(constraint.fingerprint),
+      command,
+      expectExit: 0
+    }
+  };
+}
+function confirmCheck(proposal, confirmed = {}) {
+  const command = (confirmed.command ?? "").replace(/^\s*["']|["']\s*$/g, "").trim();
+  if (!command || command === PLACEHOLDER_COMMAND) return null;
+  const expectExit = typeof confirmed.expectExit === "number" && Number.isInteger(confirmed.expectExit) ? confirmed.expectExit : proposal.suggestedCheck.expectExit ?? 0;
+  return { id: proposal.checkId, command, expectExit };
+}
+function formatCheckProposalNotice(proposal) {
+  const preview = failureCommandLabel(proposal.command).replace(/\s+/g, " ").slice(0, 120);
+  const suffix = proposal.derivedFromProcedure ? `--as-check --command "${proposal.suggestedCheck.command}"` : '--as-check --command "<comando>"';
+  return `[memory] candidato WorldCheck: \u201C${preview}\u201D (exit ${proposal.exit}) \u2014 /memory promote ${proposal.checkId} ${suffix}`;
+}
+function checkConfirmationHint(proposal) {
+  return proposal.derivedFromProcedure ? `[memory] proposta di check (applicazione sempre manuale):
+  id: ${proposal.checkId}
+  comando suggerito (da procedura verificata): ${proposal.suggestedCheck.command}
+  exit atteso: ${proposal.suggestedCheck.expectExit}
+  conferma con: /memory promote ${proposal.checkId} --as-check --command "${proposal.suggestedCheck.command}"` : `[memory] proposta di check (applicazione sempre manuale):
+  id: ${proposal.checkId}
+  comando fallito (NON ri-eseguito automaticamente): ${failureCommandLabel(proposal.command)}
+  digest: ${proposal.digest} \xB7 exit ${proposal.exit}
+  nessuna procedura verificata per lo stesso digest: scrivi il comando di regressione,
+  conferma con: /memory promote ${proposal.checkId} --as-check --command "<comando>"`;
+}
+var PLACEHOLDER_COMMAND;
+var init_repeatCheck = __esm({
+  "src/cli/memory/repeatCheck.ts"() {
+    "use strict";
+    init_repeatFailure();
+    PLACEHOLDER_COMMAND = "<confirm-command>";
+  }
+});
+
 // src/cli/memory/legacyImport.ts
 import { createHash as createHash19 } from "node:crypto";
-import { promises as fs28 } from "node:fs";
-import * as path67 from "node:path";
+import { promises as fs29 } from "node:fs";
+import * as path68 from "node:path";
 function sourceId(fact, line) {
   return `jsonl:${fact.id ?? createHash19("sha256").update(line).digest("hex")}`;
 }
@@ -57755,7 +58088,7 @@ function isPermanentSkip(error51) {
 }
 async function isImportComplete(markerPath) {
   try {
-    const marker = JSON.parse(await fs28.readFile(markerPath, "utf8"));
+    const marker = JSON.parse(await fs29.readFile(markerPath, "utf8"));
     return typeof marker?.found === "number" && typeof marker?.at === "string";
   } catch {
     return false;
@@ -57764,20 +58097,20 @@ async function isImportComplete(markerPath) {
 async function markImportComplete(markerPath, found) {
   const temporary = `${markerPath}.tmp`;
   try {
-    await fs28.writeFile(temporary, `${JSON.stringify({ found, at: (/* @__PURE__ */ new Date()).toISOString() })}
+    await fs29.writeFile(temporary, `${JSON.stringify({ found, at: (/* @__PURE__ */ new Date()).toISOString() })}
 `, "utf8");
-    await fs28.rename(temporary, markerPath);
+    await fs29.rename(temporary, markerPath);
   } catch {
   }
 }
 async function importLegacyMemoryLog(backend, service) {
   const result = { found: 0, imported: 0, skipped: 0, corrupt: 0 };
-  const memoryDir = path67.dirname(backend.databasePath);
-  const markerPath = path67.join(memoryDir, LEGACY_IMPORT_MARKER);
+  const memoryDir = path68.dirname(backend.databasePath);
+  const markerPath = path68.join(memoryDir, LEGACY_IMPORT_MARKER);
   if (await isImportComplete(markerPath)) return result;
   let raw;
   try {
-    raw = await fs28.readFile(path67.join(memoryDir, "log.jsonl"), "utf8");
+    raw = await fs29.readFile(path68.join(memoryDir, "log.jsonl"), "utf8");
   } catch {
     return result;
   }
@@ -57969,7 +58302,7 @@ var init_sqliteCodec = __esm({
 // src/cli/memory/sqliteRpc.ts
 import { existsSync as existsSync34 } from "node:fs";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 import { Worker } from "node:worker_threads";
 function isBusy(error51) {
   const candidate = error51;
@@ -57978,10 +58311,10 @@ function isBusy(error51) {
   );
 }
 function resolveWorkerUrl() {
-  const here = path68.dirname(fileURLToPath2(import.meta.url));
-  const direct = path68.join(here, "sqliteWorker.mjs");
+  const here = path69.dirname(fileURLToPath2(import.meta.url));
+  const direct = path69.join(here, "sqliteWorker.mjs");
   if (existsSync34(direct)) return pathToFileURL2(direct);
-  return pathToFileURL2(path68.join(here, "memory", "sqliteWorker.mjs"));
+  return pathToFileURL2(path69.join(here, "memory", "sqliteWorker.mjs"));
 }
 var SqliteWorkerRpc;
 var init_sqliteRpc = __esm({
@@ -58269,8 +58602,8 @@ 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 randomUUID5 } from "node:crypto";
-import { promises as fs29 } from "node:fs";
-import * as path69 from "node:path";
+import { promises as fs30 } from "node:fs";
+import * as path70 from "node:path";
 function boundedLimit(value, fallback = 50) {
   return Math.max(1, Math.min(Math.floor(value ?? fallback), 1e5));
 }
@@ -58331,42 +58664,42 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
       async init(projectRoot) {
         let resolved;
         try {
-          resolved = await fs29.realpath(projectRoot);
+          resolved = await fs30.realpath(projectRoot);
         } catch {
-          resolved = path69.resolve(projectRoot);
+          resolved = path70.resolve(projectRoot);
         }
         if (this.initialized && resolved === this.projectRoot) return;
         if (this.initialized) await this.close();
         const filename = this.options.filename ?? "memory.db";
-        if (path69.basename(filename) !== filename || filename === "." || filename === "..") {
+        if (path70.basename(filename) !== filename || filename === "." || filename === "..") {
           throw new Error("SQLite memory filename must not contain a path.");
         }
-        const zelariDirectory = path69.join(resolved, ".zelari");
-        const directory = path69.join(zelariDirectory, "memory");
+        const zelariDirectory = path70.join(resolved, ".zelari");
+        const directory = path70.join(zelariDirectory, "memory");
         for (const candidate of [zelariDirectory, directory]) {
           let stat8;
           try {
-            stat8 = await fs29.lstat(candidate);
+            stat8 = await fs30.lstat(candidate);
           } catch (error51) {
             if (error51.code !== "ENOENT") throw error51;
             try {
-              await fs29.mkdir(candidate);
+              await fs30.mkdir(candidate);
             } catch (mkdirError) {
               if (mkdirError.code !== "EEXIST") throw mkdirError;
             }
-            stat8 = await fs29.lstat(candidate);
+            stat8 = await fs30.lstat(candidate);
           }
           if (stat8.isSymbolicLink() || !stat8.isDirectory()) {
             throw new Error(`Memory directory is not a real directory: ${candidate}`);
           }
         }
-        const canonicalDirectory = await fs29.realpath(directory);
-        const relativeDirectory = path69.relative(resolved, canonicalDirectory);
-        if (relativeDirectory.startsWith("..") || path69.isAbsolute(relativeDirectory)) {
+        const canonicalDirectory = await fs30.realpath(directory);
+        const relativeDirectory = path70.relative(resolved, canonicalDirectory);
+        if (relativeDirectory.startsWith("..") || path70.isAbsolute(relativeDirectory)) {
           throw new Error("SQLite memory directory resolves outside the active project.");
         }
         this.projectRoot = resolved;
-        this.databasePath = path69.join(canonicalDirectory, filename);
+        this.databasePath = path70.join(canonicalDirectory, filename);
         const opened = await this.rpc.open({
           dbPath: this.databasePath,
           schemaSql: SQLITE_MEMORY_BASE_SCHEMA,
@@ -58908,8 +59241,8 @@ __export(serviceFactory_exports, {
   isMemoryV2Enabled: () => isMemoryV2Enabled
 });
 import { createHash as createHash21 } from "node:crypto";
-import { promises as fs30 } from "node:fs";
-import * as path70 from "node:path";
+import { promises as fs31 } from "node:fs";
+import * as path71 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;
@@ -58928,9 +59261,9 @@ function semanticMinScore(env) {
 async function canonicalProjectId(projectRoot) {
   let canonical;
   try {
-    canonical = await fs30.realpath(projectRoot);
+    canonical = await fs31.realpath(projectRoot);
   } catch {
-    canonical = path70.resolve(projectRoot);
+    canonical = path71.resolve(projectRoot);
   }
   canonical = canonical.replace(/\\/g, "/").replace(/\/$/, "");
   if (process.platform === "win32") canonical = canonical.toLocaleLowerCase("en-US");
@@ -59167,6 +59500,8 @@ async function promoteOpsKnowledge(gate, deps) {
   let skippedDuplicate = 0;
   let constraintsCreated = 0;
   const proposals = [];
+  const checkProposals = [];
+  const procedureNodes = fails.length > 0 ? await listVerifiedProcedureNodes(memory) ?? [] : [];
   for (const candidate of pass) {
     const outcome = await rememberProcedure(memory, candidate, { sessionId: deps.sessionId });
     if (outcome === "created") {
@@ -59186,11 +59521,14 @@ async function promoteOpsKnowledge(gate, deps) {
       constraintsCreated += 1;
       const node = await memory.get(outcome.constraintId);
       if (node && meetsPromoteThreshold(node)) proposals.push(formatPromoteNotice(node));
+      const constraint = constraintFromNode(node);
+      if (constraint) checkProposals.push(proposalFromConstraint(constraint, procedureNodes));
     } else if (outcome.constraint === "duplicate") {
       skippedDuplicate += 1;
     }
   }
-  return { enabled: true, created, skippedDuplicate, constraintsCreated, proposals };
+  if (created > 0) await regenerateHowWeTestSafe(memory, deps.projectRoot);
+  return { enabled: true, created, skippedDuplicate, constraintsCreated, proposals, checkProposals };
 }
 async function promoteOpsKnowledgeSafe(gate, deps) {
   try {
@@ -59206,7 +59544,8 @@ function emptyResult(enabled, skippedReason) {
     created: 0,
     skippedDuplicate: 0,
     constraintsCreated: 0,
-    proposals: []
+    proposals: [],
+    checkProposals: []
   };
 }
 async function openMemory(projectRoot, env) {
@@ -59222,7 +59561,9 @@ var ALLOWED_TIERS;
 var init_opsKnowledge = __esm({
   "src/cli/memory/opsKnowledge.ts"() {
     "use strict";
+    init_howWeTest();
     init_promotion();
+    init_repeatCheck();
     init_repeatFailure();
     init_repeatFailure();
     ALLOWED_TIERS = /* @__PURE__ */ new Set(["command-output", "fs-observation"]);
@@ -59312,20 +59653,20 @@ var init_askUserTimeout = __esm({
 
 // src/cli/state/fileStateStore.ts
 import { createHash as createHash23, randomUUID as randomUUID6 } from "node:crypto";
-import { promises as fs31 } from "node:fs";
-import * as path71 from "node:path";
+import { promises as fs32 } from "node:fs";
+import * as path72 from "node:path";
 function shortId() {
   return randomUUID6().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs31.mkdir(path71.dirname(filePath), { recursive: true });
+  await fs32.mkdir(path72.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await fs31.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
-  await fs31.rename(tmp, filePath);
+  await fs32.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
+  await fs32.rename(tmp, filePath);
 }
 async function readJsonFile(filePath) {
   try {
-    const raw = await fs31.readFile(filePath, "utf8");
+    const raw = await fs32.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -59379,13 +59720,13 @@ var init_fileStateStore = __esm({
       indexPath = "";
       async init(projectRoot) {
         this.root = projectRoot;
-        this.stateDir = path71.join(projectRoot, ".zelari", "state");
-        this.commitsDir = path71.join(this.stateDir, "commits");
-        this.artifactsDir = path71.join(this.stateDir, "artifacts");
-        this.headPath = path71.join(this.stateDir, "HEAD.json");
-        this.indexPath = path71.join(this.stateDir, "index.jsonl");
-        await fs31.mkdir(this.commitsDir, { recursive: true });
-        await fs31.mkdir(this.artifactsDir, { recursive: true });
+        this.stateDir = path72.join(projectRoot, ".zelari", "state");
+        this.commitsDir = path72.join(this.stateDir, "commits");
+        this.artifactsDir = path72.join(this.stateDir, "artifacts");
+        this.headPath = path72.join(this.stateDir, "HEAD.json");
+        this.indexPath = path72.join(this.stateDir, "index.jsonl");
+        await fs32.mkdir(this.commitsDir, { recursive: true });
+        await fs32.mkdir(this.artifactsDir, { recursive: true });
       }
       async commit(input) {
         if (!input.force && input.verification.ran && !input.verification.ok) {
@@ -59396,13 +59737,13 @@ var init_fileStateStore = __esm({
         const discoveries = input.discoveries ?? [];
         const parent = await this.head();
         const id3 = shortId();
-        const artifactRel = path71.join("artifacts", id3);
-        const artifactAbs = path71.join(this.artifactsDir, id3);
-        await fs31.mkdir(artifactAbs, { recursive: true });
+        const artifactRel = path72.join("artifacts", id3);
+        const artifactAbs = path72.join(this.artifactsDir, id3);
+        await fs32.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs31.writeFile(path71.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
-        await writeJsonAtomic(path71.join(artifactAbs, "discoveries.json"), discoveries);
-        await writeJsonAtomic(path71.join(artifactAbs, "verification.json"), input.verification);
+        await fs32.writeFile(path72.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await writeJsonAtomic(path72.join(artifactAbs, "discoveries.json"), discoveries);
+        await writeJsonAtomic(path72.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
           id: id3,
           parentId: parent?.id ?? null,
@@ -59414,16 +59755,16 @@ var init_fileStateStore = __esm({
           workspaceCheckpointId: input.workspaceCheckpointId,
           verification: {
             ...input.verification,
-            reportPath: input.verification.reportPath ?? path71.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
+            reportPath: input.verification.reportPath ?? path72.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
           },
           changedPaths: input.changedPaths ?? [],
           stablePromptHash: input.stablePromptHash,
           discoveryCount: discoveries.length,
           artifactDir: artifactRel.replace(/\\/g, "/")
         };
-        await writeJsonAtomic(path71.join(this.commitsDir, `${id3}.json`), meta3);
+        await writeJsonAtomic(path72.join(this.commitsDir, `${id3}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id: id3, updatedAt: meta3.createdAt });
-        await fs31.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
+        await fs32.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
       }
       async head() {
@@ -59432,13 +59773,13 @@ var init_fileStateStore = __esm({
         return this.get(head.id);
       }
       async get(id3) {
-        const stored = await readJsonFile(path71.join(this.commitsDir, `${id3}.json`));
+        const stored = await readJsonFile(path72.join(this.commitsDir, `${id3}.json`));
         return stored ? stripStored(stored) : null;
       }
       async list(limit = 20) {
         let raw;
         try {
-          raw = await fs31.readFile(this.indexPath, "utf8");
+          raw = await fs32.readFile(this.indexPath, "utf8");
         } catch {
           return [];
         }
@@ -59471,9 +59812,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(path71.join(this.commitsDir, `${meta3.id}.json`));
+        const stored = await readJsonFile(path72.join(this.commitsDir, `${meta3.id}.json`));
         if (!stored?.artifactDir) return [];
-        const discPath = path71.join(this.stateDir, stored.artifactDir, "discoveries.json");
+        const discPath = path72.join(this.stateDir, stored.artifactDir, "discoveries.json");
         return await readJsonFile(discPath) ?? [];
       }
       async materializeContext(id3, maxChars = DEFAULT_MATERIALIZE_CHARS) {
@@ -59684,7 +60025,7 @@ __export(conversationContext_exports, {
   setLastClarification: () => setLastClarification
 });
 import { existsSync as existsSync35 } from "node:fs";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function getHistory() {
   return history;
 }
@@ -59693,7 +60034,7 @@ function setHistory(messages) {
   history = projected === messages ? [...messages] : projected;
 }
 function compactInPlace(cwd = process.cwd()) {
-  const durableStatePresent = existsSync35(join26(cwd, ".zelari", "state", "HEAD.json"));
+  const durableStatePresent = existsSync35(join27(cwd, ".zelari", "state", "HEAD.json"));
   history = applySessionSurface(compactHistory(history, { durableStatePresent }));
 }
 function appendMessages(msgs) {
@@ -60076,10 +60417,10 @@ var init_mode = __esm({
 
 // src/cli/headless.ts
 import { readFileSync as readFileSync24 } from "node:fs";
-import path72 from "node:path";
+import path73 from "node:path";
 function resolveHeadlessCwd(opts) {
   const raw = typeof opts.cwd === "string" ? opts.cwd.trim() : "";
-  return path72.resolve(raw.length > 0 ? raw : process.cwd());
+  return path73.resolve(raw.length > 0 ? raw : process.cwd());
 }
 function defaultProfileForMode(mode) {
   switch (mode) {
@@ -60395,7 +60736,7 @@ __export(headlessSpine_exports, {
   seedHeadlessModelHistory: () => seedHeadlessModelHistory,
   sessionStartedEvent: () => sessionStartedEvent
 });
-import path73 from "node:path";
+import path74 from "node:path";
 function sessionStartedEvent(handle) {
   return {
     type: "session_started",
@@ -60412,7 +60753,7 @@ async function countVerificationEvidenceInLog(mirror, sessionId2) {
   try {
     await mirror.flush().catch(() => void 0);
     const report = await readSessionLogCached(
-      path73.join(mirror.sessionsDir, sessionId2, "events.jsonl"),
+      path74.join(mirror.sessionsDir, sessionId2, "events.jsonl"),
       mirror.replayCache
     );
     return report.events.filter((e) => e.kind === "verification.evidence").length;
@@ -61188,9 +61529,9 @@ __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
 import { existsSync as existsSync36, readFileSync as readFileSync25 } from "node:fs";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
-  const planPath = join27(resolveWorkspaceRoot(projectRoot), "plan.json");
+  const planPath = join28(resolveWorkspaceRoot(projectRoot), "plan.json");
   if (!existsSync36(planPath)) return false;
   try {
     const parsed = JSON.parse(readFileSync25(planPath, "utf8"));
@@ -61208,10 +61549,10 @@ var init_planDetect = __esm({
 
 // src/cli/workspace/projectInstructions.ts
 import { existsSync as existsSync37, readFileSync as readFileSync26 } from "node:fs";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
   for (const name of CANDIDATES) {
-    const full = join28(projectRoot, name);
+    const full = join29(projectRoot, name);
     if (!existsSync37(full)) continue;
     try {
       let raw = readFileSync26(full, "utf8");
@@ -61259,7 +61600,7 @@ __export(workspaceSummary_exports, {
   buildZelariReadHint: () => buildZelariReadHint
 });
 import { existsSync as existsSync38, readFileSync as readFileSync27, readdirSync as readdirSync7, statSync as statSync5 } from "node:fs";
-import { join as join29, relative as relative2 } from "node:path";
+import { join as join30, relative as relative2 } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30, maxChars = 3500, maxDeps = 24, maxScripts = 16 } = options;
   const name = safeProjectName(projectRoot);
@@ -61292,7 +61633,7 @@ function formatTaskLine(t) {
 }
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  const planPath = join29(zelariRoot, "plan.json");
+  const planPath = join30(zelariRoot, "plan.json");
   if (!existsSync38(planPath)) return null;
   let plan;
   try {
@@ -61435,7 +61776,7 @@ function pickNextTask(open2) {
   )[0];
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
-  const planPath = join29(resolveWorkspaceRoot(projectRoot), "plan.json");
+  const planPath = join30(resolveWorkspaceRoot(projectRoot), "plan.json");
   if (!existsSync38(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/) \u2014 DRAFT vault",
@@ -61451,7 +61792,7 @@ function safeProjectName(root) {
   }
 }
 function readPackageJson2(projectRoot) {
-  const p3 = join29(projectRoot, "package.json");
+  const p3 = join30(projectRoot, "package.json");
   if (!existsSync38(p3)) return null;
   try {
     return JSON.parse(readFileSync27(p3, "utf8"));
@@ -61504,11 +61845,11 @@ function listShallow(projectRoot, maxEntries) {
         out.push(`\u2026 (+${top.length - count} more)`);
         break;
       }
-      const rel2 = relative2(projectRoot, join29(projectRoot, entry.name));
+      const rel2 = relative2(projectRoot, join30(projectRoot, entry.name));
       if (entry.isDirectory()) {
         let inner = "";
         try {
-          const sub = readdirSync7(join29(projectRoot, entry.name), {
+          const sub = readdirSync7(join30(projectRoot, entry.name), {
             withFileTypes: true
           }).filter((e) => !e.name.startsWith(".")).slice(0, 4).map((e) => e.name);
           if (sub.length > 0)
@@ -61557,11 +61898,11 @@ var init_workspaceSummary = __esm({
 
 // src/cli/workspace/buildLessonsSummary.ts
 import { existsSync as existsSync39 } from "node:fs";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync39(join30(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync39(join31(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -61583,7 +61924,7 @@ __export(composeContext_exports, {
   composeProjectContext: () => composeProjectContext
 });
 import { existsSync as existsSync40, readdirSync as readdirSync8, readFileSync as readFileSync28 } from "node:fs";
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 function cap2(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
   return {
@@ -61600,7 +61941,7 @@ function buildDesignIndex(projectRoot, maxChars) {
     "# Design vault index (.zelari/) \u2014 HYPOTHESES only",
     "Full design docs are NOT product source of truth. Open with list_files / read_file / searchDocuments if needed."
   ];
-  const docsDir = join31(root, "docs");
+  const docsDir = join32(root, "docs");
   if (existsSync40(docsDir)) {
     try {
       const docs = readdirSync8(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
@@ -61615,11 +61956,11 @@ function buildDesignIndex(projectRoot, maxChars) {
     }
   }
   for (const name of ["risks.md", "plan.json", "nfr-spec.json"]) {
-    if (existsSync40(join31(root, name))) {
+    if (existsSync40(join32(root, name))) {
       lines.push(`- .zelari/${name} present`);
     }
   }
-  const decisionsDir = join31(root, "decisions");
+  const decisionsDir = join32(root, "decisions");
   if (existsSync40(decisionsDir)) {
     try {
       const n = readdirSync8(decisionsDir).filter((f) => f.endsWith(".md")).length;
@@ -61721,14 +62062,14 @@ function composeProjectContext(input) {
 }
 function readDurableHeadSync(projectRoot) {
   try {
-    const headPath = join31(projectRoot, ".zelari", "state", "HEAD.json");
+    const headPath = join32(projectRoot, ".zelari", "state", "HEAD.json");
     if (!existsSync40(headPath)) return "";
     const head = JSON.parse(readFileSync28(headPath, "utf8"));
     if (!head?.id) return "";
-    const metaPath = join31(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
+    const metaPath = join32(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
     if (!existsSync40(metaPath)) return "";
     const meta3 = JSON.parse(readFileSync28(metaPath, "utf8"));
-    const discPath = meta3.artifactDir ? join31(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join31(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
+    const discPath = meta3.artifactDir ? join32(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join32(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
     let discoveries = [];
     if (existsSync40(discPath)) {
       discoveries = JSON.parse(readFileSync28(discPath, "utf8"));
@@ -61812,7 +62153,7 @@ import {
   mkdirSync as mkdirSync16,
   renameSync as renameSync5
 } from "node:fs";
-import { join as join32, basename as basename4, dirname as dirname8, relative as relative3 } from "node:path";
+import { join as join33, basename as basename4, dirname as dirname9, relative as relative3 } from "node:path";
 function createWorkspaceContext(projectRoot = process.cwd()) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return {
@@ -61822,7 +62163,7 @@ function createWorkspaceContext(projectRoot = process.cwd()) {
   };
 }
 function planJsonPath(ctx) {
-  return join32(ctx.rootDir, "plan.json");
+  return join33(ctx.rootDir, "plan.json");
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
@@ -61841,8 +62182,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path102 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path102);
+  const path103 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path103);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -61853,7 +62194,7 @@ function readPlan(ctx) {
 }
 function writePlan(ctx, summary) {
   const jsonPath = planJsonPath(ctx);
-  mkdirSync16(dirname8(jsonPath), { recursive: true });
+  mkdirSync16(dirname9(jsonPath), { recursive: true });
   const tmp = jsonPath + ".tmp-" + process.pid;
   writeFileSync18(
     tmp,
@@ -61935,7 +62276,7 @@ function renderPlanBody(summary) {
   return lines.join("\n");
 }
 function nextAdrId(ctx) {
-  const decisionsDir = join32(ctx.rootDir, "decisions");
+  const decisionsDir = join33(ctx.rootDir, "decisions");
   if (!existsSync41(decisionsDir)) return "001";
   const existing = readdirSync9(decisionsDir).filter((f) => f.endsWith(".md")).map((f) => f.match(/^(\d+)-/)).filter((m) => !!m).map((m) => parseInt(m[1], 10));
   const max = existing.length === 0 ? 0 : Math.max(...existing);
@@ -61981,7 +62322,7 @@ function addTaskRecord(ctx, summary, phaseId, t, options) {
     // plan.json record (they already live in tags + the artifact body md).
     files: t.fileRefs
   });
-  const taskPath = join32(ctx.rootDir, "plan-tasks", `${id3}.md`);
+  const taskPath = join33(ctx.rootDir, "plan-tasks", `${id3}.md`);
   const meta3 = {
     kind: "task",
     id: id3,
@@ -62023,7 +62364,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path102 = join32(ctx.rootDir, "milestones", `${id3}.md`);
+  const path103 = join33(ctx.rootDir, "milestones", `${id3}.md`);
   const meta3 = {
     kind: "milestone",
     id: id3,
@@ -62040,7 +62381,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path102, meta3, body);
+  ctx.storage.write(path103, meta3, body);
   return { id: id3, created: true };
 }
 function readPlanSummary(ctx) {
@@ -62244,7 +62585,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id3 = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path102 = workspaceArtifact(ctx.rootDir, "decisions", id3);
+        const path103 = workspaceArtifact(ctx.rootDir, "decisions", id3);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -62270,7 +62611,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path102, meta3, body);
+        ctx.storage.write(path103, meta3, body);
         return `ADR ${id3} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -62321,7 +62662,7 @@ function createNfrSpecStub(ctx) {
           },
           planFeatureKeywords: Array.isArray(args["planFeatureKeywords"]) ? args["planFeatureKeywords"] : void 0
         };
-        const outPath = join32(ctx.rootDir, "nfr-spec.json");
+        const outPath = join33(ctx.rootDir, "nfr-spec.json");
         writeFileSync18(outPath, JSON.stringify(spec, null, 2), "utf8");
         return `NFR spec written to nfr-spec.json (${targets.length} target(s)).`;
       });
@@ -62352,14 +62693,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path102 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path103 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path102, meta3, content);
+        ctx.storage.write(path103, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -62385,11 +62726,11 @@ function searchDocumentsStub(ctx) {
         (w) => w.length >= 3 && w !== "or" && w !== "and" && w !== "the"
       );
       const files = [
-        ...ctx.storage.listMarkdown(join32(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join32(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join32(ctx.rootDir, "reviews")),
-        ...ctx.storage.listMarkdown(join32(ctx.rootDir, "plan-tasks")),
-        ...ctx.storage.listMarkdown(join32(ctx.rootDir, "milestones")),
+        ...ctx.storage.listMarkdown(join33(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join33(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join33(ctx.rootDir, "reviews")),
+        ...ctx.storage.listMarkdown(join33(ctx.rootDir, "plan-tasks")),
+        ...ctx.storage.listMarkdown(join33(ctx.rootDir, "milestones")),
         workspaceFile(ctx.rootDir, "plan"),
         workspaceFile(ctx.rootDir, "risks")
       ];
@@ -62447,9 +62788,9 @@ function linkDocumentsStub(ctx) {
         const toId = args["toId"] ?? args["targetId"] ?? args["targetPathOrTitle"];
         if (!fromId || !toId) return "linkDocuments requires fromId and toId.";
         const allFiles = [
-          ...ctx.storage.listMarkdown(join32(ctx.rootDir, "decisions")),
-          ...ctx.storage.listMarkdown(join32(ctx.rootDir, "docs")),
-          ...ctx.storage.listMarkdown(join32(ctx.rootDir, "reviews"))
+          ...ctx.storage.listMarkdown(join33(ctx.rootDir, "decisions")),
+          ...ctx.storage.listMarkdown(join33(ctx.rootDir, "docs")),
+          ...ctx.storage.listMarkdown(join33(ctx.rootDir, "reviews"))
         ];
         const source2 = allFiles.find((f) => {
           try {
@@ -62480,9 +62821,9 @@ function getDocumentBacklinksStub(ctx) {
       const targetId = args["targetId"] ?? args["id"];
       if (!targetId) return "getDocumentBacklinks requires targetId.";
       const allFiles = [
-        ...ctx.storage.listMarkdown(join32(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join32(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join32(ctx.rootDir, "reviews"))
+        ...ctx.storage.listMarkdown(join33(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join33(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join33(ctx.rootDir, "reviews"))
       ];
       const backlinks = [];
       for (const file2 of allFiles) {
@@ -62977,17 +63318,17 @@ import {
   readFileSync as readFileSync30,
   writeFileSync as writeFileSync19
 } from "node:fs";
-import { dirname as dirname9, join as join33 } from "node:path";
+import { dirname as dirname10, join as join34 } from "node:path";
 function getUserMcpPath() {
-  return join33(zelariHome(), "mcp.json");
+  return join34(zelariHome(), "mcp.json");
 }
 function getProjectMcpPath(projectRoot) {
-  return join33(projectRoot, ".zelari", "mcp.json");
+  return join34(projectRoot, ".zelari", "mcp.json");
 }
-function readFile10(path102) {
-  if (!existsSync42(path102)) return {};
+function readFile10(path103) {
+  if (!existsSync42(path103)) return {};
   try {
-    const parsed = JSON.parse(readFileSync30(path102, "utf8"));
+    const parsed = JSON.parse(readFileSync30(path103, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       const hasCommand = !!cfg && typeof cfg.command === "string" && !!cfg.command.trim();
@@ -63009,10 +63350,10 @@ function readFile10(path102) {
     return {};
   }
 }
-function writeFile4(path102, servers) {
-  mkdirSync17(dirname9(path102), { recursive: true });
+function writeFile4(path103, servers) {
+  mkdirSync17(dirname10(path103), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync19(path102, `${JSON.stringify(body, null, 2)}
+  writeFileSync19(path103, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -63050,9 +63391,9 @@ function upsertMcpServer(opts) {
       error: "either command (stdio) or url (http) is required"
     };
   }
-  let path102;
+  let path103;
   if (opts.scope === "user") {
-    path102 = getUserMcpPath();
+    path103 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -63061,9 +63402,9 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path102 = getProjectMcpPath(root);
+    path103 = getProjectMcpPath(root);
   }
-  const current = readFile10(path102);
+  const current = readFile10(path103);
   current[name] = {
     command: hasCommand ? opts.config.command.trim() : void 0,
     args: opts.config.args,
@@ -63074,21 +63415,21 @@ function upsertMcpServer(opts) {
     serial: opts.config.serial,
     enabled: opts.config.enabled !== false
   };
-  writeFile4(path102, current);
-  return { ok: true, path: path102 };
+  writeFile4(path103, current);
+  return { ok: true, path: path103 };
 }
 function removeMcpServer(opts) {
-  const path102 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path102) {
+  const path103 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path103) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile10(path102);
+  const current = readFile10(path103);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path102}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path103}` };
   }
   delete current[opts.name];
-  writeFile4(path102, current);
-  return { ok: true, path: path102 };
+  writeFile4(path103, current);
+  return { ok: true, path: path103 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -63261,15 +63602,15 @@ __export(mcpManager_exports, {
   registerMcpTools: () => registerMcpTools
 });
 import { existsSync as existsSync43, readFileSync as readFileSync31 } from "node:fs";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 function readMcpConfig(projectRoot = process.cwd(), opts) {
   const merged = {};
   const paths = [];
   if (process.env["ZELARI_MCP_USER"] !== "0") {
-    paths.push(join34(zelariHome(), "mcp.json"));
+    paths.push(join35(zelariHome(), "mcp.json"));
   }
   if (!opts?.skipProjectMcp) {
-    paths.push(join34(projectRoot, ".zelari", "mcp.json"));
+    paths.push(join35(projectRoot, ".zelari", "mcp.json"));
   }
   for (const p3 of paths) {
     if (!existsSync43(p3)) continue;
@@ -63290,7 +63631,7 @@ async function ensureLoaded(projectRoot) {
   if (state2.loaded) return;
   state2.loaded = true;
   const trusted = isFolderTrusted(projectRoot);
-  if (!trusted && existsSync43(join34(projectRoot, ".zelari", "mcp.json"))) {
+  if (!trusted && existsSync43(join35(projectRoot, ".zelari", "mcp.json"))) {
     state2.warnings.push(
       "[mcp] project .zelari/mcp.json ignored \u2014 folder not trusted (run /trust or `zelari-code --trust` to enable project MCP)"
     );
@@ -63556,13 +63897,13 @@ __export(agentsMd_exports, {
 });
 import { existsSync as existsSync44, readFileSync as readFileSync32, writeFileSync as writeFileSync20 } from "node:fs";
 import { createHash as createHash24 } from "node:crypto";
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 import { readFile as readFile11 } from "node:fs/promises";
 async function readPackageJson3(projectRoot) {
-  const path102 = join35(projectRoot, "package.json");
-  if (!existsSync44(path102)) return null;
+  const path103 = join36(projectRoot, "package.json");
+  if (!existsSync44(path103)) return null;
   try {
-    return JSON.parse(await readFile11(path102, "utf8"));
+    return JSON.parse(await readFile11(path103, "utf8"));
   } catch {
     return null;
   }
@@ -63584,7 +63925,7 @@ async function genTechStack(ctx) {
   ].join("\n");
 }
 async function genDecisions(ctx) {
-  const decisionsDir = join35(ctx.rootDir, "decisions");
+  const decisionsDir = join36(ctx.rootDir, "decisions");
   if (!existsSync44(decisionsDir)) return "_No ADRs yet._";
   const files = ctx.storage.listMarkdown(decisionsDir).sort();
   const accepted = [];
@@ -63610,7 +63951,7 @@ async function genDecisions(ctx) {
 }
 async function genConventions(ctx) {
   const lines = [];
-  const claudeMd = join35(ctx.projectRoot, "CLAUDE.MD");
+  const claudeMd = join36(ctx.projectRoot, "CLAUDE.MD");
   if (existsSync44(claudeMd)) {
     const content = readFileSync32(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
@@ -63644,9 +63985,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path102 = join35(ctx.rootDir, "risks.md");
-  if (!existsSync44(path102)) return "_No open questions._";
-  const content = readFileSync32(path102, "utf8");
+  const path103 = join36(ctx.rootDir, "risks.md");
+  if (!existsSync44(path103)) return "_No open questions._";
+  const content = readFileSync32(path103, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -63720,7 +64061,7 @@ function titleCase(id3) {
   return id3.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
 }
 async function updateAgentsMd(ctx, projectRoot) {
-  const agentsPath = join35(projectRoot, "AGENTS.MD");
+  const agentsPath = join36(projectRoot, "AGENTS.MD");
   if (existsSync44(agentsPath)) {
     const content = readFileSync32(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id3) => content.includes(MARKER_OPEN(id3)));
@@ -63892,11 +64233,11 @@ var init_completeDesign = __esm({
 
 // src/cli/workspace/planDriftCheck.ts
 import { existsSync as existsSync45, readFileSync as readFileSync33, readdirSync as readdirSync10, statSync as statSync6, writeFileSync as writeFileSync21 } from "node:fs";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 function findCanonicalDoc(rootDir) {
-  const docsDir = join36(rootDir, "docs");
+  const docsDir = join37(rootDir, "docs");
   if (!existsSync45(docsDir)) return null;
-  const candidates = readdirSync10(docsDir).filter((f) => /^plan-canonical.*\.md$/i.test(f)).map((f) => ({ f, mtime: statSync6(join36(docsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const candidates = readdirSync10(docsDir).filter((f) => /^plan-canonical.*\.md$/i.test(f)).map((f) => ({ f, mtime: statSync6(join37(docsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return candidates.length > 0 ? candidates[0].f : null;
 }
 function parseCanonicalDoc(text) {
@@ -63920,9 +64261,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path102) {
+function readFileSyncSafe(path103) {
   try {
-    return readFileSync33(path102, "utf8");
+    return readFileSync33(path103, "utf8");
   } catch {
     return null;
   }
@@ -63931,7 +64272,7 @@ async function runPlanDriftCheck(rootDir) {
   if (process.env["ZELARI_DRIFT_CHECK"] === "0") {
     return { ran: false, reason: "ZELARI_DRIFT_CHECK=0 (disabled)" };
   }
-  const planPath = join36(rootDir, "plan.json");
+  const planPath = join37(rootDir, "plan.json");
   if (!existsSync45(planPath)) {
     return { ran: false, reason: ".zelari/plan.json missing (not design-phase)" };
   }
@@ -63947,7 +64288,7 @@ async function runPlanDriftCheck(rootDir) {
   const milestones = Array.isArray(plan.milestones) ? plan.milestones : [];
   const phaseIds = new Set(phases.map((p3) => typeof p3.id === "string" ? p3.id : "").filter(Boolean));
   const canonicalName = findCanonicalDoc(rootDir);
-  const canonicalText = canonicalName ? readFileSyncSafe(join36(rootDir, "docs", canonicalName)) : null;
+  const canonicalText = canonicalName ? readFileSyncSafe(join37(rootDir, "docs", canonicalName)) : null;
   if (canonicalText !== null) {
     const { activePhases, blockedPrefixes } = parseCanonicalDoc(canonicalText);
     for (const id3 of activePhases) {
@@ -64026,7 +64367,7 @@ async function runPlanDriftCheck(rootDir) {
   const canonicalParsed = canonicalName !== null && canonicalText !== null;
   let reportPath;
   try {
-    reportPath = join36(rootDir, "drift-report.json");
+    reportPath = join37(rootDir, "drift-report.json");
     writeFileSync21(
       reportPath,
       JSON.stringify(
@@ -64064,7 +64405,7 @@ var init_planDriftCheck = __esm({
 // src/cli/workspace/projectSmoke.ts
 import { spawn as spawn15 } from "node:child_process";
 import { existsSync as existsSync46, readFileSync as readFileSync34 } from "node:fs";
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
   for (const name of SMOKE_SCRIPT_PRIORITY) {
@@ -64076,7 +64417,7 @@ async function runProjectSmoke(projectRoot, timeoutMs2 = DEFAULT_TIMEOUT_MS3) {
   if (process.env["ZELARI_SMOKE"] === "0") {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
-  const pkgPath = join37(projectRoot, "package.json");
+  const pkgPath = join38(projectRoot, "package.json");
   if (!existsSync46(pkgPath)) {
     return { ran: false, reason: "no package.json (skipped)" };
   }
@@ -64170,7 +64511,7 @@ __export(evidenceFromSpine_exports, {
   evidenceRefsFromEventLines: () => evidenceRefsFromEventLines
 });
 import { existsSync as existsSync47, readFileSync as readFileSync35 } from "node:fs";
-import path74 from "node:path";
+import path75 from "node:path";
 function asRecord2(v) {
   return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
 }
@@ -64208,7 +64549,7 @@ function evidenceRefsFromEventLines(lines) {
 }
 function collectSessionEvidenceRefs(sessionId2) {
   try {
-    const file2 = path74.join(sessionsDir(), sessionId2, "events.jsonl");
+    const file2 = path75.join(sessionsDir(), sessionId2, "events.jsonl");
     if (!existsSync47(file2)) return [];
     return evidenceRefsFromEventLines(readFileSync35(file2, "utf8").split("\n"));
   } catch {
@@ -64234,7 +64575,7 @@ __export(postCouncilHook_exports, {
 });
 import { spawn as spawn16 } from "node:child_process";
 import { existsSync as existsSync48, readFileSync as readFileSync36 } from "node:fs";
-import { join as join38 } from "node:path";
+import { join as join39 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
     return {
@@ -64245,8 +64586,8 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (process.env["ZELARI_COMPLETE_DESIGN"] === "0") {
     return { ran: false, reason: "ZELARI_COMPLETE_DESIGN=0 (disabled)" };
   }
-  const planJsonPath2 = join38(ctx.rootDir, "plan.json");
-  const scriptPath = join38(ctx.projectRoot, "complete-design.mjs");
+  const planJsonPath2 = join39(ctx.rootDir, "plan.json");
+  const scriptPath = join39(ctx.projectRoot, "complete-design.mjs");
   if (!existsSync48(planJsonPath2)) {
     return {
       ran: false,
@@ -64458,8 +64799,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path102 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path102, completion };
+      const path103 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path103, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -64498,13 +64839,13 @@ __export(councilFeedback_exports, {
   FeedbackStore: () => FeedbackStore
 });
 import {
-  promises as fs32,
+  promises as fs33,
   existsSync as existsSync49,
   readFileSync as readFileSync37,
   writeFileSync as writeFileSync22,
   mkdirSync as mkdirSync18
 } from "node:fs";
-import path75 from "node:path";
+import path76 from "node:path";
 var FeedbackStore;
 var init_councilFeedback = __esm({
   "src/cli/councilFeedback.ts"() {
@@ -64621,7 +64962,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync18(path75.dirname(this.file), { recursive: true });
+        mkdirSync18(path76.dirname(this.file), { recursive: true });
         writeFileSync22(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -64631,7 +64972,7 @@ var init_councilFeedback = __esm({
       /** Async variant of load for callers that prefer async IO. */
       async loadAsync() {
         try {
-          const raw = await fs32.readFile(this.file, "utf-8");
+          const raw = await fs33.readFile(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -64696,12 +65037,12 @@ __export(ledger_exports, {
   readLedger: () => readLedger
 });
 import { appendFileSync as appendFileSync4, existsSync as existsSync50, mkdirSync as mkdirSync19, readFileSync as readFileSync38 } from "node:fs";
-import path76 from "node:path";
+import path77 from "node:path";
 function evolutionMode(env = process.env) {
   return env[EVOLUTION_ENV] === "shadow" ? "shadow" : "0";
 }
 function ledgerPath(cwd) {
-  return path76.join(cwd, LEDGER_REL);
+  return path77.join(cwd, LEDGER_REL);
 }
 function appendLedgerEntry(cwd, entry) {
   if (evolutionMode() === "0") {
@@ -64709,7 +65050,7 @@ function appendLedgerEntry(cwd, entry) {
   }
   try {
     const file2 = ledgerPath(cwd);
-    mkdirSync19(path76.dirname(file2), { recursive: true });
+    mkdirSync19(path77.dirname(file2), { recursive: true });
     appendFileSync4(file2, `${JSON.stringify(entry)}
 `, "utf8");
     return { written: true, path: file2 };
@@ -64810,7 +65151,7 @@ var init_ledger = __esm({
   "src/cli/evolution/ledger.ts"() {
     "use strict";
     EVOLUTION_ENV = "ZELARI_EVOLUTION";
-    LEDGER_REL = path76.join(".zelari", "evolution", "ledger.jsonl");
+    LEDGER_REL = path77.join(".zelari", "evolution", "ledger.jsonl");
     TIER_WEIGHTS = {
       build: 1,
       "tool-output": 1,
@@ -64951,8 +65292,8 @@ __export(fileBackend_exports, {
   isMemoryEnabled: () => isMemoryEnabled
 });
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { promises as fs33 } from "node:fs";
-import * as path77 from "node:path";
+import { promises as fs34 } from "node:fs";
+import * as path78 from "node:path";
 function tokenize2(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -65005,9 +65346,9 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path77.join(projectRoot, ".zelari", "memory");
-        this.logPath = path77.join(this.memoryDir, "log.jsonl");
-        await fs33.mkdir(this.memoryDir, { recursive: true });
+        this.memoryDir = path78.join(projectRoot, ".zelari", "memory");
+        this.logPath = path78.join(this.memoryDir, "log.jsonl");
+        await fs34.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata2 = {}, graph) {
         const fact = {
@@ -65017,7 +65358,7 @@ var init_fileBackend = __esm({
           ...graph ? { graph } : {},
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await fs33.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
+        await fs34.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
         return fact.id;
       }
       async search(query, options = {}) {
@@ -65045,7 +65386,7 @@ var init_fileBackend = __esm({
       async readAll() {
         let raw;
         try {
-          raw = await fs33.readFile(this.logPath, "utf8");
+          raw = await fs34.readFile(this.logPath, "utf8");
         } catch {
           return [];
         }
@@ -65078,23 +65419,23 @@ var init_fileBackend = __esm({
 });
 
 // src/cli/traceStore.ts
-import { promises as fs34 } from "node:fs";
-import * as path78 from "node:path";
+import { promises as fs35 } from "node:fs";
+import * as path79 from "node:path";
 function traceDir(projectRoot) {
-  return path78.join(projectRoot, ".zelari", "trace");
+  return path79.join(projectRoot, ".zelari", "trace");
 }
 function tracePath(projectRoot, missionId) {
-  return path78.join(traceDir(projectRoot), `${missionId}.json`);
+  return path79.join(traceDir(projectRoot), `${missionId}.json`);
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
-  await fs34.mkdir(dir, { recursive: true });
+  await fs35.mkdir(dir, { recursive: true });
   const payload = {
     missionId,
     ts: Date.now(),
     entries
   };
-  await fs34.writeFile(
+  await fs35.writeFile(
     tracePath(projectRoot, missionId),
     JSON.stringify(payload, null, 2) + "\n",
     "utf8"
@@ -65125,8 +65466,8 @@ __export(zelariMission_exports, {
   runZelariMission: () => runZelariMission
 });
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { promises as fs35 } from "node:fs";
-import * as path79 from "node:path";
+import { promises as fs36 } from "node:fs";
+import * as path80 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;
@@ -65169,10 +65510,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state3) {
-  const dir = path79.join(projectRoot, ".zelari");
-  await fs35.mkdir(dir, { recursive: true });
-  await fs35.writeFile(
-    path79.join(dir, "mission-state.json"),
+  const dir = path80.join(projectRoot, ".zelari");
+  await fs36.mkdir(dir, { recursive: true });
+  await fs36.writeFile(
+    path80.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
   );
@@ -65185,8 +65526,8 @@ async function writeMissionState(projectRoot, state3) {
 }
 async function loadMissionState(projectRoot) {
   try {
-    const raw = await fs35.readFile(
-      path79.join(projectRoot, ".zelari", "mission-state.json"),
+    const raw = await fs36.readFile(
+      path80.join(projectRoot, ".zelari", "mission-state.json"),
       "utf8"
     );
     const parsed = JSON.parse(raw);
@@ -65945,7 +66286,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path102 = safeSocketPath(socketPath);
+  const path103 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -66045,10 +66386,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve9, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path102, () => {
+    server.listen(path103, () => {
       server.removeListener("error", onError);
       resolve9({
-        socketPath: path102,
+        socketPath: path103,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -66059,7 +66400,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path102, () => res());
+              unlink(path103, () => res());
             } else {
               res();
             }
@@ -66072,11 +66413,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path102 = safeSocketPath(socketPath);
+  const path103 = 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(path102);
+    const socket = connect(path103);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -66091,7 +66432,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path102}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path103}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -66909,7 +67250,7 @@ __export(prereqChecks_exports, {
 });
 import { execSync, spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync52 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 function isWslBashPath2(p3) {
   if (!p3 || typeof p3 !== "string") return false;
   const n = p3.replace(/\//g, "\\").toLowerCase();
@@ -67015,7 +67356,7 @@ function resolveAgentShellSync() {
 function agentProbeEnv() {
   const env = { ...process.env };
   try {
-    const nodeDir = dirname11(process.execPath);
+    const nodeDir = dirname12(process.execPath);
     if (!nodeDir) return env;
     const sep4 = process.platform === "win32" ? ";" : ":";
     const current = env.PATH ?? env.Path ?? "";
@@ -67280,7 +67621,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 path84 from "node:path";
+import path85 from "node:path";
 function getPluginPrefsPath() {
   return pluginsPrefsPath();
 }
@@ -67303,7 +67644,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync20(path84.dirname(file2), { recursive: true });
+  mkdirSync20(path85.dirname(file2), { recursive: true });
   writeFileSync23(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -67341,7 +67682,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync54 } from "node:fs";
-import path85 from "node:path";
+import path86 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -67359,7 +67700,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" ? path85.win32 : path85.posix;
+  const pathMod = platform === "win32" ? path86.win32 : path86.posix;
   const sep4 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep4).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -68463,11 +68804,11 @@ var init_policy = __esm({
 });
 
 // src/cli/orchestration/facts.ts
-import { promises as fs44 } from "node:fs";
-import path89 from "node:path";
+import { promises as fs45 } from "node:fs";
+import path90 from "node:path";
 async function collectRepoFileCount(root = process.cwd()) {
   try {
-    await fs44.readdir(root);
+    await fs45.readdir(root);
   } catch {
     return void 0;
   }
@@ -68478,13 +68819,13 @@ async function collectRepoFileCount(root = process.cwd()) {
       const dir = queue.pop();
       let entries;
       try {
-        entries = await fs44.readdir(dir, { withFileTypes: true });
+        entries = await fs45.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const e of entries) {
         if (e.isDirectory()) {
-          if (!SKIP_DIRS.has(e.name)) queue.push(path89.join(dir, e.name));
+          if (!SKIP_DIRS.has(e.name)) queue.push(path90.join(dir, e.name));
         } else if (e.isFile()) {
           count++;
           if (count > MAX_WALK_FILES) return count;
@@ -68582,7 +68923,7 @@ var init_streamScrub = __esm({
 });
 
 // src/cli/harnessState.ts
-import path90 from "node:path";
+import path91 from "node:path";
 function asString4(v) {
   return typeof v === "string" ? v : "";
 }
@@ -68757,7 +69098,7 @@ function contractFor(t) {
   };
 }
 async function readHarnessState(sessionDir, cache4) {
-  const report = await readSessionLogCached(path90.join(sessionDir, "events.jsonl"), cache4);
+  const report = await readSessionLogCached(path91.join(sessionDir, "events.jsonl"), cache4);
   return deriveHarnessState(report.events);
 }
 var init_harnessState = __esm({
@@ -68768,12 +69109,12 @@ var init_harnessState = __esm({
 });
 
 // src/cli/headless/harnessStateEmit.ts
-import path91 from "node:path";
+import path92 from "node:path";
 async function emitHarnessStateEvent(opts) {
   if (opts.output !== "json") return;
   try {
     const sessionsDir2 = resolveSessionsDir({ workspaceRoot: opts.workspaceRoot });
-    const state3 = await readHarnessState(path91.join(sessionsDir2, opts.spine.sessionId));
+    const state3 = await readHarnessState(path92.join(sessionsDir2, opts.spine.sessionId));
     opts.emitEvent({ type: "harness_state", ...state3 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -69330,13 +69671,13 @@ var init_verifierLifecycle = __esm({
 
 // src/cli/extensions/sandboxedFs.ts
 import { promises as fsp } from "node:fs";
-import path92 from "node:path";
+import path93 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 = path92.resolve(root);
+  const resolvedRoot = path93.resolve(root);
   return {
     root: resolvedRoot,
     async readFile(relativePath) {
@@ -69352,7 +69693,7 @@ function bindSandboxedFs(root) {
       try {
         const target = resolveSandboxedPath(relativePath, { root: resolvedRoot });
         verifyContainment(target, { root: resolvedRoot });
-        await fsp.mkdir(path92.dirname(target), { recursive: true });
+        await fsp.mkdir(path93.dirname(target), { recursive: true });
         await fsp.writeFile(target, data, "utf8");
         return typedOk({ path: target });
       } catch (err) {
@@ -69379,15 +69720,15 @@ var init_sandboxedFs = __esm({
 });
 
 // src/cli/extensions/loader.ts
-import { join as join44 } from "node:path";
+import { join as join45 } from "node:path";
 import { readdirSync as readdirSync11, readFileSync as readFileSync43 } from "node:fs";
 import { createHash as createHash25 } from "node:crypto";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 function globalExtensionsDir() {
-  return join44(zelariHome(), "extensions");
+  return join45(zelariHome(), "extensions");
 }
 function projectExtensionsDir(projectRoot) {
-  return join44(projectRoot, ".zelari", "extensions");
+  return join45(projectRoot, ".zelari", "extensions");
 }
 function sha256File(file2) {
   return createHash25("sha256").update(readFileSync43(file2)).digest("hex");
@@ -69399,7 +69740,7 @@ function candidateFiles(dir) {
   } catch {
     return [];
   }
-  return names.filter((n) => EXTENSION_FILE_EXTS.has(n.slice(n.lastIndexOf(".")).toLowerCase())).sort().map((n) => join44(dir, n));
+  return names.filter((n) => EXTENSION_FILE_EXTS.has(n.slice(n.lastIndexOf(".")).toLowerCase())).sort().map((n) => join45(dir, n));
 }
 function extractExtension(mod) {
   const m = mod;
@@ -69421,14 +69762,14 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
     skipped
   };
   const fsRoot = options.fsRoot ?? process.cwd();
-  let fs49 = null;
+  let fs50 = null;
   const pending = [];
   for (const dir of dirs) {
     const files = candidateFiles(dir.path);
     if (files.length === 0) continue;
     let lock = null;
     try {
-      lock = JSON.parse(readFileSync43(join44(dir.path, EXTENSIONS_LOCK_FILE), "utf8"));
+      lock = JSON.parse(readFileSync43(join45(dir.path, EXTENSIONS_LOCK_FILE), "utf8"));
     } catch {
       lock = null;
       if (dirHasLockFile(dir.path)) {
@@ -69476,9 +69817,9 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
       skipped.push(`${file2}: missing ZelariExtension export`);
       continue;
     }
-    if (!fs49) fs49 = bindSandboxedFs(fsRoot);
+    if (!fs50) fs50 = bindSandboxedFs(fsRoot);
     try {
-      await runtime.registry.registerExtension(ext, { fs: fs49 });
+      await runtime.registry.registerExtension(ext, { fs: fs50 });
       runtime.loaded.push({ id: ext.id, file: file2, scope });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -69495,7 +69836,7 @@ function basenameOf(file2) {
 }
 function dirHasLockFile(dir) {
   try {
-    readFileSync43(join44(dir, EXTENSIONS_LOCK_FILE));
+    readFileSync43(join45(dir, EXTENSIONS_LOCK_FILE));
     return true;
   } catch {
     return false;
@@ -69536,8 +69877,8 @@ var init_loader = __esm({
 });
 
 // src/cli/headless/runOneTurn.ts
-import { promises as fs45 } from "node:fs";
-import path93 from "node:path";
+import { promises as fs46 } from "node:fs";
+import path94 from "node:path";
 function planModeFromOpts(opts) {
   return (opts.phase ?? "build") === "plan";
 }
@@ -69590,7 +69931,18 @@ async function writeProofSafe(gate, meta3, baseDir = process.cwd()) {
 `
     );
   }
-  await promoteOpsKnowledgeSafe(gate, { projectRoot: baseDir, sessionId: meta3.sessionId });
+  return promoteOpsKnowledgeSafe(gate, { projectRoot: baseDir, sessionId: meta3.sessionId });
+}
+function surfaceOpsKnowledgeNotices(result, opts) {
+  const notices = [
+    ...result.proposals,
+    ...result.checkProposals.map(formatCheckProposalNotice)
+  ];
+  for (const notice of notices) {
+    if (opts.output === "json") emitEvent({ type: "log", message: notice });
+    else process.stderr.write(`[zelari-code --headless] ${notice}
+`);
+  }
 }
 async function runOneTurn(opts, provider, model, providerStream, extras) {
   const sessionId2 = crypto.randomUUID();
@@ -70031,7 +70383,10 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
     if (opts.output === "json") {
       emitEvent({ type: "verification_run", ...verificationPayload });
     }
-    await writeProofSafe(strictGate, { surface: "kraken", sessionId: spine.sessionId }, cwd);
+    surfaceOpsKnowledgeNotices(
+      await writeProofSafe(strictGate, { surface: "kraken", sessionId: spine.sessionId }, cwd),
+      opts
+    );
     if (strictGate.blocked) {
       const repairPrompt = buildKrakenRepairPrompt(gate, repairExcerptsFromEvaluation(strictGate));
       if (opts.output === "json") {
@@ -70065,7 +70420,10 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
       if (opts.output === "json") {
         emitEvent({ type: "verification_run", ...afterPayload });
       }
-      await writeProofSafe(after, { surface: "kraken", sessionId: spine.sessionId }, cwd);
+      surfaceOpsKnowledgeNotices(
+        await writeProofSafe(after, { surface: "kraken", sessionId: spine.sessionId }, cwd),
+        opts
+      );
       if (!after.blocked) markRepairSucceeded();
       else {
         strictExit = strictGateExitCode(after);
@@ -70108,8 +70466,8 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs45.mkdir(path93.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-          await fs45.writeFile(opts.exportSessionPath, json3, "utf8");
+          await fs46.mkdir(path94.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs46.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
     } catch {
@@ -70175,6 +70533,7 @@ var init_runOneTurn = __esm({
     init_completionProof();
     init_completionProofPersist();
     init_opsKnowledge();
+    init_repeatCheck();
     init_nativeVerification();
     init_verifierLifecycle();
     init_modelContextBuilder();
@@ -71157,10 +71516,10 @@ __export(triggerLock_exports, {
   lockPath: () => lockPath,
   releaseLock: () => releaseLock
 });
-import { promises as fs46 } from "node:fs";
-import * as path94 from "node:path";
+import { promises as fs47 } from "node:fs";
+import * as path95 from "node:path";
 function lockPath(projectRoot) {
-  return path94.join(projectRoot, ".zelari", "trigger.lock");
+  return path95.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -71173,10 +71532,10 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path94.dirname(lp);
-  await fs46.mkdir(dir, { recursive: true });
+  const dir = path95.dirname(lp);
+  await fs47.mkdir(dir, { recursive: true });
   try {
-    const raw = await fs46.readFile(lp, "utf8");
+    const raw = await fs47.readFile(lp, "utf8");
     const existing = JSON.parse(raw);
     if (existing.pid && isPidAlive(existing.pid)) {
       return { acquired: false, heldBy: existing.pid, lockPath: lp };
@@ -71187,13 +71546,13 @@ async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date())
     pid: process.pid,
     acquiredAt: now().toISOString()
   };
-  await fs46.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  await fs47.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
   return { acquired: true, lockPath: lp };
 }
 async function releaseLock(projectRoot) {
   const lp = lockPath(projectRoot);
   try {
-    await fs46.unlink(lp);
+    await fs47.unlink(lp);
   } catch {
   }
 }
@@ -71204,8 +71563,8 @@ var init_triggerLock = __esm({
 });
 
 // src/cli/runHeadless.ts
-import { promises as fs47 } from "node:fs";
-import path95 from "node:path";
+import { promises as fs48 } from "node:fs";
+import path96 from "node:path";
 import { randomUUID as randomUUID10 } from "node:crypto";
 async function runHeadless(opts) {
   resetTaskSpawnCount();
@@ -71479,11 +71838,11 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   try {
     let preflightGraph;
     if (opts.runPlan && opts.runPlan.trim() !== "") {
-      const planPath = path95.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      const planPath = path96.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
-        raw = await fs47.readFile(planPath, "utf8");
+        raw = await fs48.readFile(planPath, "utf8");
       } catch (e) {
         log(`plan file not found: ${planPath} (${e.message})`);
         exitCode = 1;
@@ -71522,10 +71881,10 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
       const planId = randomUUID10();
-      const planDir = path95.join(cwd, ".zelari", "radio");
-      const planPath = path95.join(planDir, `plan-${planId}.json`);
-      await fs47.mkdir(planDir, { recursive: true });
-      await fs47.writeFile(
+      const planDir = path96.join(cwd, ".zelari", "radio");
+      const planPath = path96.join(planDir, `plan-${planId}.json`);
+      await fs48.mkdir(planDir, { recursive: true });
+      await fs48.writeFile(
         planPath,
         JSON.stringify(
           { id: graph.id, nodes: [...graph.nodes.values()] },
@@ -71914,8 +72273,8 @@ async function runHeadlessCouncilBody(opts, provider, model, providerStream, ext
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs47.mkdir(path95.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-          await fs47.writeFile(opts.exportSessionPath, json3, "utf8");
+          await fs48.mkdir(path96.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs48.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
     } catch {
@@ -72386,8 +72745,8 @@ ${ragContext}` : slicePrompt;
         if (json3) {
           if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
           else {
-            await fs47.mkdir(path95.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-            await fs47.writeFile(opts.exportSessionPath, json3, "utf8");
+            await fs48.mkdir(path96.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs48.writeFile(opts.exportSessionPath, json3, "utf8");
           }
         }
       } catch {
@@ -72850,7 +73209,7 @@ import {
   rmSync as rmSync4,
   writeFileSync as writeFileSync25
 } from "node:fs";
-import { dirname as dirname13, join as join46 } from "node:path";
+import { dirname as dirname14, join as join47 } from "node:path";
 function ensureBuiltinSkillsLoadedSync() {
   if (builtinsLoaded) return;
   for (const spec of BUILTIN_SKILL_MODULES) {
@@ -72861,13 +73220,13 @@ function ensureBuiltinSkillsLoadedSync() {
   }
 }
 function getUserSkillsDir() {
-  return join46(zelariHome(), "skills");
+  return join47(zelariHome(), "skills");
 }
 function getProjectSkillsDir(projectRoot) {
-  return join46(projectRoot, ".zelari", "skills");
+  return join47(projectRoot, ".zelari", "skills");
 }
 function skillFilePath(dir, name) {
-  return join46(dir, name, "SKILL.md");
+  return join47(dir, name, "SKILL.md");
 }
 function classifyScope(skillPath, projectRoot) {
   const userDir = getUserSkillsDir().replace(/\\/g, "/");
@@ -72943,9 +73302,9 @@ function listSkillsSnapshot(projectRoot) {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
   if (root) {
-    scanSkillsDir(join46(root, ".zelari", "skills"), root, seen, skills);
-    scanSkillsDir(join46(root, ".claude", "skills"), root, seen, skills);
-    scanSkillsDir(join46(root, ".opencode", "skills"), root, seen, skills);
+    scanSkillsDir(join47(root, ".zelari", "skills"), root, seen, skills);
+    scanSkillsDir(join47(root, ".claude", "skills"), root, seen, skills);
+    scanSkillsDir(join47(root, ".opencode", "skills"), root, seen, skills);
   }
   scanSkillsDir(userSkillsDir, root, seen, skills);
   for (const s of listCodingSkills()) {
@@ -73011,7 +73370,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path102 = skillFilePath(dir, name);
+  const path103 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -73020,13 +73379,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path102);
+  const parsed = parseSkillMd(content, path103);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync23(dirname13(path102), { recursive: true });
-  writeFileSync25(path102, content, "utf8");
-  return { ok: true, path: path102 };
+  mkdirSync23(dirname14(path103), { recursive: true });
+  writeFileSync25(path103, content, "utf8");
+  return { ok: true, path: path103 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -73043,9 +73402,9 @@ function removeSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const skillDir = join46(dir, name);
-  const path102 = skillFilePath(dir, name);
-  if (!existsSync59(path102) && !existsSync59(skillDir)) {
+  const skillDir = join47(dir, name);
+  const path103 = skillFilePath(dir, name);
+  if (!existsSync59(path103) && !existsSync59(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -73056,7 +73415,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path102 };
+  return { ok: true, path: path103 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -73177,7 +73536,7 @@ var init_jsonApi = __esm({
 });
 
 // src/cli/memory/mcpAdapter.ts
-import * as path96 from "node:path";
+import * as path97 from "node:path";
 var id2, projectId, source, SearchSchema, AddSchema, LinkSchema, RetractSchema, MEMORY_MCP_TOOLS, MemoryMcpAdapter;
 var init_mcpAdapter = __esm({
   "src/cli/memory/mcpAdapter.ts"() {
@@ -73347,8 +73706,8 @@ var init_mcpAdapter = __esm({
         this.takeWrite();
         const externalFile = args.source?.file;
         if (externalFile) {
-          const normalized = path96.normalize(externalFile);
-          if (path96.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path96.sep}`)) {
+          const normalized = path97.normalize(externalFile);
+          if (path97.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path97.sep}`)) {
             throw new Error("source.file must be project-relative and cannot escape the project");
           }
         }
@@ -73857,16 +74216,16 @@ import {
   readFileSync as readFileSync45,
   writeFileSync as writeFileSync26
 } from "node:fs";
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 import { createHash as createHash26, randomBytes as randomBytes7, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
   return zelariHome();
 }
 function getCompanionConfigPath() {
-  return join47(getZelariHome(), "companion.json");
+  return join48(getZelariHome(), "companion.json");
 }
 function getCompanionTokenPath() {
-  return join47(getZelariHome(), "companion.token");
+  return join48(getZelariHome(), "companion.token");
 }
 function ensureHome() {
   const home = getZelariHome();
@@ -73875,12 +74234,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path102 = getCompanionConfigPath();
-  if (!existsSync60(path102)) {
+  const path103 = getCompanionConfigPath();
+  if (!existsSync60(path103)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync45(path102, "utf8"));
+    const raw = JSON.parse(readFileSync45(path103, "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) => ({
@@ -73918,16 +74277,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path102 = getCompanionTokenPath();
-  if (existsSync60(path102)) {
-    const t = readFileSync45(path102, "utf8").trim();
+  const path103 = getCompanionTokenPath();
+  if (existsSync60(path103)) {
+    const t = readFileSync45(path103, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes7(24).toString("base64url");
-  writeFileSync26(path102, token + "\n", "utf8");
+  writeFileSync26(path103, token + "\n", "utf8");
   try {
-    const fs49 = __require("node:fs");
-    fs49.chmodSync?.(path102, 384);
+    const fs50 = __require("node:fs");
+    fs50.chmodSync?.(path103, 384);
   } catch {
   }
   return { token, created: true };
@@ -73952,17 +74311,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path102 = raw.trim();
-    if (!path102) continue;
-    let id3 = slugFromPath(path102);
+    const path103 = raw.trim();
+    if (!path103) continue;
+    let id3 = slugFromPath(path103);
     let n = 2;
-    while (byId.has(id3) && byId.get(id3).path !== path102) {
-      id3 = `${slugFromPath(path102)}-${n++}`;
+    while (byId.has(id3) && byId.get(id3).path !== path103) {
+      id3 = `${slugFromPath(path103)}-${n++}`;
     }
     byId.set(id3, {
       id: id3,
-      name: slugFromPath(path102),
-      path: path102
+      name: slugFromPath(path103),
+      path: path103
     });
   }
   return [...byId.values()];
@@ -74204,8 +74563,8 @@ var init_askUserBridge = __esm({
 });
 
 // src/cli/serve/spineLockSweep.ts
-import { promises as fs48 } from "node:fs";
-import path97 from "node:path";
+import { promises as fs49 } from "node:fs";
+import path98 from "node:path";
 async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
   const dir = sessionsDir2 ?? resolveSessionsDir();
   const onSwept = options.onSwept ?? ((sessionId2, reason) => {
@@ -74218,14 +74577,14 @@ async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
   const result = { swept: 0, kept: 0, errors: 0 };
   let entries;
   try {
-    entries = await fs48.readdir(dir);
+    entries = await fs49.readdir(dir);
   } catch {
     return result;
   }
   for (const sessionId2 of entries) {
-    const lockPath2 = path97.join(dir, sessionId2, "writer.lock");
+    const lockPath2 = path98.join(dir, sessionId2, "writer.lock");
     try {
-      const raw = await fs48.readFile(lockPath2, "utf-8");
+      const raw = await fs49.readFile(lockPath2, "utf-8");
       let lockInfo = {};
       try {
         lockInfo = JSON.parse(raw);
@@ -74242,7 +74601,7 @@ async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
         result.kept += 1;
         continue;
       }
-      await fs48.rm(lockPath2, { force: true });
+      await fs49.rm(lockPath2, { force: true });
       result.swept += 1;
       onSwept(sessionId2, verdict.reason);
     } catch (err) {
@@ -74676,7 +75035,7 @@ import { spawn as spawn18 } from "node:child_process";
 import { createInterface as createInterface4 } from "node:readline";
 import { randomUUID as randomUUID13 } from "node:crypto";
 import { writeFileSync as writeFileSync27, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join48 } from "node:path";
+import { join as join49 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 function harnessServerMode() {
   return process.env[HARNESS_SERVER_ENV] === "1";
@@ -74798,7 +75157,7 @@ var init_runManager = __esm({
         }
         let historyFile;
         if (args.history && Array.isArray(args.history) && args.history.length > 0) {
-          historyFile = join48(tmpdir4(), `zelari-companion-hist-${id3}.json`);
+          historyFile = join49(tmpdir4(), `zelari-companion-hist-${id3}.json`);
           try {
             writeFileSync27(historyFile, JSON.stringify(args.history), "utf8");
             argv.push("--history-file", historyFile);
@@ -75221,9 +75580,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path102 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path103 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path102 === "/health" || path102 === "/v1/health")) {
+      if (req.method === "GET" && (path103 === "/health" || path103 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -75235,18 +75594,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path102.startsWith("/v1")) {
+      if (path103.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path102 === "/v1/config") {
+      if (req.method === "GET" && path103 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path102 === "/v1/projects") {
+      if (req.method === "GET" && path103 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -75257,7 +75616,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path102 === "/v1/runs") {
+      if (req.method === "GET" && path103 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -75275,7 +75634,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path102 === "/v1/runs") {
+      if (req.method === "POST" && path103 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -75323,7 +75682,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path102);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path103);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -75388,7 +75747,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path102);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path103);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -75399,7 +75758,7 @@ async function runCompanionServe(opts = {}) {
         sendJson2(res, 200, { ok: true, cancelled: runId });
         return;
       }
-      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path102);
+      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path103);
       if (req.method === "POST" && steerMatch) {
         const runId = steerMatch[1];
         const raw = await readBody(req);
@@ -75568,11 +75927,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 path98 from "node:path";
+import path99 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path98.join(dir, "package.json");
+    const candidate = path99.join(dir, "package.json");
     if (existsSync62(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync46(candidate, "utf8"));
@@ -75580,11 +75939,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path98.dirname(dir);
+    const parent = path99.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path98.resolve(__dirname3, "..", "..", "..");
+  return path99.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -75598,7 +75957,7 @@ function tryExec(cmd) {
 }
 function readPackageJson4() {
   try {
-    const pkgPath = path98.join(packageRoot, "package.json");
+    const pkgPath = path99.join(packageRoot, "package.json");
     return JSON.parse(readFileSync46(pkgPath, "utf8"));
   } catch {
     return null;
@@ -75610,7 +75969,7 @@ function getGlobalPrefix() {
   return (process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || "").trim();
 }
 function isSourceCheckout() {
-  return existsSync62(path98.join(packageRoot, "src", "cli", "main.ts")) && existsSync62(path98.join(packageRoot, "apps", "desktop", "package.json"));
+  return existsSync62(path99.join(packageRoot, "src", "cli", "main.ts")) && existsSync62(path99.join(packageRoot, "apps", "desktop", "package.json"));
 }
 function checkShim(pkgName) {
   const prefix = getGlobalPrefix();
@@ -75619,9 +75978,9 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path98.join(prefix, shimName);
+  const shimPath = path99.join(prefix, shimName);
   if (!existsSync62(shimPath)) {
-    const localBin = path98.join(packageRoot, "bin", "zelari-code.js");
+    const localBin = path99.join(packageRoot, "bin", "zelari-code.js");
     if (isSourceCheckout() && existsSync62(localBin)) {
       return WARN(
         `global shim not found at ${shimPath}
@@ -75655,8 +76014,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path98.resolve(path98.dirname(shimPath), target);
-    const expected = path98.join(
+    const resolved = path99.resolve(path99.dirname(shimPath), target);
+    const expected = path99.join(
       prefix,
       "node_modules",
       pkgName,
@@ -75698,7 +76057,7 @@ function checkNode(pkg) {
   return OK(`node ${raw} (engines.node ${enginesNode ?? ">= 20.0.0"})`);
 }
 function checkBundle() {
-  const bundle = path98.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path99.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync62(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -75719,7 +76078,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path98.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path99.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -75996,7 +76355,7 @@ var init_doctor = __esm({
     init_metrics3();
     init_contextGrowthSummary();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path98.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path99.dirname(fileURLToPath3(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -76105,7 +76464,7 @@ __export(userSettings_exports, {
   settingsOverrides: () => settingsOverrides
 });
 import { existsSync as existsSync63, readFileSync as readFileSync47 } from "node:fs";
-import path99 from "node:path";
+import path100 from "node:path";
 function parseBool(raw) {
   const v = raw.trim().toLowerCase();
   if (["1", "true", "yes", "on"].includes(v)) return true;
@@ -76172,8 +76531,8 @@ function envValueFor(key, env) {
 function resolveUserSettings(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const env = opts.env ?? process.env;
-  const userPath = path99.join(zelariHome(), SETTINGS_FILE_NAME);
-  const projectPath = path99.join(cwd, ".zelari", SETTINGS_FILE_NAME);
+  const userPath = path100.join(zelariHome(), SETTINGS_FILE_NAME);
+  const projectPath = path100.join(cwd, ".zelari", SETTINGS_FILE_NAME);
   const warnings = [];
   const userLayer = loadFileLayer(userPath, "user", warnings);
   const projectLayer = loadFileLayer(projectPath, "project", warnings);
@@ -76387,7 +76746,7 @@ __export(inspectSession_exports, {
   renderInspectReport: () => renderInspectReport,
   runInspectSession: () => runInspectSession
 });
-import path100 from "node:path";
+import path101 from "node:path";
 import { existsSync as existsSync64 } from "node:fs";
 function formatLimit(limit) {
   return `${Math.round(limit / 1e3)}k`;
@@ -76421,8 +76780,8 @@ function renderInspectReport(state3) {
 }
 async function runInspectSession(opts) {
   const sessionsDir2 = resolveSessionsDir({ workspaceRoot: opts.cwd ?? process.cwd() });
-  const sessionDir = path100.join(sessionsDir2, opts.sessionId);
-  const eventsPath = path100.join(sessionDir, "events.jsonl");
+  const sessionDir = path101.join(sessionsDir2, opts.sessionId);
+  const eventsPath = path101.join(sessionDir, "events.jsonl");
   if (!existsSync64(sessionDir)) {
     console.error(`zelari-code inspect: no session directory at ${sessionDir}`);
     return 1;
@@ -76456,14 +76815,14 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path101 from "node:path";
+import path102 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 = path101.join(zelariHome(), "mcp.json");
-  const projectMcpPath = path101.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path102.join(zelariHome(), "mcp.json");
+  const projectMcpPath = path102.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -76491,9 +76850,9 @@ async function collectInspectReport(cwd = process.cwd()) {
     configSources: [
       { path: userMcpPath, exists: existsSync65(userMcpPath) },
       { path: projectMcpPath, exists: existsSync65(projectMcpPath) },
-      { 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")) }
+      { path: path102.join(zelariHome(), "provider.json"), exists: existsSync65(path102.join(zelariHome(), "provider.json")) },
+      { path: path102.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync65(path102.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path102.join(cwd, "AGENTS.md"), exists: existsSync65(path102.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -76533,8 +76892,8 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path101.join(cwd, "AGENTS.md"),
-    path101.join(cwd, ".zelari", "AGENTS.md")
+    path102.join(cwd, "AGENTS.md"),
+    path102.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
@@ -79566,6 +79925,7 @@ init_completionGate();
 init_verificationBridge();
 init_completionProof();
 init_opsKnowledge();
+init_repeatCheck();
 init_verifyStatus();
 init_nativeVerification();
 init_spineTelemetry();
@@ -80199,10 +80559,17 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
                   () => void 0,
                   () => void 0
                 );
-                await promoteOpsKnowledgeSafe(gate, {
+                const opsKnowledge = await promoteOpsKnowledgeSafe(gate, {
                   projectRoot: process.cwd(),
                   sessionId: sessionId2
                 });
+                const notices = [
+                  ...opsKnowledge.proposals,
+                  ...opsKnowledge.checkProposals.map(formatCheckProposalNotice)
+                ];
+                if (notices.length > 0) {
+                  appendSystem(setMessages, notices.join("\n"), Date.now());
+                }
               };
               if (event.reason === "completed" && !krakenRepairEnqueued && (isKrakenSelectionEnabled() || nativePackEnabled()) && workPhase === "build") {
                 const strictGate = await evaluateStrictBuildGate("build", { emit: krakenSpineEmit });
@@ -81741,10 +82108,10 @@ init_ledger();
 
 // src/cli/evolution/proposals.ts
 import { existsSync as existsSync51, readFileSync as readFileSync39 } from "node:fs";
-import path80 from "node:path";
-var PROPOSALS_REL = path80.join(".zelari", "evolution", "proposals.jsonl");
+import path81 from "node:path";
+var PROPOSALS_REL = path81.join(".zelari", "evolution", "proposals.jsonl");
 function proposalsPath(cwd) {
-  return path80.join(cwd, PROPOSALS_REL);
+  return path81.join(cwd, PROPOSALS_REL);
 }
 function readProposalStore(cwd) {
   const file2 = proposalsPath(cwd);
@@ -82868,9 +83235,12 @@ function handleCacheStats(ctx) {
 // src/cli/slashHandlers/memory.ts
 init_messageHelpers();
 init_serviceFactory();
+init_howWeTest();
 init_promotion();
-import { promises as fs36 } from "node:fs";
-import * as path81 from "node:path";
+init_repeatCheck();
+init_worldModel();
+import { promises as fs37 } from "node:fs";
+import * as path82 from "node:path";
 var USAGE = [
   "/memory \u2014 backend summary",
   "/memory search <query>",
@@ -82882,6 +83252,8 @@ var USAGE = [
   "/memory consolidate [query]",
   "/memory index [--force]",
   "/memory promote <id> \u2014 append durable knowledge to managed AGENTS.md section",
+  '/memory promote con-<fp> --as-check --command "<cmd>" [--expect-exit N] \u2014 append a WorldCheck',
+  "/memory how-we-test \u2014 regenerate .zelari/how-we-test.md from verified procedures",
   "/memory stats | doctor | export [project-relative-path]",
   "/memory audit \u2014 read-only decay + contradiction report (nothing is mutated)"
 ].join("\n  ");
@@ -82894,24 +83266,24 @@ function sourceLine(source2) {
   return entries.length ? entries.map(([key, value]) => `${key}=${value}`).join(" \xB7 ") : "unknown";
 }
 function isInside(root, target) {
-  const relative6 = path81.relative(root, target);
-  return relative6 === "" || !relative6.startsWith("..") && !path81.isAbsolute(relative6);
+  const relative6 = path82.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path82.isAbsolute(relative6);
 }
 async function safeExportPath(cwd, requested) {
-  const lexicalRoot = path81.resolve(cwd);
-  const root = await fs36.realpath(lexicalRoot).catch(() => lexicalRoot);
-  const fallback = path81.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
-  const target = requested?.trim() ? path81.resolve(root, requested.trim()) : fallback;
+  const lexicalRoot = path82.resolve(cwd);
+  const root = await fs37.realpath(lexicalRoot).catch(() => lexicalRoot);
+  const fallback = path82.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
+  const target = requested?.trim() ? path82.resolve(root, requested.trim()) : fallback;
   if (!isInside(root, target)) {
     throw new Error("Export path must stay inside the active project.");
   }
-  const parent = path81.dirname(target);
-  const relativeParent = path81.relative(root, parent);
+  const parent = path82.dirname(target);
+  const relativeParent = path82.relative(root, parent);
   let cursor = root;
-  for (const segment of relativeParent.split(path81.sep).filter(Boolean)) {
-    cursor = path81.join(cursor, segment);
+  for (const segment of relativeParent.split(path82.sep).filter(Boolean)) {
+    cursor = path82.join(cursor, segment);
     try {
-      const stat8 = await fs36.lstat(cursor);
+      const stat8 = await fs37.lstat(cursor);
       if (stat8.isSymbolicLink()) {
         throw new Error("Export path must not traverse a symbolic link.");
       }
@@ -82921,7 +83293,7 @@ async function safeExportPath(cwd, requested) {
     }
   }
   try {
-    if ((await fs36.lstat(target)).isSymbolicLink()) {
+    if ((await fs37.lstat(target)).isSymbolicLink()) {
       throw new Error("Export target must not be a symbolic link.");
     }
   } catch (error51) {
@@ -83058,10 +83430,21 @@ ${message}` : message
         );
         return;
       }
+      case "how-we-test": {
+        const result = await regenerateHowWeTest(memory, ctx.cwd);
+        emit(result.written ? `[memory] how-we-test written to ${result.path} (${result.rows} procedure(s))` : `[memory] how-we-test not written: ${result.reason ?? "nothing to project"}.`);
+        return;
+      }
       case "promote": {
-        const memoryId = args[0];
+        const parsed = parsePromoteArgs(args);
+        if (parsed.error) {
+          emit(`[memory] ${parsed.error}
+  ${PROMOTE_USAGE}`);
+          return;
+        }
+        const memoryId = parsed.id;
         if (!memoryId) {
-          emit("Usage: /memory promote <id>");
+          emit(PROMOTE_USAGE);
           return;
         }
         const node = await memory.get(memoryId);
@@ -83069,6 +83452,26 @@ ${message}` : message
           emit(`[memory] ${memoryId} not found in this project.`);
           return;
         }
+        if (parsed.asCheck) {
+          const constraint = constraintFromNode(node);
+          if (!constraint) {
+            emit(`[memory] ${memoryId} is not a repeat-failure constraint (no fingerprint/command/digest) \u2014 nothing to turn into a check.`);
+            return;
+          }
+          const nodes = await listVerifiedProcedureNodes(memory);
+          const proposal = proposalFromConstraint(constraint, nodes ?? []);
+          const check2 = confirmCheck(proposal, {
+            command: parsed.command,
+            ...parsed.expectExit === void 0 ? {} : { expectExit: parsed.expectExit }
+          });
+          if (!check2) {
+            emit(checkConfirmationHint(proposal));
+            return;
+          }
+          const appended = await appendWorldCheck(ctx.cwd, check2);
+          emit(appended.added ? `[memory] check \u201C${check2.id}\u201D appended to ${appended.path} (${appended.count} check(s))` : `[memory] check \u201C${check2.id}\u201D already present in ${appended.path} \u2014 file untouched.`);
+          return;
+        }
         const promoted = await promoteMemoryToAgentsMd(ctx.cwd, node);
         emit(promoted.added ? `[memory] promoted ${memoryId} to ${promoted.path}` : `[memory] ${memoryId} not promoted: ${promoted.reason ?? "policy rejected it"}.`);
         return;
@@ -83081,13 +83484,13 @@ ${message}` : message
       }
       case "export": {
         const target = await safeExportPath(ctx.cwd, args.join(" ").trim() || void 0);
-        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));
+        await fs37.mkdir(path82.dirname(target), { recursive: true });
+        const root = await fs37.realpath(ctx.cwd).catch(() => path82.resolve(ctx.cwd));
+        const realParent = await fs37.realpath(path82.dirname(target));
         if (!isInside(root, realParent)) {
           throw new Error("Export path resolves outside the active project.");
         }
-        await fs36.writeFile(target, JSON.stringify(await memory.export(), null, 2) + "\n", "utf8");
+        await fs37.writeFile(target, JSON.stringify(await memory.export(), null, 2) + "\n", "utf8");
         emit(`[memory] export written to ${target}`);
         return;
       }
@@ -83329,13 +83732,13 @@ ${digest}
 init_auditLogger();
 init_toolRegistry();
 init_messageHelpers();
-import { promises as fs38 } from "node:fs";
+import { promises as fs39 } from "node:fs";
 
 // src/cli/tools/krakenCsvFanout.ts
 init_zod();
 init_taskTool();
-import { promises as fs37 } from "node:fs";
-import path82 from "node:path";
+import { promises as fs38 } from "node:fs";
+import path83 from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
@@ -83356,7 +83759,7 @@ var CsvFanoutArgsSchema = external_exports.object({
   max_runtime_seconds: external_exports.number().int().positive().optional()
 });
 async function readCsv(filePath) {
-  const text = await fs37.readFile(filePath, "utf8");
+  const text = await fs38.readFile(filePath, "utf8");
   return parseCsv(text);
 }
 function parseCsv(text) {
@@ -83429,8 +83832,8 @@ function resolveMaxConcurrency(env = process.env) {
 }
 async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
-  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 absCsv = path83.isAbsolute(args.csv_path) ? args.csv_path : path83.join(opts.parentCwd, args.csv_path);
+  const absOut = path83.isAbsolute(args.output_csv_path) ? args.output_csv_path : path83.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`);
@@ -83486,7 +83889,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs37.mkdir(path82.dirname(absOut), { recursive: true });
+      await fs38.mkdir(path83.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -83508,8 +83911,8 @@ async function runCsvFanout(args, deps, opts) {
 }
 async function atomicWrite(file2, contents) {
   const tmp = `${file2}.${process.pid}.${Date.now()}.${randomBytes6(6).toString("hex")}.tmp`;
-  await fs37.writeFile(tmp, contents, "utf8");
-  await fs37.rename(tmp, file2);
+  await fs38.writeFile(tmp, contents, "utf8");
+  await fs38.rename(tmp, file2);
 }
 
 // src/cli/slashHandlers/krakenFanout.ts
@@ -83607,7 +84010,7 @@ async function handleKrakenFanout(ctx, raw) {
   }
   const absCsv = isAbsolute3(parsed.args.csv_path) ? parsed.args.csv_path : joinPath(ctx.cwd, parsed.args.csv_path);
   try {
-    await fs38.access(absCsv);
+    await fs39.access(absCsv);
   } catch {
     appendSystem(ctx.setMessages, `[kraken fanout] source CSV not found: ${absCsv}`);
     return;
@@ -83680,8 +84083,8 @@ function splitArgs(s) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
-import { promises as fs39 } from "node:fs";
-import path83 from "node:path";
+import { promises as fs40 } from "node:fs";
+import path84 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
 var EMPTY = {
@@ -83798,15 +84201,15 @@ function formatWorkbenchForTerminal(p3) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 async function handleKrakenWorkbench(ctx) {
-  const dir = path83.join(ctx.cwd, ".zelari", "radio");
+  const dir = path84.join(ctx.cwd, ".zelari", "radio");
   let latest = null;
   let latestMtime = 0;
   try {
-    const files = await fs39.readdir(dir);
+    const files = await fs40.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
-      const full = path83.join(dir, f);
-      const stat8 = await fs39.stat(full);
+      const full = path84.join(dir, f);
+      const stat8 = await fs40.stat(full);
       if (stat8.mtimeMs > latestMtime) {
         latestMtime = stat8.mtimeMs;
         latest = full;
@@ -83818,14 +84221,14 @@ async function handleKrakenWorkbench(ctx) {
     appendSystem(ctx.setMessages, "[kraken workbench] no workbench file found (.zelari/radio/workbench-*.md)");
     return;
   }
-  const content = await fs39.readFile(latest, "utf8");
+  const content = await fs40.readFile(latest, "utf8");
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
-    appendSystem(ctx.setMessages, `[kraken workbench] ${path83.basename(latest)}: (no nodes / no events yet)`);
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path84.basename(latest)}: (no nodes / no events yet)`);
     return;
   }
-  appendSystem(ctx.setMessages, `[kraken workbench] ${path83.basename(latest)}:
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path84.basename(latest)}:
 ${rendered}`);
 }
 
@@ -84132,20 +84535,20 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 // src/cli/slashHandlers/promoteMember.ts
 init_messageHelpers();
 init_paths();
-import { promises as fs40 } from "node:fs";
-import path86 from "node:path";
+import { promises as fs41 } from "node:fs";
+import path87 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 = path86.join(skillDir, `${skill.id}.md`);
-    const previous = await fs40.readFile(filePath, "utf8").catch(() => null);
+    await fs41.mkdir(skillDir, { recursive: true });
+    const filePath = path87.join(skillDir, `${skill.id}.md`);
+    const previous = await fs41.readFile(filePath, "utf8").catch(() => null);
     const { createHash: createHash27 } = await import("node:crypto");
     const sha = (s) => createHash27("sha256").update(s, "utf8").digest("hex");
     const lineage = `<!-- lineage: genome=sha256:${sha(markdown)} parent=${previous ? `sha256:${sha(previous)}` : "none"} promotedBy=user promotedAt=${(/* @__PURE__ */ new Date()).toISOString()} -->`;
-    await fs40.writeFile(filePath, `${markdown}
+    await fs41.writeFile(filePath, `${markdown}
 ${lineage}
 `, "utf8");
     appendSystem(
@@ -84165,8 +84568,8 @@ ${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 path87 from "node:path";
+import { promises as fs42, existsSync as existsSync55, readFileSync as readFileSync41, writeFileSync as writeFileSync24, mkdirSync as mkdirSync21, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
+import path88 from "node:path";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
@@ -84176,13 +84579,13 @@ function getSessionsBaseDir() {
   return sessionsDir();
 }
 function branchPathFor(name, baseDir) {
-  return path87.join(baseDir, name);
+  return path88.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path87.join(baseDir, name, META_FILENAME);
+  return path88.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path87.join(baseDir, name, SESSIONS_SUBDIR);
+  return path88.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -84207,13 +84610,13 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync21(path87.dirname(metaPath), { recursive: true });
+  mkdirSync21(path88.dirname(metaPath), { recursive: true });
   writeFileSync24(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
   try {
-    const entries = await fs41.readdir(sessionsPath);
+    const entries = await fs42.readdir(sessionsPath);
     return entries.filter((e) => e.endsWith(".jsonl")).length;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
@@ -84258,15 +84661,15 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path87.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path88.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 = path87.join(branchSessionsPath, `${fromSessionId}.jsonl`);
-  await fs41.copyFile(sourcePath, destPath);
+  const destPath = path88.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  await fs42.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
     createdAt: Date.now(),
@@ -84284,7 +84687,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
 async function listBranches(baseDir = getBranchesBaseDir()) {
   let entries;
   try {
-    entries = await fs41.readdir(baseDir);
+    entries = await fs42.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -84368,26 +84771,26 @@ async function handleBranchCheckout(ctx, branchName) {
 
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
-import { promises as fs42 } from "node:fs";
-import path88 from "node:path";
+import { promises as fs43 } from "node:fs";
+import path89 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path88.join(process.cwd(), ".zelari");
+    const zelari = path89.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path88.join(zelari, "plan.md");
+        const planPath = path89.join(zelari, "plan.md");
         try {
-          content = await fs42.readFile(planPath, "utf-8");
+          content = await fs43.readFile(planPath, "utf-8");
         } catch {
           content = "(no plan.md yet \u2014 run a council session first)";
         }
         break;
       }
       case "decisions": {
-        const decisionsDir = path88.join(zelari, "decisions");
+        const decisionsDir = path89.join(zelari, "decisions");
         try {
-          const files = (await fs42.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs43.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
             content = "(no ADRs yet \u2014 invoke /council to generate some)";
           } else {
@@ -84395,7 +84798,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(path88.join(decisionsDir, f), "utf-8");
+              const raw = await fs43.readFile(path89.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}`);
@@ -84408,27 +84811,27 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path88.join(zelari, "risks.md");
+        const risksPath = path89.join(zelari, "risks.md");
         try {
-          content = await fs42.readFile(risksPath, "utf-8");
+          content = await fs43.readFile(risksPath, "utf-8");
         } catch {
           content = "(no risks.md yet)";
         }
         break;
       }
       case "agents": {
-        const agentsPath = path88.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path89.join(process.cwd(), "AGENTS.MD");
         try {
-          content = await fs42.readFile(agentsPath, "utf-8");
+          content = await fs43.readFile(agentsPath, "utf-8");
         } catch {
           content = "(no AGENTS.MD yet at project root \u2014 run `/workspace sync` after a council session)";
         }
         break;
       }
       case "docs": {
-        const docsDir = path88.join(zelari, "docs");
+        const docsDir = path89.join(zelari, "docs");
         try {
-          const files = (await fs42.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs43.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
 
 ` + files.map((f) => `- ${f}`).join("\n") : "(no docs drafts yet)";
@@ -84468,8 +84871,8 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path88.join(process.cwd(), ".zelari");
-    await fs42.rm(target, { recursive: true, force: true });
+    const target = path89.join(process.cwd(), ".zelari");
+    await fs43.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
     appendSystem(ctx.setMessages, `[workspace reset error] ${err instanceof Error ? err.message : String(err)}`);
@@ -84480,13 +84883,13 @@ async function handleWorkspaceReset(ctx, force) {
 init_provider2();
 
 // src/cli/skillHistory.ts
-import { promises as fs43, existsSync as existsSync56, statSync as statSync8, renameSync as renameSync6, appendFileSync as appendFileSync5, mkdirSync as mkdirSync22 } from "node:fs";
+import { promises as fs44, existsSync as existsSync56, statSync as statSync8, renameSync as renameSync6, appendFileSync as appendFileSync5, mkdirSync as mkdirSync22 } from "node:fs";
 init_paths();
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
   try {
-    raw = await fs43.readFile(file2, "utf-8");
+    raw = await fs44.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -86366,8 +86769,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 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";
+      const path103 = 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 = path103 && /^[a-z0-9]/.test(path103) ? path103 : "imported-skill";
     } catch {
       name = "imported-skill";
     }