zelari-code 2.24.0 → 2.25.0

package/dist/cli/main.bundled.js

@@ -3288,10 +3288,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path93) {
-  if (!path93)
+function getElementAtPath(obj, path94) {
+  if (!path94)
     return obj;
-  return path93.reduce((acc, key) => acc?.[key], obj);
+  return path94.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3619,11 +3619,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path93, issues) {
+function prefixIssues(path94, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path93);
+    iss.path.unshift(path94);
     return iss;
   });
 }
@@ -3841,16 +3841,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path93 = []) => {
+  const processError = (error52, path94 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path93, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path94, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path93, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path94, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path93, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path94, ...issue2.path]);
       } else {
-        const fullpath = [...path93, ...issue2.path];
+        const fullpath = [...path94, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -3877,17 +3877,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path93 = []) => {
+  const processError = (error52, path94 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path93, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path94, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path93, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path94, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path93, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path94, ...issue2.path]);
       } else {
-        const fullpath = [...path93, ...issue2.path];
+        const fullpath = [...path94, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -3919,8 +3919,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path93 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path93) {
+  const path94 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path94) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17423,13 +17423,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path93 = ref.slice(1).split("/").filter(Boolean);
-  if (path93.length === 0) {
+  const path94 = ref.slice(1).split("/").filter(Boolean);
+  if (path94.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path93[0] === defsKey) {
-    const key = path93[1];
+  if (path94[0] === defsKey) {
+    const key = path94[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18260,6 +18260,37 @@ var init_newlines = __esm({
   }
 });
 
+// packages/core/dist/core/tools/builtin/fileEvents.js
+function fileReadEvent(path94, snapshotId) {
+  return { kind: "file.read", actor: { type: "tool" }, data: { path: path94, snapshotId } };
+}
+function fileAppliedEvent(path94, snapshotId, bytes) {
+  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path94, snapshotId, bytes } };
+}
+function fileRejectedEvent(path94, reason, hint) {
+  return {
+    kind: "file.rejected",
+    actor: { type: "tool" },
+    data: hint === void 0 ? { path: path94, reason } : { path: path94, reason, hint }
+  };
+}
+function reReadHint(reject) {
+  return `re-read ${reject.next.path}, then retry with the fresh snapshotId`;
+}
+async function emitFileEvent(emit, input) {
+  if (!emit)
+    return;
+  try {
+    await emit(input);
+  } catch {
+  }
+}
+var init_fileEvents = __esm({
+  "packages/core/dist/core/tools/builtin/fileEvents.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/core/tools/builtin/filesystem.js
 import { createHash as createHash2 } from "node:crypto";
 import { promises as fs4 } from "node:fs";
@@ -18267,6 +18298,19 @@ import path6 from "node:path";
 function snapshotIdOf(content) {
   return createHash2("sha256").update(content, "utf8").digest("hex").slice(0, 16);
 }
+function fileExistsMinimalDiff(existing, incoming, pathLabel) {
+  const EXISTING_HEAD_LINES = 10;
+  const MAX_BODY_LINES = 40;
+  const oldHead = splitLinesLF(existing).slice(0, EXISTING_HEAD_LINES);
+  const newHead = splitLinesLF(incoming).slice(0, MAX_BODY_LINES - oldHead.length);
+  return [
+    `--- ${pathLabel}`,
+    `+++ ${pathLabel}`,
+    `@@ -1,${oldHead.length} +1,${newHead.length} @@`,
+    ...oldHead.map((l) => `-${l}`),
+    ...newHead.map((l) => `+${l}`)
+  ].join("\n");
+}
 function replaceFileString(text, oldString, newString, replaceAll) {
   const exact = replaceOnceOrAll(text, oldString, newString, replaceAll);
   if (exact.occurrences > 0)
@@ -18299,6 +18343,7 @@ var init_filesystem = __esm({
     init_zod();
     init_toolTypes();
     init_newlines();
+    init_fileEvents();
     ReadFileArgsSchema = external_exports.object({
       path: external_exports.string().min(1),
       startLine: external_exports.number().int().nonnegative().optional().describe("0-based first line to include. Range is applied to the full file before maxBytes."),
@@ -18318,6 +18363,7 @@ var init_filesystem = __esm({
           const buf = await fs4.readFile(absPath, { encoding: "utf-8", signal: ctx.signal });
           const content = typeof buf === "string" ? buf : buf.toString("utf-8");
           const snapshotId = snapshotIdOf(content);
+          await emitFileEvent(ctx.emitSessionEvent, fileReadEvent(absPath, snapshotId));
           const allLines = content.split("\n");
           const totalLines = allLines.length;
           const start = args.startLine ?? 0;
@@ -18365,11 +18411,18 @@ var init_filesystem = __esm({
     WriteFileArgsSchema = external_exports.object({
       path: external_exports.string().min(1),
       content: external_exports.string(),
-      createDirs: external_exports.boolean().default(false)
+      createDirs: external_exports.boolean().default(false),
+      /**
+       * ADR-0033 file_exists guard. Absent/false: an existing target is NEVER
+       * clobbered — the tool rejects with a structured `file_exists` WriteReject
+       * and writes nothing. Explicit `true` restores the legacy overwrite,
+       * on purpose and on record.
+       */
+      overwrite: external_exports.boolean().optional()
     });
     writeFileTool = {
       name: "write_file",
-      description: "Write or create a file. Use createDirs=true to auto-create parent directories.",
+      description: "Write or create a file. Use createDirs=true to auto-create parent directories. If the target already exists and overwrite is not true, rejects with a structured file_exists WriteReject (meta.reject) and writes nothing \u2014 read it first with read_file, then use edit with its snapshotId, or pass overwrite: true to replace it.",
       permissions: ["write"],
       sideEffect: "local",
       timeoutMs: 1e4,
@@ -18377,6 +18430,29 @@ var init_filesystem = __esm({
       execute: async (args, ctx) => {
         try {
           const absPath = path6.isAbsolute(args.path) ? args.path : path6.join(ctx.cwd, args.path);
+          if (!args.overwrite) {
+            let existing = null;
+            try {
+              const buf = await fs4.readFile(absPath, { encoding: "utf-8", signal: ctx.signal });
+              existing = typeof buf === "string" ? buf : buf.toString("utf-8");
+            } catch (err) {
+              if (err?.code !== "ENOENT")
+                throw err;
+            }
+            if (existing !== null) {
+              return typedErr(`write_file: ${args.path} already exists (FILE_EXISTS). Read it with read_file and use edit with its snapshotId, or pass overwrite: true.`, {
+                status: "failed",
+                warnings: ["FILE_EXISTS"],
+                reject: {
+                  ok: false,
+                  status: "file_exists",
+                  path: absPath,
+                  minimalDiff: fileExistsMinimalDiff(existing, args.content, absPath),
+                  next: { action: "re-read", path: absPath }
+                }
+              });
+            }
+          }
           if (args.createDirs) {
             await fs4.mkdir(path6.dirname(absPath), { recursive: true });
           }
@@ -18549,6 +18625,7 @@ var init_edit = __esm({
     init_toolTypes();
     init_filesystem();
     init_newlines();
+    init_fileEvents();
     WriteRejectSchema = external_exports.object({
       ok: external_exports.literal(false),
       status: external_exports.enum(["stale_snapshot", "hunk_mismatch", "parse_error", "file_exists"]),
@@ -18600,6 +18677,7 @@ var init_edit = __esm({
           });
           if (!result.ok) {
             const detail = result.reject.status === "stale_snapshot" ? `(expected ${result.reject.expectedHash}, actual ${result.reject.actualHash})` : "(oldString not found \u2014 no relocation attempted)";
+            await emitFileEvent(ctx.emitSessionEvent, fileRejectedEvent(absPath, result.reject.status, reReadHint(result.reject)));
             return typedErr(`edit: ${result.reject.status}: ${args.path} ${detail}`, {
               status: "failed",
               warnings: [result.reject.status === "stale_snapshot" ? "STALE_SNAPSHOT" : "HUNK_MISMATCH"],
@@ -18610,6 +18688,7 @@ var init_edit = __esm({
             encoding: "utf-8",
             signal: ctx.signal
           });
+          await emitFileEvent(ctx.emitSessionEvent, fileAppliedEvent(absPath, result.snapshotId, result.newContent.length));
           return typedOk({
             path: absPath,
             applied: true,
@@ -20061,11 +20140,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path93 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path94 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path93,
+            path: path94,
             title,
             content,
             format: "markdown",
@@ -20074,7 +20153,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path93}".`;
+          return `Document "${title}" created at "${path94}".`;
         }
       }
     ];
@@ -26420,11 +26499,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join4 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path93 = join4(zelariRoot, "nfr-spec.json");
-  if (!existsSync7(path93))
+  const path94 = join4(zelariRoot, "nfr-spec.json");
+  if (!existsSync7(path94))
     return null;
   try {
-    const raw = JSON.parse(readFileSync7(path93, "utf8"));
+    const raw = JSON.parse(readFileSync7(path94, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -28730,9 +28809,9 @@ var init_types5 = __esm({
 import { readFileSync as readFileSync12 } from "node:fs";
 import { join as join10 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path93 = join10(zelariRoot, LESSONS_FILE);
+  const path94 = join10(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync12(path93, "utf8");
+    const raw = readFileSync12(path94, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -28833,8 +28912,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path93 = join11(zelariRoot, LESSONS_FILE);
-  appendFileSync(path93, `${JSON.stringify(lesson)}
+  const path94 = join11(zelariRoot, LESSONS_FILE);
+  appendFileSync(path94, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -30798,9 +30877,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path93 = [];
+    const path94 = [];
     color.set(start, GRAY);
-    path93.push(start);
+    path94.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id3, idx] = top;
@@ -30813,17 +30892,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path93.indexOf(dep);
-          return [...path93.slice(at), dep];
+          const at = path94.indexOf(dep);
+          return [...path94.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path93.push(dep);
+          path94.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id3, BLACK);
-        path93.pop();
+        path94.pop();
         stack.pop();
       }
     }
@@ -31743,8 +31822,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path93 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path93}`);
+        const path94 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path94}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -31879,6 +31958,13 @@ var init_types9 = __esm({
       // older readers skip them via the tolerant replay (schema-mismatch issues).
       "graph.node_started",
       "graph.node_ended",
+      // ADR-0033 (t75): file write-path lifecycle telemetry. State-only (never
+      // model-surface): data = {path, snapshotId?, status?}. Additive kinds —
+      // no SCHEMA_VERSION bump (ADR-0021): older readers report schema-mismatch
+      // and skip them via the tolerant replay; deriveMessages ignores them.
+      "file.read",
+      "file.applied",
+      "file.rejected",
       "note"
     ];
     SessionEventEnvelopeSchema = external_exports.object({
@@ -34017,7 +34103,7 @@ async function createExecutionContext(options = {}) {
       workspaceKind: workspace.kind
     }
   });
-  const fs47 = options.fs ?? new NodeFsProvider(workspace);
+  const fs48 = 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;
@@ -34025,7 +34111,7 @@ async function createExecutionContext(options = {}) {
     sessionId: sessionId2,
     profile,
     workspace,
-    fs: fs47,
+    fs: fs48,
     shell,
     subagent,
     appendSessionEvent: (input) => writer.append(input),
@@ -34276,16 +34362,16 @@ function runRetentionFromEnv() {
     maxTotalBytes: Number.isFinite(parseMb) && parseMb > 0 ? Math.round(parseMb * 1024 * 1024) : DEFAULT_RUN_RETENTION_MAX_MB * 1024 * 1024
   };
 }
-async function dirSize(path93) {
+async function dirSize(path94) {
   let total = 0;
   let entries;
   try {
-    entries = await readdir(path93, { withFileTypes: true });
+    entries = await readdir(path94, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child = join13(path93, entry.name);
+    const child = join13(path94, entry.name);
     if (entry.isDirectory())
       total += await dirSize(child);
     else {
@@ -34312,19 +34398,19 @@ async function enforceRunRetention(runsDir, options = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const path93 = join13(runsDir, entry.name);
+    const path94 = join13(runsDir, entry.name);
     let startedAt = 0;
     let endedAt;
     let completed = false;
     try {
-      const manifest = JSON.parse(await readFile(join13(path93, "manifest.json"), "utf8"));
+      const manifest = JSON.parse(await readFile(join13(path94, "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: path93, startedAt, endedAt, completed, bytes: await dirSize(path93) });
+    infos.push({ name: entry.name, path: path94, startedAt, endedAt, completed, bytes: await dirSize(path94) });
   }
   const remove = async (info) => {
     await rm(info.path, { recursive: true, force: true });
@@ -35096,12 +35182,12 @@ var init_engine = __esm({
        * content digest) and the returned ref carries the event seq when the
        * emitter resolved one.
        */
-      async fsEvidence(observation, path93, sha256, content, extra = {}) {
+      async fsEvidence(observation, path94, sha256, content, extra = {}) {
         const digest = sha256 && content !== void 0 ? sha256(content) : void 0;
-        const seq = await this.emitEvidence({ observation, path: path93, ...extra, ...digest ? { digest } : {} });
+        const seq = await this.emitEvidence({ observation, path: path94, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
-          ref: path93,
+          ref: path94,
           capturedAt: Date.now(),
           ...digest ? { digest } : {},
           ...seq !== void 0 ? { seq } : {}
@@ -35109,25 +35195,25 @@ var init_engine = __esm({
       }
       async evalFileExists(check2, done) {
         const sha256 = this.options.sha256 ?? defaultSha256;
-        const fs47 = this.services.fs;
-        if (!fs47)
+        const fs48 = this.services.fs;
+        if (!fs48)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs47.exists(check2.path);
+        const exists = await fs48.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 fs47.readFile(check2.path).catch(() => "");
+        const content = await fs48.readFile(check2.path).catch(() => "");
         return done({
           status: "pass",
           evidence: [await this.fsEvidence("file-exists", check2.path, sha256, content, { exists: true })]
         });
       }
       async evalFileAbsent(check2, done) {
-        const fs47 = this.services.fs;
-        if (!fs47)
+        const fs48 = this.services.fs;
+        if (!fs48)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs47.exists(check2.path);
+        const exists = await fs48.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}` });
@@ -35139,12 +35225,12 @@ var init_engine = __esm({
       }
       async evalFileContains(check2, done) {
         const sha256 = this.options.sha256 ?? defaultSha256;
-        const fs47 = this.services.fs;
-        if (!fs47)
+        const fs48 = this.services.fs;
+        if (!fs48)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
         let content;
         try {
-          content = await fs47.readFile(check2.path);
+          content = await fs48.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}` });
@@ -36903,8 +36989,11 @@ var init_budgetRuntime = __esm({
     init_resourceSnapshot();
     DEFAULT_ESSENTIAL_TOOLS = [
       "read_file",
-      "edit_file",
+      "edit",
       "write_file",
+      // ADR-0033 t77: legacy names kept for verification-essential classification
+      // of past-session replays (edit_file/apply_diff left the default catalog).
+      "edit_file",
       "apply_diff",
       "grep_content",
       "list_files",
@@ -37378,6 +37467,88 @@ var init_taskContract2 = __esm({
   }
 });
 
+// src/cli/spineFileEvents.ts
+function asRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function asString3(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function extractReject(output) {
+  const rec = asRecord(output);
+  if (!rec) return null;
+  if (rec.ok !== false) return null;
+  const meta3 = asRecord(rec.meta);
+  const reject = asRecord(meta3?.reject) ?? asRecord(rec.reject);
+  if (reject) return reject;
+  return asString3(rec.status) && asString3(rec.path) ? rec : null;
+}
+function decodeValue(output) {
+  let rec;
+  if (typeof output !== "string") {
+    rec = asRecord(output);
+  } else {
+    try {
+      rec = asRecord(JSON.parse(output));
+    } catch {
+      return null;
+    }
+  }
+  if (rec && rec.ok === true) return asRecord(rec.value);
+  return rec;
+}
+function deriveFileEvents(toolName, output) {
+  if (typeof toolName !== "string" || !FILE_TOOLS.has(toolName)) return [];
+  const reject = toolName === "edit" ? extractReject(output) : null;
+  if (reject) {
+    const status = asString3(reject.status);
+    const rejectPath = asString3(reject.path);
+    return status && rejectPath ? [{ kind: "file.rejected", data: { path: rejectPath, status } }] : [];
+  }
+  const rec = decodeValue(output);
+  if (toolName === "edit") {
+    if (!rec) {
+      const m = typeof output === "string" ? EDIT_REJECT_RE.exec(output) : null;
+      return m ? [{ kind: "file.rejected", data: { path: m[2], status: m[1] } }] : [];
+    }
+    if (rec.applied !== true) return [];
+    const p3 = asString3(rec.path);
+    const snapshotId = asString3(rec.snapshotId);
+    if (!p3 || !snapshotId) return [];
+    const occurrences = typeof rec.occurrencesReplaced === "number" && Number.isFinite(rec.occurrencesReplaced) ? rec.occurrencesReplaced : null;
+    return [
+      {
+        kind: "file.applied",
+        data: { path: p3, snapshotId, ...occurrences !== null ? { occurrencesReplaced: occurrences } : {} }
+      }
+    ];
+  }
+  if (!rec) return [];
+  switch (toolName) {
+    case "read_file": {
+      const p3 = asString3(rec.path);
+      const snapshotId = asString3(rec.snapshotId);
+      return p3 && snapshotId ? [{ kind: "file.read", data: { path: p3, snapshotId } }] : [];
+    }
+    case "write_file": {
+      const p3 = asString3(rec.path);
+      if (!p3 || typeof rec.bytesWritten !== "number") return [];
+      const created = typeof rec.created === "boolean" ? rec.created : null;
+      return [{ kind: "file.applied", data: { path: p3, ...created !== null ? { created } : {} } }];
+    }
+    default:
+      return [];
+  }
+}
+var FILE_TOOLS, EDIT_REJECT_RE;
+var init_spineFileEvents = __esm({
+  "src/cli/spineFileEvents.ts"() {
+    "use strict";
+    FILE_TOOLS = /* @__PURE__ */ new Set(["read_file", "write_file", "edit"]);
+    EDIT_REJECT_RE = /^edit: (stale_snapshot|hunk_mismatch|parse_error|file_exists): (.+?)(?: \(|\n|$)/;
+  }
+});
+
 // src/cli/sessionSpine.ts
 import path24 from "node:path";
 function spineEnabled() {
@@ -37528,7 +37699,7 @@ async function noteHarnessLifecycle(spine, sessionId2, profileId, budget, baseDi
   } catch {
   }
 }
-var MAX_STREAM_BUFFERS, SessionSpineMirror, SpineMirroringWriter;
+var MAX_PENDING_TOOL_NAMES, MAX_STREAM_BUFFERS, SessionSpineMirror, SpineMirroringWriter;
 var init_sessionSpine = __esm({
   "src/cli/sessionSpine.ts"() {
     "use strict";
@@ -37541,6 +37712,8 @@ var init_sessionSpine = __esm({
     init_runtime2();
     init_harnessManifest2();
     init_taskContract2();
+    init_spineFileEvents();
+    MAX_PENDING_TOOL_NAMES = 256;
     MAX_STREAM_BUFFERS = 32;
     SessionSpineMirror = class _SessionSpineMirror {
       constructor(sessionId2, options) {
@@ -37561,6 +37734,8 @@ var init_sessionSpine = __esm({
       resourceTurnPrepared = false;
       /** 2.6 Track A: set once a task.contract has been seeded (or the log had one). */
       contractSeeded = false;
+      /** ADR-0033 (t75): bounded callId→tool-name map for result derivation. */
+      pendingToolNames = /* @__PURE__ */ new Map();
       status = "disabled";
       /** Seq the log continued from when adopting an existing session. */
       resumedFromSeq;
@@ -37845,6 +38020,30 @@ var init_sessionSpine = __esm({
       }
       append(input) {
         if (!this.writer || this.status === "closed") return Promise.resolve(null);
+        if (input.kind === "tool.call") {
+          const callId = input.data?.callId;
+          const tool = input.data?.tool;
+          if (typeof callId === "string" && typeof tool === "string") {
+            if (this.pendingToolNames.size >= MAX_PENDING_TOOL_NAMES) {
+              const oldest = this.pendingToolNames.keys().next().value;
+              if (oldest !== void 0) this.pendingToolNames.delete(oldest);
+            }
+            this.pendingToolNames.set(callId, tool);
+          }
+        }
+        let derivedFileEvents = [];
+        if (input.kind === "tool.result") {
+          const callId = input.data?.callId;
+          const toolName = typeof callId === "string" ? this.pendingToolNames.get(callId) : void 0;
+          if (typeof callId === "string") this.pendingToolNames.delete(callId);
+          if (toolName !== void 0) {
+            try {
+              derivedFileEvents = deriveFileEvents(toolName, input.data?.output);
+            } catch {
+              derivedFileEvents = [];
+            }
+          }
+        }
         const budgetEffect = input.kind === "tool.call" ? this.onToolCallBudget() : null;
         const dueContract = input.kind === "user.message" && taskContractsEnabled() && !this.contractSeeded ? (this.contractSeeded = true, input.data?.text) : null;
         const steerText = input.kind === "user.message" && taskContractsEnabled() && this.contractSeeded && !dueContract ? input.data?.text ?? null : null;
@@ -37861,6 +38060,11 @@ var init_sessionSpine = __esm({
             (s) => this.writer.append({ kind: "resource.snapshot", actor: ACTOR_SYSTEM, data: { ...dueSnapshot } }).then(() => s)
           );
         }
+        for (const fileEvent of derivedFileEvents) {
+          seq = seq.then(
+            (s) => this.writer.append({ kind: fileEvent.kind, actor: ACTOR_AGENT, data: { ...fileEvent.data } }).then(() => s)
+          );
+        }
         if (dueContract) {
           seq = seq.then(async (s) => {
             try {
@@ -38284,9 +38488,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 path93 = join14(dir, file2);
-    writeFileSync11(path93, fullText, "utf8");
-    return path93;
+    const path94 = join14(dir, file2);
+    writeFileSync11(path94, fullText, "utf8");
+    return path94;
   } catch {
     return null;
   }
@@ -38332,10 +38536,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path93 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path93) {
+    const path94 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path94) {
       const spillNote = `
-\u2026 [full output spilled to: ${path93} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path94} \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}
 `);
@@ -46130,28 +46334,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path93) {
-        if (!existsSync21(path93)) {
-          throw new Error(`File not found: ${path93}`);
+      read(path94) {
+        if (!existsSync21(path94)) {
+          throw new Error(`File not found: ${path94}`);
         }
-        const md = readFileSync17(path93, "utf8");
+        const md = readFileSync17(path94, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path93) {
-        if (!existsSync21(path93)) return null;
-        return this.read(path93);
+      readIfExists(path94) {
+        if (!existsSync21(path94)) return null;
+        return this.read(path94);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path93, meta3, body) {
-        mkdirSync10(dirname2(path93), { recursive: true });
-        const tmp = path93 + ".tmp-" + process.pid;
+      write(path94, meta3, body) {
+        mkdirSync10(dirname2(path94), { recursive: true });
+        const tmp = path94 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync13(tmp, md, "utf8");
-        renameSync(tmp, path93);
+        renameSync(tmp, path94);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -46213,8 +46417,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path93 = join18(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync11(dirname3(path93), { recursive: true });
+  const path94 = join18(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync11(dirname3(path94), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -46235,7 +46439,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path93, meta3, body);
+  new Storage().write(path94, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join18(rootDir, "plan.json");
@@ -47949,7 +48153,7 @@ function createLspTools(provider, root = process.cwd()) {
   };
   const renameSymbol = {
     name: "rename_symbol",
-    description: "PREVIEW a safe, workspace-wide rename of the symbol at a position (via the language server): returns which files change and how many edits each gets, so you know the blast radius before touching anything. It does NOT write files \u2014 apply the change yourself with edit_file once the scope looks right.",
+    description: "PREVIEW a safe, workspace-wide rename of the symbol at a position (via the language server): returns which files change and how many edits each gets, so you know the blast radius before touching anything. It does NOT write files \u2014 apply the change yourself with edit once the scope looks right.",
     permissions: ["read"],
     inputSchema: PosArgs.extend({
       newName: external_exports.string().min(1).describe("The new symbol name.")
@@ -48526,7 +48730,7 @@ function createAstTools(root) {
   };
   const findSymbolTool = {
     name: "find_symbol",
-    description: "Locate a named declaration in a TS/JS file and return its EXACT source text and line range. Use this to grab a function/class/method verbatim so you can edit_file it reliably (node-accurate) instead of guessing the surrounding text. Relative paths resolve against the working directory. TS/JS only.",
+    description: "Locate a named declaration in a TS/JS file and return its EXACT source text and line range. Use this to grab a function/class/method verbatim so you can edit it reliably (node-accurate) instead of guessing the surrounding text. Relative paths resolve against the working directory. TS/JS only.",
     permissions: ["read"],
     inputSchema: external_exports.object({
       path: external_exports.string().min(1).describe("Path to the TS/JS file."),
@@ -49888,21 +50092,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path93 = getSshSecretsPath();
-  if (!existsSync27(path93)) return {};
+  const path94 = getSshSecretsPath();
+  if (!existsSync27(path94)) return {};
   try {
-    return JSON.parse(readFileSync21(path93, "utf8"));
+    return JSON.parse(readFileSync21(path94, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path93 = getSshSecretsPath();
-  mkdirSync12(dirname4(path93), { recursive: true });
-  writeFileSync15(path93, `${JSON.stringify(data, null, 2)}
+  const path94 = getSshSecretsPath();
+  mkdirSync12(dirname4(path94), { recursive: true });
+  writeFileSync15(path94, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path93, 384);
+    chmodSync(path94, 384);
   } catch {
   }
 }
@@ -49931,10 +50135,10 @@ function deleteSshPassword(id3) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path93 = getSshTargetsPath();
-  if (!existsSync27(path93)) return [];
+  const path94 = getSshTargetsPath();
+  if (!existsSync27(path94)) return [];
   try {
-    const parsed = JSON.parse(readFileSync21(path93, "utf8"));
+    const parsed = JSON.parse(readFileSync21(path94, "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"
@@ -49949,11 +50153,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path93 = getSshTargetsPath();
-  mkdirSync12(dirname4(path93), { recursive: true });
+  const path94 = getSshTargetsPath();
+  mkdirSync12(dirname4(path94), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync15(
-    path93,
+    path94,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -50199,11 +50403,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path93 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path94 = 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}${path93}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path94}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -51192,6 +51396,133 @@ var init_lifecycleHooks = __esm({
   }
 });
 
+// src/cli/safety/astGate.ts
+import { promises as fs23 } from "node:fs";
+import path49 from "node:path";
+function astGateEnabled() {
+  return process.env.ZELARI_AST_GATE !== "0";
+}
+function loadTs2() {
+  if (!tsPromise2) {
+    tsPromise2 = import("typescript").then((m) => m.default ?? m).catch(() => null);
+  }
+  return tsPromise2;
+}
+function firstSyntaxError(ts, fileName, content) {
+  const source2 = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true);
+  const diags = source2.parseDiagnostics;
+  const first = diags?.[0];
+  if (!first) return null;
+  const { line, character } = source2.getLineAndCharacterOfPosition(first.start ?? 0);
+  const flattened = typeof ts.flattenDiagnosticMessageText === "function" ? ts.flattenDiagnosticMessageText(first.messageText, " ") : String(first.messageText);
+  const code = typeof first.code === "number" ? `TS${first.code}: ` : "";
+  return { message: `${code}${flattened}`, line: line + 1, character: character + 1 };
+}
+function minimalDiffOf(pathLabel, brokenContent, line) {
+  const brokenLine = (brokenContent.split(/\r?\n/)[line - 1] ?? "").slice(0, 160);
+  return [
+    `--- a/${pathLabel}`,
+    `+++ b/${pathLabel}`,
+    `@@ -${line},1 +${line},1 @@`,
+    `- ${brokenLine}`,
+    "+ (write REVERTED \u2014 pre-write content restored)"
+  ].join("\n");
+}
+function wrapWithAstGate(original, opts) {
+  if (!AST_GATE_TOOLS.has(original.name)) return original;
+  const containedPathOf = (args) => {
+    const raw = args["path"];
+    if (typeof raw !== "string" || raw.length === 0) return null;
+    const absPath = path49.isAbsolute(raw) ? raw : path49.join(opts.root, raw);
+    const rel2 = path49.relative(opts.root, absPath);
+    if (rel2.startsWith("..") || path49.isAbsolute(rel2)) return null;
+    return absPath;
+  };
+  return {
+    ...original,
+    execute: async (args, ctx) => {
+      let preContent;
+      let gateTarget = null;
+      try {
+        if (astGateEnabled()) gateTarget = containedPathOf(args);
+        if (gateTarget !== null && isAstSupported(gateTarget)) {
+          try {
+            preContent = await fs23.readFile(gateTarget, "utf8");
+          } catch (err) {
+            if (err?.code === "ENOENT") preContent = null;
+          }
+        }
+      } catch {
+        gateTarget = null;
+        preContent = void 0;
+      }
+      const result = await original.execute(args, ctx);
+      if (!result.ok) return result;
+      if (gateTarget !== null && !isAstSupported(gateTarget)) {
+        process.stderr.write(
+          `[ast_gate] LOUD SKIP (unsupported-extension): ${original.name} ${gateTarget} \u2014 ${path49.extname(gateTarget) || "(no extension)"} is outside the AST surface; write KEPT, NOT syntax-gated.
+`
+        );
+        return result;
+      }
+      if (preContent === void 0) return result;
+      try {
+        const absPath = gateTarget;
+        const ts = await loadTs2();
+        if (!ts) {
+          process.stderr.write(
+            `[ast_gate] LOUD SKIP (typescript-unavailable): ${original.name} ${absPath} \u2014 TypeScript is not loadable in this runtime; write KEPT, NOT syntax-gated.
+`
+          );
+          return result;
+        }
+        const post = await fs23.readFile(absPath, "utf8");
+        const syntaxError = firstSyntaxError(ts, path49.basename(absPath), post);
+        if (!syntaxError) return result;
+        const parseError = `${syntaxError.message} (line ${syntaxError.line}, col ${syntaxError.character})`;
+        let revertedTo;
+        if (preContent === null) {
+          await fs23.unlink(absPath).catch(() => void 0);
+          revertedTo = "absent";
+        } else {
+          await fs23.writeFile(absPath, preContent, "utf8");
+          revertedTo = snapshotIdOf(preContent);
+        }
+        const relLabel = path49.relative(opts.root, absPath) || path49.basename(absPath);
+        return typedErr(
+          `[ast_gate_reverted] ${original.name}: ${absPath} written but the file no longer parses \u2014 write REVERTED (revertedTo=${revertedTo}). ${parseError}. Fix the syntax and re-apply (read_file first for a fresh snapshotId).`,
+          {
+            status: "failed",
+            warnings: ["AST_GATE_REVERTED"],
+            // WriteReject (ADR-0033 schema): conforming payload — the parse
+            // detail lives in the error string + minimalDiff/span.
+            reject: {
+              ok: false,
+              status: "parse_error",
+              path: absPath,
+              minimalDiff: minimalDiffOf(relLabel, post, syntaxError.line),
+              next: { action: "re-read", path: absPath },
+              span: { startLine: syntaxError.line, endLine: syntaxError.line }
+            }
+          }
+        );
+      } catch {
+        return result;
+      }
+    }
+  };
+}
+var AST_GATE_TOOLS, tsPromise2;
+var init_astGate = __esm({
+  "src/cli/safety/astGate.ts"() {
+    "use strict";
+    init_toolTypes();
+    init_filesystem();
+    init_engine3();
+    AST_GATE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit"]);
+  }
+});
+
 // src/cli/extensions/extensionToolWiring.ts
 function extensionToolToDefinition(entry) {
   const { spec, extensionId } = entry;
@@ -51386,7 +51717,9 @@ function resourceClaimsFor(toolName, args) {
   const a = asArgs(args);
   switch (toolName) {
     case "write_file":
-    case "edit_file": {
+    case "edit_file":
+    // ADR-0033 t77: the anchored `edit` carries the same single-path args.
+    case "edit": {
       const p3 = primaryPath(a);
       return p3 ? [{ kind: "path", operation: "write", path: p3 }] : [];
     }
@@ -51579,8 +51912,8 @@ var init_resourceClaims = __esm({
 
 // src/cli/toolResultCache.ts
 import { createHash as createHash14 } from "node:crypto";
-import { promises as fs23 } from "node:fs";
-import path49 from "node:path";
+import { promises as fs24 } from "node:fs";
+import path50 from "node:path";
 function isToolCacheEnabled() {
   const raw = process.env.ZELARI_TOOL_CACHE;
   return raw !== "0" && raw !== "false" && raw !== "off";
@@ -51665,9 +51998,9 @@ async function statKey(toolName, input, ctx) {
   if (!input || typeof input !== "object") return null;
   const rawPath = input.path;
   if (typeof rawPath !== "string" || rawPath.length === 0) return null;
-  const abs = path49.isAbsolute(rawPath) ? rawPath : path49.join(ctx.cwd, rawPath);
+  const abs = path50.isAbsolute(rawPath) ? rawPath : path50.join(ctx.cwd, rawPath);
   try {
-    const st = await fs23.stat(abs);
+    const st = await fs24.stat(abs);
     return hashKey({
       tool: toolName,
       args: input,
@@ -51721,7 +52054,7 @@ __export(toolRegistry_exports, {
   wrapWithSandbox: () => wrapWithSandbox
 });
 import { existsSync as existsSync29 } from "node:fs";
-import path50 from "node:path";
+import path51 from "node:path";
 function createBuiltinToolRegistry(options = {}) {
   const root = options.root ?? process.cwd();
   const audit = options.audit ?? new AuditLogger();
@@ -51737,10 +52070,16 @@ function createBuiltinToolRegistry(options = {}) {
     sessionId2
   );
   const safeWriteFile = withDiag(
-    wrapWithSandbox(writeFileTool, ["path"], root, audit, sessionId2, { verifyWrite: true })
+    wrapWithAstGate(
+      wrapWithSandbox(writeFileTool, ["path"], root, audit, sessionId2, { verifyWrite: true }),
+      { root }
+    )
   );
-  const safeEditFile = withDiag(
-    wrapWithSandbox(editFileTool, ["path"], root, audit, sessionId2, { verifyWrite: true })
+  const safeEdit = withDiag(
+    wrapWithAstGate(
+      wrapWithSandbox(editTool, ["path"], root, audit, sessionId2, { verifyWrite: true }),
+      { root }
+    )
   );
   const safeGrepContent = wrapWithSandbox(
     withResultCache(grepContentTool, { kind: "ttl" }),
@@ -51757,9 +52096,6 @@ function createBuiltinToolRegistry(options = {}) {
     sessionId2
   );
   const safeShowDiff = wrapWithSandbox(showDiffTool, ["path"], root, audit, sessionId2);
-  const safeApplyDiff = withDiag(
-    wrapWithSandbox(applyDiffTool, ["path"], root, audit, sessionId2, { verifyWrite: true })
-  );
   const jailSpec = buildJailSpec({ root });
   const resolveJailNetwork = (toolName, args) => {
     const allowedHosts = [];
@@ -51855,8 +52191,7 @@ function createBuiltinToolRegistry(options = {}) {
   }
   if (allowMutators) {
     registry4.register(withPerm(safeWriteFile));
-    registry4.register(withPerm(safeEditFile));
-    registry4.register(withPerm(safeApplyDiff));
+    registry4.register(withPerm(safeEdit));
   }
   if (allowBash) {
     registry4.register(withPerm(safeBash));
@@ -51890,7 +52225,7 @@ function createBuiltinToolRegistry(options = {}) {
     safeWebSearch,
     ...observeBatchTool ? [observeBatchTool] : [],
     ...retrieveObservationTool ? [retrieveObservationTool] : [],
-    ...allowMutators ? [safeWriteFile, safeEditFile, safeApplyDiff] : [],
+    ...allowMutators ? [safeWriteFile, safeEdit] : [],
     ...allowBash ? [safeBash, safeExecProcess] : [],
     ...askUserTool ? [askUserTool] : [],
     ...skillTool ? [skillTool] : [],
@@ -52285,14 +52620,14 @@ function wrapWithDiagnostics(original, root, runner) {
 function claimedSourcePath(token, args, root) {
   const cleaned = token.replace(/^["']|["']$/g, "");
   if (!cleaned || cleaned.startsWith("-")) return null;
-  if (!DIAG_SOURCE_EXTENSIONS.has(path50.extname(cleaned).toLowerCase())) return null;
+  if (!DIAG_SOURCE_EXTENSIONS.has(path51.extname(cleaned).toLowerCase())) return null;
   const bases = [root];
   const cwd = args["cwd"];
   if (typeof cwd === "string" && cwd.length > 0) {
-    bases.unshift(path50.isAbsolute(cwd) ? cwd : path50.resolve(root, cwd));
+    bases.unshift(path51.isAbsolute(cwd) ? cwd : path51.resolve(root, cwd));
   }
   for (const base2 of bases) {
-    const candidate = path50.isAbsolute(cleaned) ? path50.normalize(cleaned) : path50.resolve(base2, cleaned);
+    const candidate = path51.isAbsolute(cleaned) ? path51.normalize(cleaned) : path51.resolve(base2, cleaned);
     try {
       const contained = resolveSandboxedPath(candidate, { root });
       if (existsSync29(contained)) return contained;
@@ -52535,6 +52870,7 @@ var init_toolRegistry = __esm({
     "use strict";
     init_registry2();
     init_filesystem();
+    init_edit();
     init_shell();
     init_search();
     init_listFiles();
@@ -52566,6 +52902,7 @@ var init_toolRegistry = __esm({
     init_providerConfig();
     init_toolPermissions();
     init_lifecycleHooks();
+    init_astGate();
     init_extensionToolWiring();
     init_policyEngine();
     init_policyLoadMode();
@@ -52580,6 +52917,10 @@ var init_toolRegistry = __esm({
     HARNESS_BUILTIN_NAMES = /* @__PURE__ */ new Set([
       "read_file",
       "write_file",
+      "edit",
+      // ADR-0033 t77: edit_file/apply_diff left the default catalog, but the
+      // harness bridge still exposes them for the deprecation cycle — keep
+      // skipping them here so catalog re-bridging never duplicates.
       "edit_file",
       "bash",
       "grep_content",
@@ -52597,13 +52938,13 @@ var init_toolRegistry = __esm({
 });
 
 // src/cli/metrics.ts
-import { promises as fs24, existsSync as existsSync30, statSync as statSync4, renameSync as renameSync3, appendFileSync as appendFileSync3, mkdirSync as mkdirSync14 } from "node:fs";
-import path51 from "node:path";
+import { promises as fs25, existsSync as existsSync30, statSync as statSync4, renameSync as renameSync3, appendFileSync as appendFileSync3, mkdirSync as mkdirSync14 } from "node:fs";
+import path52 from "node:path";
 import os9 from "node:os";
 async function readMetrics(file2) {
   let raw = "";
   try {
-    raw = await fs24.readFile(file2, "utf-8");
+    raw = await fs25.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -52647,8 +52988,8 @@ var init_metrics3 = __esm({
       file;
       writeQueue = Promise.resolve();
       constructor(file2) {
-        this.file = file2 ?? process.env.ANATHEMA_METRICS_FILE ?? path51.join(os9.homedir(), ".tmp", "zelari-code", "metrics.jsonl");
-        mkdirSync14(path51.dirname(this.file), { recursive: true });
+        this.file = file2 ?? process.env.ANATHEMA_METRICS_FILE ?? path52.join(os9.homedir(), ".tmp", "zelari-code", "metrics.jsonl");
+        mkdirSync14(path52.dirname(this.file), { recursive: true });
       }
       /** Metrics file path — doctor/summary readers use this. */
       get filePath() {
@@ -52706,6 +53047,9 @@ var init_turnRuntime = __esm({
     init_events2();
     WRITE_TOOLS3 = /* @__PURE__ */ new Set([
       "write_file",
+      "edit",
+      // ADR-0033 t77: legacy names kept so replays of past sessions still
+      // classify as writes (edit_file/apply_diff left the default catalog).
       "edit_file",
       "apply_diff"
     ]);
@@ -52958,7 +53302,7 @@ You are an orchestrator, not an implementer. DEFAULT to spawning tentacles.
 Current policy: **lead only**.
 
 - Do **not** spawn \`task\` tentacles (explore / general / verify) unless the user explicitly asks.
-- Do the work yourself with \`read_file\` / \`grep_content\` / \`bash\` / \`edit_file\`.
+- Do the work yourself with \`read_file\` / \`grep_content\` / \`bash\` / \`edit\`.
 - The \`task\` tool remains available for an explicit user request only.
 `;
     FRAGMENTS = {
@@ -52971,7 +53315,7 @@ Current policy: **lead only**.
 
 // src/cli/kraken/verificationAdapters/node.ts
 import { readFile as readFile4, stat as stat2 } from "node:fs/promises";
-import path52 from "node:path";
+import path53 from "node:path";
 async function fileExists(candidate) {
   try {
     return (await stat2(candidate)).isFile();
@@ -52981,7 +53325,7 @@ async function fileExists(candidate) {
 }
 async function readPackageJson(root) {
   try {
-    return JSON.parse(await readFile4(path52.join(root, "package.json"), "utf-8"));
+    return JSON.parse(await readFile4(path53.join(root, "package.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -52995,7 +53339,7 @@ async function resolvePackageManager(root) {
   const fromField = packageManagerFromField(await readPackageJson(root));
   if (fromField) return { pm: fromField, declaredToolchain: true };
   for (const [marker, pm] of PM_LOCKFILES) {
-    if (await fileExists(path52.join(root, marker))) return { pm, declaredToolchain: true };
+    if (await fileExists(path53.join(root, marker))) return { pm, declaredToolchain: true };
   }
   return { pm: "npm", declaredToolchain: false };
 }
@@ -53018,7 +53362,7 @@ var init_node = __esm({
     KNOWN_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
     nodeAdapter = {
       async detect(root) {
-        if (!await fileExists(path52.join(root, "package.json"))) return 0;
+        if (!await fileExists(path53.join(root, "package.json"))) return 0;
         const { declaredToolchain } = await resolvePackageManager(root);
         return declaredToolchain ? 20 : 10;
       },
@@ -53037,7 +53381,7 @@ var init_node = __esm({
 
 // src/cli/kraken/verificationAdapters/python.ts
 import { readFile as readFile5, stat as stat3 } from "node:fs/promises";
-import path53 from "node:path";
+import path54 from "node:path";
 async function fileExists2(candidate) {
   try {
     return (await stat3(candidate)).isFile();
@@ -53073,7 +53417,7 @@ var init_python = __esm({
       async detect(root) {
         let best = 0;
         for (const [marker, score] of DETECT_MARKERS) {
-          if (score > best && await fileExists2(path53.join(root, marker))) best = score;
+          if (score > best && await fileExists2(path54.join(root, marker))) best = score;
         }
         return best;
       },
@@ -53081,12 +53425,12 @@ var init_python = __esm({
         const present = /* @__PURE__ */ new Map();
         for (const name of SCAN_FILES) {
           try {
-            present.set(name, await readFile5(path53.join(root, name), "utf-8"));
+            present.set(name, await readFile5(path54.join(root, name), "utf-8"));
           } catch {
           }
         }
         const hasToken = (token) => [...present.values()].some((text) => text.includes(token));
-        const pytestEvidenced = hasToken("pytest") || await dirExists(path53.join(root, "tests"));
+        const pytestEvidenced = hasToken("pytest") || await dirExists(path54.join(root, "tests"));
         const mypyReferenced = hasToken("mypy") || present.has("mypy.ini") || present.has(".mypy.ini");
         const pyrightReferenced = hasToken("pyright") || present.has("pyrightconfig.json");
         return {
@@ -53102,7 +53446,7 @@ var init_python = __esm({
 
 // src/cli/kraken/verificationAdapters/rust.ts
 import { stat as stat4 } from "node:fs/promises";
-import path54 from "node:path";
+import path55 from "node:path";
 async function fileExists3(candidate) {
   try {
     return (await stat4(candidate)).isFile();
@@ -53116,7 +53460,7 @@ var init_rust = __esm({
     "use strict";
     rustAdapter = {
       async detect(root) {
-        return await fileExists3(path54.join(root, "Cargo.toml")) ? 10 : 0;
+        return await fileExists3(path55.join(root, "Cargo.toml")) ? 10 : 0;
       },
       async buildPlan(_root) {
         void _root;
@@ -53132,7 +53476,7 @@ var init_rust = __esm({
 
 // src/cli/kraken/verificationAdapters/go.ts
 import { stat as stat5 } from "node:fs/promises";
-import path55 from "node:path";
+import path56 from "node:path";
 async function fileExists4(candidate) {
   try {
     return (await stat5(candidate)).isFile();
@@ -53146,7 +53490,7 @@ var init_go = __esm({
     "use strict";
     goAdapter = {
       async detect(root) {
-        return await fileExists4(path55.join(root, "go.mod")) ? 10 : 0;
+        return await fileExists4(path56.join(root, "go.mod")) ? 10 : 0;
       },
       async buildPlan(_root) {
         return {
@@ -53162,7 +53506,7 @@ var init_go = __esm({
 
 // src/cli/kraken/verificationAdapters/java.ts
 import { stat as stat6 } from "node:fs/promises";
-import path56 from "node:path";
+import path57 from "node:path";
 async function fileExists5(candidate) {
   try {
     return (await stat6(candidate)).isFile();
@@ -53172,13 +53516,13 @@ async function fileExists5(candidate) {
 }
 async function hasGradleMarker(root) {
   for (const [marker] of GRADLE_MARKERS) {
-    if (await fileExists5(path56.join(root, marker))) return true;
+    if (await fileExists5(path57.join(root, marker))) return true;
   }
   return false;
 }
 async function gradleCommand(root, verb, platform = process.platform) {
   const wrapper = platform === "win32" ? "gradlew.bat" : "gradlew";
-  if (await fileExists5(path56.join(root, wrapper))) {
+  if (await fileExists5(path57.join(root, wrapper))) {
     return platform === "win32" ? `gradlew.bat ${verb}` : `./gradlew ${verb}`;
   }
   return `gradle ${verb}`;
@@ -53203,7 +53547,7 @@ var init_java = __esm({
       async detect(root) {
         let best = 0;
         for (const [marker, score] of DETECT_MARKERS2) {
-          if (score > best && await fileExists5(path56.join(root, marker))) best = score;
+          if (score > best && await fileExists5(path57.join(root, marker))) best = score;
         }
         return best;
       },
@@ -53216,7 +53560,7 @@ var init_java = __esm({
             buildCommand: await gradleCommand(root, "build")
           };
         }
-        if (await fileExists5(path56.join(root, "pom.xml"))) {
+        if (await fileExists5(path57.join(root, "pom.xml"))) {
           return {
             typecheckCommand: null,
             // compilation rides the test/package lifecycle
@@ -53325,7 +53669,7 @@ __export(nativeVerification_exports, {
   resolvePackCommandsForRoot: () => resolvePackCommandsForRoot
 });
 import { readFile as readFile6 } from "node:fs/promises";
-import path57 from "node:path";
+import path58 from "node:path";
 function nativePackEnabled(env = process.env) {
   const v = env.ZELARI_VERIFY_PACK?.toLowerCase();
   if (v === "0" || v === "off" || v === "false") return false;
@@ -53368,7 +53712,7 @@ function packTimeoutMs(env = process.env) {
 }
 async function readPackageScripts(cwd = process.cwd()) {
   try {
-    const raw = await readFile6(path57.join(cwd, "package.json"), "utf-8");
+    const raw = await readFile6(path58.join(cwd, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && typeof parsed.scripts === "object") {
       return parsed.scripts;
@@ -53901,7 +54245,7 @@ var init_completionProofAttestation = __esm({
 // src/cli/kraken/completionProofPersist.ts
 import { open, rename as rename2, rm as rm2 } from "node:fs/promises";
 import { randomBytes as randomBytes5 } from "node:crypto";
-import path58 from "node:path";
+import path59 from "node:path";
 function isTruthyFlag2(v) {
   const n = v?.trim().toLowerCase();
   return n === "1" || n === "true" || n === "yes" || n === "on";
@@ -53943,8 +54287,8 @@ function isWindowsRenameBlock(err) {
   return code === "EPERM" || code === "ENOTEMPTY" || code === "EEXIST";
 }
 async function writeFileAtomic(target, data) {
-  const dir = path58.dirname(target);
-  const tmp = path58.join(dir, `.${path58.basename(target)}.${randomBytes5(6).toString("hex")}.tmp`);
+  const dir = path59.dirname(target);
+  const tmp = path59.join(dir, `.${path59.basename(target)}.${randomBytes5(6).toString("hex")}.tmp`);
   let fh = null;
   try {
     fh = await open(tmp, "w");
@@ -53990,7 +54334,7 @@ var init_completionProofPersist = __esm({
 
 // src/cli/kraken/completionProof.ts
 import { mkdir as mkdir3 } from "node:fs/promises";
-import path59 from "node:path";
+import path60 from "node:path";
 function verdictOf(evaluation) {
   return evaluation.evaluation?.verdict ?? (evaluation.blocked ? "BLOCKED" : "PASS");
 }
@@ -54135,7 +54479,7 @@ async function writeCompletionProofDetailed(evaluation, options = {}) {
   const mode = options.persistenceMode ?? activeProofPersistenceMode();
   try {
     const baseDir = options.baseDir ?? process.cwd();
-    const dir = path59.join(baseDir, ".zelari");
+    const dir = path60.join(baseDir, ".zelari");
     await mkdir3(dir, { recursive: true });
     const requested = options.attestation ?? {};
     const plan = requested.skipProbes || requested.verificationPlan !== void 0 ? void 0 : await defaultVerificationPlanSnapshot(baseDir);
@@ -54155,8 +54499,8 @@ async function writeCompletionProofDetailed(evaluation, options = {}) {
       baseDir
     );
     const rendered = renderCompletionProof(evaluation, options.meta ?? {}, wrapper.attestation);
-    const markdownPath = path59.join(dir, "completion-proof.md");
-    const jsonPath = path59.join(dir, "completion-proof.json");
+    const markdownPath = path60.join(dir, "completion-proof.md");
+    const jsonPath = path60.join(dir, "completion-proof.json");
     await writeFileAtomic(markdownPath, rendered.markdown);
     await writeFileAtomic(jsonPath, rendered.json);
     return { paths: { markdownPath, jsonPath }, mode, requiredBlockReason: null };
@@ -54246,20 +54590,20 @@ var init_spineTelemetry = __esm({
 
 // src/cli/state/fileStateStore.ts
 import { createHash as createHash17, randomUUID as randomUUID5 } from "node:crypto";
-import { promises as fs25 } from "node:fs";
-import * as path60 from "node:path";
+import { promises as fs26 } from "node:fs";
+import * as path61 from "node:path";
 function shortId() {
   return randomUUID5().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs25.mkdir(path60.dirname(filePath), { recursive: true });
+  await fs26.mkdir(path61.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await fs25.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
-  await fs25.rename(tmp, filePath);
+  await fs26.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
+  await fs26.rename(tmp, filePath);
 }
 async function readJsonFile(filePath) {
   try {
-    const raw = await fs25.readFile(filePath, "utf8");
+    const raw = await fs26.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -54313,13 +54657,13 @@ var init_fileStateStore = __esm({
       indexPath = "";
       async init(projectRoot) {
         this.root = projectRoot;
-        this.stateDir = path60.join(projectRoot, ".zelari", "state");
-        this.commitsDir = path60.join(this.stateDir, "commits");
-        this.artifactsDir = path60.join(this.stateDir, "artifacts");
-        this.headPath = path60.join(this.stateDir, "HEAD.json");
-        this.indexPath = path60.join(this.stateDir, "index.jsonl");
-        await fs25.mkdir(this.commitsDir, { recursive: true });
-        await fs25.mkdir(this.artifactsDir, { recursive: true });
+        this.stateDir = path61.join(projectRoot, ".zelari", "state");
+        this.commitsDir = path61.join(this.stateDir, "commits");
+        this.artifactsDir = path61.join(this.stateDir, "artifacts");
+        this.headPath = path61.join(this.stateDir, "HEAD.json");
+        this.indexPath = path61.join(this.stateDir, "index.jsonl");
+        await fs26.mkdir(this.commitsDir, { recursive: true });
+        await fs26.mkdir(this.artifactsDir, { recursive: true });
       }
       async commit(input) {
         if (!input.force && input.verification.ran && !input.verification.ok) {
@@ -54330,13 +54674,13 @@ var init_fileStateStore = __esm({
         const discoveries = input.discoveries ?? [];
         const parent = await this.head();
         const id3 = shortId();
-        const artifactRel = path60.join("artifacts", id3);
-        const artifactAbs = path60.join(this.artifactsDir, id3);
-        await fs25.mkdir(artifactAbs, { recursive: true });
+        const artifactRel = path61.join("artifacts", id3);
+        const artifactAbs = path61.join(this.artifactsDir, id3);
+        await fs26.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs25.writeFile(path60.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
-        await writeJsonAtomic(path60.join(artifactAbs, "discoveries.json"), discoveries);
-        await writeJsonAtomic(path60.join(artifactAbs, "verification.json"), input.verification);
+        await fs26.writeFile(path61.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await writeJsonAtomic(path61.join(artifactAbs, "discoveries.json"), discoveries);
+        await writeJsonAtomic(path61.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
           id: id3,
           parentId: parent?.id ?? null,
@@ -54348,16 +54692,16 @@ var init_fileStateStore = __esm({
           workspaceCheckpointId: input.workspaceCheckpointId,
           verification: {
             ...input.verification,
-            reportPath: input.verification.reportPath ?? path60.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
+            reportPath: input.verification.reportPath ?? path61.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
           },
           changedPaths: input.changedPaths ?? [],
           stablePromptHash: input.stablePromptHash,
           discoveryCount: discoveries.length,
           artifactDir: artifactRel.replace(/\\/g, "/")
         };
-        await writeJsonAtomic(path60.join(this.commitsDir, `${id3}.json`), meta3);
+        await writeJsonAtomic(path61.join(this.commitsDir, `${id3}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id: id3, updatedAt: meta3.createdAt });
-        await fs25.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
+        await fs26.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
       }
       async head() {
@@ -54366,13 +54710,13 @@ var init_fileStateStore = __esm({
         return this.get(head.id);
       }
       async get(id3) {
-        const stored = await readJsonFile(path60.join(this.commitsDir, `${id3}.json`));
+        const stored = await readJsonFile(path61.join(this.commitsDir, `${id3}.json`));
         return stored ? stripStored(stored) : null;
       }
       async list(limit = 20) {
         let raw;
         try {
-          raw = await fs25.readFile(this.indexPath, "utf8");
+          raw = await fs26.readFile(this.indexPath, "utf8");
         } catch {
           return [];
         }
@@ -54405,9 +54749,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(path60.join(this.commitsDir, `${meta3.id}.json`));
+        const stored = await readJsonFile(path61.join(this.commitsDir, `${meta3.id}.json`));
         if (!stored?.artifactDir) return [];
-        const discPath = path60.join(this.stateDir, stored.artifactDir, "discoveries.json");
+        const discPath = path61.join(this.stateDir, stored.artifactDir, "discoveries.json");
         return await readJsonFile(discPath) ?? [];
       }
       async materializeContext(id3, maxChars = DEFAULT_MATERIALIZE_CHARS) {
@@ -54722,7 +55066,7 @@ function buildContinueUserMessage(task, prior, opts) {
 ## CRITICAL \u2014 plan text \u2260 done on disk
 The prior assistant output is a PLAN / SPEC / PROPOSAL (or analysis). It is NOT proof that project files already contain those changes.
 The user CONFIRMED the plan and wants you to IMPLEMENT it ON DISK NOW.
-- You MUST use write_file and/or edit_file (and bash when needed) to apply every planned change.
+- You MUST use write_file and/or edit (and bash when needed) to apply every planned change.
 - Reading files alone is incomplete. Do not stop after read_file/list_files/grep.
 - Do NOT claim "already implemented" / "tutto fatto" unless you verified the changes exist on disk in THIS turn (read after your own successful writes).
 - Do NOT restart from zero or re-ask for the overall goal.
@@ -54870,10 +55214,13 @@ var init_phase = __esm({
       "createDecision",
       "linkDocuments"
       // Soft writes that only touch .zelari / plan paths are still gated in
-      // toolRegistry by path when needed; write_file/edit_file stay DENIED.
+      // toolRegistry by path when needed; write_file/edit stay DENIED.
     ]);
     PLAN_BLOCKED_TOOLS = /* @__PURE__ */ new Set([
       "write_file",
+      "edit",
+      // ADR-0033 t77: edit_file/apply_diff left the default catalog but past
+      // sessions' replays still classify by name — keep them blocked.
       "edit_file",
       "apply_diff",
       "bash"
@@ -55007,10 +55354,10 @@ var init_mode = __esm({
 
 // src/cli/headless.ts
 import { readFileSync as readFileSync23 } from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 function resolveHeadlessCwd(opts) {
   const raw = typeof opts.cwd === "string" ? opts.cwd.trim() : "";
-  return path61.resolve(raw.length > 0 ? raw : process.cwd());
+  return path62.resolve(raw.length > 0 ? raw : process.cwd());
 }
 function defaultProfileForMode(mode) {
   switch (mode) {
@@ -56004,8 +56351,8 @@ var init_claudeProvider = __esm({
 
 // src/cli/memory/legacyImport.ts
 import { createHash as createHash18 } from "node:crypto";
-import { promises as fs26 } from "node:fs";
-import * as path62 from "node:path";
+import { promises as fs27 } from "node:fs";
+import * as path63 from "node:path";
 function sourceId(fact, line) {
   return `jsonl:${fact.id ?? createHash18("sha256").update(line).digest("hex")}`;
 }
@@ -56023,10 +56370,10 @@ function timestamp(value) {
 }
 async function importLegacyMemoryLog(backend, service) {
   const result = { found: 0, imported: 0, skipped: 0, corrupt: 0 };
-  const logPath = path62.join(path62.dirname(backend.databasePath), "log.jsonl");
+  const logPath = path63.join(path63.dirname(backend.databasePath), "log.jsonl");
   let raw;
   try {
-    raw = await fs26.readFile(logPath, "utf8");
+    raw = await fs27.readFile(logPath, "utf8");
   } catch {
     return result;
   }
@@ -56206,7 +56553,7 @@ var init_sqliteCodec = __esm({
 // src/cli/memory/sqliteRpc.ts
 import { existsSync as existsSync32 } from "node:fs";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
-import * as path63 from "node:path";
+import * as path64 from "node:path";
 import { Worker } from "node:worker_threads";
 function isBusy(error51) {
   const candidate = error51;
@@ -56215,10 +56562,10 @@ function isBusy(error51) {
   );
 }
 function resolveWorkerUrl() {
-  const here = path63.dirname(fileURLToPath2(import.meta.url));
-  const direct = path63.join(here, "sqliteWorker.mjs");
+  const here = path64.dirname(fileURLToPath2(import.meta.url));
+  const direct = path64.join(here, "sqliteWorker.mjs");
   if (existsSync32(direct)) return pathToFileURL2(direct);
-  return pathToFileURL2(path63.join(here, "memory", "sqliteWorker.mjs"));
+  return pathToFileURL2(path64.join(here, "memory", "sqliteWorker.mjs"));
 }
 var SqliteWorkerRpc;
 var init_sqliteRpc = __esm({
@@ -56506,8 +56853,8 @@ WHERE NOT EXISTS (SELECT 1 FROM memory_fts f WHERE f.node_id = n.id);
 
 // src/cli/memory/sqliteBackend.ts
 import { createHash as createHash19, randomUUID as randomUUID6 } from "node:crypto";
-import { promises as fs27 } from "node:fs";
-import * as path64 from "node:path";
+import { promises as fs28 } from "node:fs";
+import * as path65 from "node:path";
 function boundedLimit(value, fallback = 50) {
   return Math.max(1, Math.min(Math.floor(value ?? fallback), 1e5));
 }
@@ -56567,42 +56914,42 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
       async init(projectRoot) {
         let resolved;
         try {
-          resolved = await fs27.realpath(projectRoot);
+          resolved = await fs28.realpath(projectRoot);
         } catch {
-          resolved = path64.resolve(projectRoot);
+          resolved = path65.resolve(projectRoot);
         }
         if (this.initialized && resolved === this.projectRoot) return;
         if (this.initialized) await this.close();
         const filename = this.options.filename ?? "memory.db";
-        if (path64.basename(filename) !== filename || filename === "." || filename === "..") {
+        if (path65.basename(filename) !== filename || filename === "." || filename === "..") {
           throw new Error("SQLite memory filename must not contain a path.");
         }
-        const zelariDirectory = path64.join(resolved, ".zelari");
-        const directory = path64.join(zelariDirectory, "memory");
+        const zelariDirectory = path65.join(resolved, ".zelari");
+        const directory = path65.join(zelariDirectory, "memory");
         for (const candidate of [zelariDirectory, directory]) {
           let stat7;
           try {
-            stat7 = await fs27.lstat(candidate);
+            stat7 = await fs28.lstat(candidate);
           } catch (error51) {
             if (error51.code !== "ENOENT") throw error51;
             try {
-              await fs27.mkdir(candidate);
+              await fs28.mkdir(candidate);
             } catch (mkdirError) {
               if (mkdirError.code !== "EEXIST") throw mkdirError;
             }
-            stat7 = await fs27.lstat(candidate);
+            stat7 = await fs28.lstat(candidate);
           }
           if (stat7.isSymbolicLink() || !stat7.isDirectory()) {
             throw new Error(`Memory directory is not a real directory: ${candidate}`);
           }
         }
-        const canonicalDirectory = await fs27.realpath(directory);
-        const relativeDirectory = path64.relative(resolved, canonicalDirectory);
-        if (relativeDirectory.startsWith("..") || path64.isAbsolute(relativeDirectory)) {
+        const canonicalDirectory = await fs28.realpath(directory);
+        const relativeDirectory = path65.relative(resolved, canonicalDirectory);
+        if (relativeDirectory.startsWith("..") || path65.isAbsolute(relativeDirectory)) {
           throw new Error("SQLite memory directory resolves outside the active project.");
         }
         this.projectRoot = resolved;
-        this.databasePath = path64.join(canonicalDirectory, filename);
+        this.databasePath = path65.join(canonicalDirectory, filename);
         const opened = await this.rpc.open({
           dbPath: this.databasePath,
           schemaSql: SQLITE_MEMORY_BASE_SCHEMA,
@@ -57134,8 +57481,8 @@ __export(serviceFactory_exports, {
   isMemoryV2Enabled: () => isMemoryV2Enabled
 });
 import { createHash as createHash20 } from "node:crypto";
-import { promises as fs28 } from "node:fs";
-import * as path65 from "node:path";
+import { promises as fs29 } from "node:fs";
+import * as path66 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;
@@ -57154,9 +57501,9 @@ function semanticMinScore(env) {
 async function canonicalProjectId(projectRoot) {
   let canonical;
   try {
-    canonical = await fs28.realpath(projectRoot);
+    canonical = await fs29.realpath(projectRoot);
   } catch {
-    canonical = path65.resolve(projectRoot);
+    canonical = path66.resolve(projectRoot);
   }
   canonical = canonical.replace(/\\/g, "/").replace(/\/$/, "");
   if (process.platform === "win32") canonical = canonical.toLocaleLowerCase("en-US");
@@ -57882,8 +58229,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path93 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path93);
+  const path94 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path94);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -58061,7 +58408,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path93 = join31(ctx.rootDir, "milestones", `${id3}.md`);
+  const path94 = join31(ctx.rootDir, "milestones", `${id3}.md`);
   const meta3 = {
     kind: "milestone",
     id: id3,
@@ -58078,7 +58425,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path93, meta3, body);
+  ctx.storage.write(path94, meta3, body);
   return { id: id3, created: true };
 }
 function readPlanSummary(ctx) {
@@ -58282,7 +58629,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id3 = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path93 = workspaceArtifact(ctx.rootDir, "decisions", id3);
+        const path94 = workspaceArtifact(ctx.rootDir, "decisions", id3);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -58308,7 +58655,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path93, meta3, body);
+        ctx.storage.write(path94, meta3, body);
         return `ADR ${id3} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -58390,14 +58737,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path93 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path94 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path93, meta3, content);
+        ctx.storage.write(path94, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -59023,10 +59370,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join32(projectRoot, ".zelari", "mcp.json");
 }
-function readFile7(path93) {
-  if (!existsSync39(path93)) return {};
+function readFile7(path94) {
+  if (!existsSync39(path94)) return {};
   try {
-    const parsed = JSON.parse(readFileSync29(path93, "utf8"));
+    const parsed = JSON.parse(readFileSync29(path94, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       const hasCommand = !!cfg && typeof cfg.command === "string" && !!cfg.command.trim();
@@ -59048,10 +59395,10 @@ function readFile7(path93) {
     return {};
   }
 }
-function writeFile3(path93, servers) {
-  mkdirSync16(dirname9(path93), { recursive: true });
+function writeFile3(path94, servers) {
+  mkdirSync16(dirname9(path94), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync18(path93, `${JSON.stringify(body, null, 2)}
+  writeFileSync18(path94, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -59089,9 +59436,9 @@ function upsertMcpServer(opts) {
       error: "either command (stdio) or url (http) is required"
     };
   }
-  let path93;
+  let path94;
   if (opts.scope === "user") {
-    path93 = getUserMcpPath();
+    path94 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -59100,9 +59447,9 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path93 = getProjectMcpPath(root);
+    path94 = getProjectMcpPath(root);
   }
-  const current = readFile7(path93);
+  const current = readFile7(path94);
   current[name] = {
     command: hasCommand ? opts.config.command.trim() : void 0,
     args: opts.config.args,
@@ -59113,21 +59460,21 @@ function upsertMcpServer(opts) {
     serial: opts.config.serial,
     enabled: opts.config.enabled !== false
   };
-  writeFile3(path93, current);
-  return { ok: true, path: path93 };
+  writeFile3(path94, current);
+  return { ok: true, path: path94 };
 }
 function removeMcpServer(opts) {
-  const path93 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path93) {
+  const path94 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path94) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile7(path93);
+  const current = readFile7(path94);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path93}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path94}` };
   }
   delete current[opts.name];
-  writeFile3(path93, current);
-  return { ok: true, path: path93 };
+  writeFile3(path94, current);
+  return { ok: true, path: path94 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -59596,10 +59943,10 @@ import { createHash as createHash21 } from "node:crypto";
 import { join as join34 } from "node:path";
 import { readFile as readFile8 } from "node:fs/promises";
 async function readPackageJson3(projectRoot) {
-  const path93 = join34(projectRoot, "package.json");
-  if (!existsSync41(path93)) return null;
+  const path94 = join34(projectRoot, "package.json");
+  if (!existsSync41(path94)) return null;
   try {
-    return JSON.parse(await readFile8(path93, "utf8"));
+    return JSON.parse(await readFile8(path94, "utf8"));
   } catch {
     return null;
   }
@@ -59681,9 +60028,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path93 = join34(ctx.rootDir, "risks.md");
-  if (!existsSync41(path93)) return "_No open questions._";
-  const content = readFileSync31(path93, "utf8");
+  const path94 = join34(ctx.rootDir, "risks.md");
+  if (!existsSync41(path94)) return "_No open questions._";
+  const content = readFileSync31(path94, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -59957,9 +60304,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path93) {
+function readFileSyncSafe(path94) {
   try {
-    return readFileSync32(path93, "utf8");
+    return readFileSync32(path94, "utf8");
   } catch {
     return null;
   }
@@ -60422,8 +60769,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path93 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path93, completion };
+      const path94 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path94, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -60462,13 +60809,13 @@ __export(councilFeedback_exports, {
   FeedbackStore: () => FeedbackStore
 });
 import {
-  promises as fs29,
+  promises as fs30,
   existsSync as existsSync45,
   readFileSync as readFileSync35,
   writeFileSync as writeFileSync21,
   mkdirSync as mkdirSync17
 } from "node:fs";
-import path66 from "node:path";
+import path67 from "node:path";
 import os10 from "node:os";
 var FeedbackStore;
 var init_councilFeedback = __esm({
@@ -60479,7 +60826,7 @@ var init_councilFeedback = __esm({
       now;
       entries = [];
       constructor(options = {}) {
-        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path66.join(os10.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
+        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path67.join(os10.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
         this.now = options.now ?? Date.now;
         this.load();
       }
@@ -60585,7 +60932,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync17(path66.dirname(this.file), { recursive: true });
+        mkdirSync17(path67.dirname(this.file), { recursive: true });
         writeFileSync21(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -60595,7 +60942,7 @@ var init_councilFeedback = __esm({
       /** Async variant of load for callers that prefer async IO. */
       async loadAsync() {
         try {
-          const raw = await fs29.readFile(this.file, "utf-8");
+          const raw = await fs30.readFile(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -60729,8 +61076,8 @@ __export(fileBackend_exports, {
   isMemoryEnabled: () => isMemoryEnabled
 });
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { promises as fs30 } from "node:fs";
-import * as path67 from "node:path";
+import { promises as fs31 } from "node:fs";
+import * as path68 from "node:path";
 function tokenize2(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -60783,9 +61130,9 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path67.join(projectRoot, ".zelari", "memory");
-        this.logPath = path67.join(this.memoryDir, "log.jsonl");
-        await fs30.mkdir(this.memoryDir, { recursive: true });
+        this.memoryDir = path68.join(projectRoot, ".zelari", "memory");
+        this.logPath = path68.join(this.memoryDir, "log.jsonl");
+        await fs31.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata2 = {}, graph) {
         const fact = {
@@ -60795,7 +61142,7 @@ var init_fileBackend = __esm({
           ...graph ? { graph } : {},
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await fs30.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
+        await fs31.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
         return fact.id;
       }
       async search(query, options = {}) {
@@ -60823,7 +61170,7 @@ var init_fileBackend = __esm({
       async readAll() {
         let raw;
         try {
-          raw = await fs30.readFile(this.logPath, "utf8");
+          raw = await fs31.readFile(this.logPath, "utf8");
         } catch {
           return [];
         }
@@ -60856,23 +61203,23 @@ var init_fileBackend = __esm({
 });
 
 // src/cli/traceStore.ts
-import { promises as fs31 } from "node:fs";
-import * as path68 from "node:path";
+import { promises as fs32 } from "node:fs";
+import * as path69 from "node:path";
 function traceDir(projectRoot) {
-  return path68.join(projectRoot, ".zelari", "trace");
+  return path69.join(projectRoot, ".zelari", "trace");
 }
 function tracePath(projectRoot, missionId) {
-  return path68.join(traceDir(projectRoot), `${missionId}.json`);
+  return path69.join(traceDir(projectRoot), `${missionId}.json`);
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
-  await fs31.mkdir(dir, { recursive: true });
+  await fs32.mkdir(dir, { recursive: true });
   const payload = {
     missionId,
     ts: Date.now(),
     entries
   };
-  await fs31.writeFile(
+  await fs32.writeFile(
     tracePath(projectRoot, missionId),
     JSON.stringify(payload, null, 2) + "\n",
     "utf8"
@@ -60898,8 +61245,8 @@ __export(zelariMission_exports, {
   runZelariMission: () => runZelariMission
 });
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { promises as fs32 } from "node:fs";
-import * as path69 from "node:path";
+import { promises as fs33 } from "node:fs";
+import * as path70 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;
@@ -60942,10 +61289,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state3) {
-  const dir = path69.join(projectRoot, ".zelari");
-  await fs32.mkdir(dir, { recursive: true });
-  await fs32.writeFile(
-    path69.join(dir, "mission-state.json"),
+  const dir = path70.join(projectRoot, ".zelari");
+  await fs33.mkdir(dir, { recursive: true });
+  await fs33.writeFile(
+    path70.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
   );
@@ -60965,7 +61312,7 @@ function buildSlicePrompt(brief, userMessage, runMode, iteration) {
   const fix = iteration > 1 ? " Address any remaining verification failures recorded in .zelari/completion.json." : "";
   return `${userMessage}
 
-[Zelari mission] Implement the MVP slice: ${brief.deliverableThisMission}.${fix} You MUST create or modify the real project files with write_file / edit_file \u2014 not just describe them in prose. A run that claims completion without writing any file is a failed run and will not be accepted.`;
+[Zelari mission] Implement the MVP slice: ${brief.deliverableThisMission}.${fix} You MUST create or modify the real project files with write_file / edit \u2014 not just describe them in prose. A run that claims completion without writing any file is a failed run and will not be accepted.`;
 }
 function formatBriefForChat(brief) {
   const lines = [
@@ -61323,7 +61670,7 @@ function createWriteCounter() {
         if (id3) pending.delete(id3);
         if (!MUTATING.has(name) || event.isError) return;
         const result = String(event.result ?? "");
-        const zeroEdit = name === "edit_file" && /occurrencesReplaced["']?\s*[:=]\s*0\b|0 occurrence|no changes/i.test(
+        const zeroEdit = (name === "edit_file" || name === "edit") && /occurrencesReplaced["']?\s*[:=]\s*0\b|0 occurrence|no changes/i.test(
           result
         );
         if (!zeroEdit) state3.successfulWrites += 1;
@@ -61381,7 +61728,7 @@ async function runAgentMissionSlice(deps) {
     "",
     "# Work phase: BUILD (Zelari mission implementation slice)",
     "IMPLEMENT ON DISK. Prior design under .zelari/ is a SPEC, not proof of delivery.",
-    "You MUST call write_file and/or edit_file before claiming done."
+    "You MUST call write_file and/or edit before claiming done."
   ].join("\n");
   const headlessRole = {
     id: "mission-agent",
@@ -61597,8 +61944,8 @@ var init_missionSlice = __esm({
     init_envNumber();
     init_modelPricing();
     init_delegationPolicy();
-    MUTATING = /* @__PURE__ */ new Set(["write_file", "edit_file", "apply_diff"]);
-    AGENT_MISSION_IMPLEMENTER_PREAMBLE = "You are the sole implementer for this Zelari mission slice. A multi-agent council may already have produced a plan under `.zelari/` \u2014 treat it as a SPEC to apply on disk. You MUST create or modify real project files with write_file / edit_file. Prose without successful writes is a failed slice.";
+    MUTATING = /* @__PURE__ */ new Set(["write_file", "edit", "edit_file", "apply_diff"]);
+    AGENT_MISSION_IMPLEMENTER_PREAMBLE = "You are the sole implementer for this Zelari mission slice. A multi-agent council may already have produced a plan under `.zelari/` \u2014 treat it as a SPEC to apply on disk. You MUST create or modify real project files with write_file / edit. Prose without successful writes is a failed slice.";
   }
 });
 
@@ -61620,7 +61967,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path93 = safeSocketPath(socketPath);
+  const path94 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -61720,10 +62067,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve9, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path93, () => {
+    server.listen(path94, () => {
       server.removeListener("error", onError);
       resolve9({
-        socketPath: path93,
+        socketPath: path94,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -61734,7 +62081,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path93, () => res());
+              unlink(path94, () => res());
             } else {
               res();
             }
@@ -61747,11 +62094,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path93 = safeSocketPath(socketPath);
+  const path94 = 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(path93);
+    const socket = connect(path94);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -61766,7 +62113,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path93}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path94}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -61906,7 +62253,7 @@ var init_brokerHandlers = __esm({
 // src/cli/gitOps.ts
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import path70 from "node:path";
+import path71 from "node:path";
 async function git5(cwd, args) {
   try {
     const { stdout } = await execFileAsync4("git", ["-C", cwd, ...args], {
@@ -61951,7 +62298,7 @@ async function undoWorkingChanges(opts = {}) {
   };
 }
 function defaultProjectRoot() {
-  return path70.resolve(__dirname, "..", "..", "..");
+  return path71.resolve(__dirname, "..", "..", "..");
 }
 var execFileAsync4;
 var init_gitOps = __esm({
@@ -62944,10 +63291,10 @@ var init_prereqChecks = __esm({
 
 // src/cli/plugins/prefs.ts
 import { existsSync as existsSync47, readFileSync as readFileSync36, writeFileSync as writeFileSync22, mkdirSync as mkdirSync18 } from "node:fs";
-import path75 from "node:path";
+import path76 from "node:path";
 import os11 from "node:os";
 function getPluginPrefsPath() {
-  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path75.join(os11.homedir(), ".tmp", "zelari-code", "plugins.json");
+  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path76.join(os11.homedir(), ".tmp", "zelari-code", "plugins.json");
 }
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
@@ -62968,7 +63315,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync18(path75.dirname(file2), { recursive: true });
+  mkdirSync18(path76.dirname(file2), { recursive: true });
   writeFileSync22(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -63005,7 +63352,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync48 } from "node:fs";
-import path76 from "node:path";
+import path77 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -63023,7 +63370,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync48;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path76.win32 : path76.posix;
+  const pathMod = platform === "win32" ? path77.win32 : path77.posix;
   const sep4 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep4).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -64117,11 +64464,11 @@ var init_policy = __esm({
 });
 
 // src/cli/orchestration/facts.ts
-import { promises as fs42 } from "node:fs";
-import path81 from "node:path";
+import { promises as fs43 } from "node:fs";
+import path82 from "node:path";
 async function collectRepoFileCount(root = process.cwd()) {
   try {
-    await fs42.readdir(root);
+    await fs43.readdir(root);
   } catch {
     return void 0;
   }
@@ -64132,13 +64479,13 @@ async function collectRepoFileCount(root = process.cwd()) {
       const dir = queue.pop();
       let entries;
       try {
-        entries = await fs42.readdir(dir, { withFileTypes: true });
+        entries = await fs43.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const e of entries) {
         if (e.isDirectory()) {
-          if (!SKIP_DIRS.has(e.name)) queue.push(path81.join(dir, e.name));
+          if (!SKIP_DIRS.has(e.name)) queue.push(path82.join(dir, e.name));
         } else if (e.isFile()) {
           count++;
           if (count > MAX_WALK_FILES) return count;
@@ -64235,8 +64582,8 @@ var init_streamScrub = __esm({
 });
 
 // src/cli/harnessState.ts
-import path82 from "node:path";
-function asString3(v) {
+import path83 from "node:path";
+function asString4(v) {
   return typeof v === "string" ? v : "";
 }
 function asNumber2(v) {
@@ -64246,7 +64593,7 @@ function asCallId(v, seq) {
   return typeof v === "string" && v.length > 0 ? v : `seq:${seq}`;
 }
 function parseProjection(data) {
-  const policy = asString3(data.policy);
+  const policy = asString4(data.policy);
   return {
     contextChars: asNumber2(data.contextChars) ?? 0,
     returnedCount: asNumber2(data.returnedCount) ?? 0,
@@ -64255,7 +64602,7 @@ function parseProjection(data) {
     contextLimit: asNumber2(data.contextLimit),
     contextPressureTokens: asNumber2(data.contextPressureTokens),
     durationMs: asNumber2(data.durationMs),
-    backend: asString3(data.backend) || void 0,
+    backend: asString4(data.backend) || void 0,
     policy: policy === "ok" || policy === "warn" || policy === "compact" || policy === "hard" ? policy : void 0
   };
 }
@@ -64290,7 +64637,7 @@ function deriveHarnessState(events) {
         break;
       case "session.ended": {
         session.endedAt = e.ts;
-        const reason = asString3(e.data.reason);
+        const reason = asString4(e.data.reason);
         session.status = reason.length > 0 ? reason : "ended";
         if (current) {
           current.closedBy = "session-ended";
@@ -64301,14 +64648,14 @@ function deriveHarnessState(events) {
       }
       case "user.message": {
         if (current) current.closedBy = "next-turn";
-        current = newTurn(acc.length + 1, asString3(e.data.text));
+        current = newTurn(acc.length + 1, asString4(e.data.text));
         acc.push(current);
         break;
       }
       case "assistant.message": {
         if (!current) break;
         current.assistantMessages += 1;
-        const text = asString3(e.data.text);
+        const text = asString4(e.data.text);
         current.assistantChars = (current.assistantChars ?? 0) + text.length;
         current.assistantText = text;
         break;
@@ -64316,7 +64663,7 @@ function deriveHarnessState(events) {
       case "tool.call": {
         if (!current) break;
         current.toolCalls += 1;
-        const tool = asString3(e.data.tool);
+        const tool = asString4(e.data.tool);
         if (tool.length > 0 && !current.toolKinds.includes(tool)) current.toolKinds.push(tool);
         current.unsettledCallIds.add(asCallId(e.data.callId, e.seq));
         break;
@@ -64334,7 +64681,7 @@ function deriveHarnessState(events) {
         if (!current) break;
         current.verification = {
           strict: e.data.strict === true,
-          verdict: asString3(e.data.verdict) || "unknown"
+          verdict: asString4(e.data.verdict) || "unknown"
         };
         break;
       }
@@ -64345,7 +64692,7 @@ function deriveHarnessState(events) {
         break;
       }
       case "note": {
-        const subject = asString3(e.data.subject);
+        const subject = asString4(e.data.subject);
         if (subject === "context.projection") {
           support.contextProjections.push(parseProjection(e.data));
         } else if (subject === "memory_event") {
@@ -64410,7 +64757,7 @@ function contractFor(t) {
   };
 }
 async function readHarnessState(sessionDir) {
-  const report = await readSessionLog(path82.join(sessionDir, "events.jsonl"));
+  const report = await readSessionLog(path83.join(sessionDir, "events.jsonl"));
   return deriveHarnessState(report.events);
 }
 var init_harnessState = __esm({
@@ -64421,12 +64768,12 @@ var init_harnessState = __esm({
 });
 
 // src/cli/headless/harnessStateEmit.ts
-import path83 from "node:path";
+import path84 from "node:path";
 async function emitHarnessStateEvent(opts) {
   if (opts.output !== "json") return;
   try {
     const sessionsDir = resolveSessionsDir({ workspaceRoot: opts.workspaceRoot });
-    const state3 = await readHarnessState(path83.join(sessionsDir, opts.spine.sessionId));
+    const state3 = await readHarnessState(path84.join(sessionsDir, opts.spine.sessionId));
     opts.emitEvent({ type: "harness_state", ...state3 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -64921,13 +65268,13 @@ var init_sessionControl = __esm({
 
 // src/cli/extensions/sandboxedFs.ts
 import { promises as fsp } from "node:fs";
-import path84 from "node:path";
+import path85 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 = path84.resolve(root);
+  const resolvedRoot = path85.resolve(root);
   return {
     root: resolvedRoot,
     async readFile(relativePath) {
@@ -64943,7 +65290,7 @@ function bindSandboxedFs(root) {
       try {
         const target = resolveSandboxedPath(relativePath, { root: resolvedRoot });
         verifyContainment(target, { root: resolvedRoot });
-        await fsp.mkdir(path84.dirname(target), { recursive: true });
+        await fsp.mkdir(path85.dirname(target), { recursive: true });
         await fsp.writeFile(target, data, "utf8");
         return typedOk({ path: target });
       } catch (err) {
@@ -65013,7 +65360,7 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
     skipped
   };
   const fsRoot = options.fsRoot ?? process.cwd();
-  let fs47 = null;
+  let fs48 = null;
   const pending = [];
   for (const dir of dirs) {
     const files = candidateFiles(dir.path);
@@ -65068,9 +65415,9 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
       skipped.push(`${file2}: missing ZelariExtension export`);
       continue;
     }
-    if (!fs47) fs47 = bindSandboxedFs(fsRoot);
+    if (!fs48) fs48 = bindSandboxedFs(fsRoot);
     try {
-      await runtime.registry.registerExtension(ext, { fs: fs47 });
+      await runtime.registry.registerExtension(ext, { fs: fs48 });
       runtime.loaded.push({ id: ext.id, file: file2, scope });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -65127,8 +65474,8 @@ var init_loader = __esm({
 });
 
 // src/cli/headless/runOneTurn.ts
-import { promises as fs43 } from "node:fs";
-import path85 from "node:path";
+import { promises as fs44 } from "node:fs";
+import path86 from "node:path";
 function planModeFromOpts(opts) {
   return (opts.phase ?? "build") === "plan";
 }
@@ -65341,13 +65688,13 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
         `# Work phase: ${opts.phase ?? "build"}`,
         (opts.phase ?? "build") === "plan" ? [
           "PLAN phase: explore and design only.",
-          "Do not write project source files (write_file/edit_file/bash blocked).",
+          "Do not write project source files (write_file/edit/bash blocked).",
           "Plan artifacts under .zelari are allowed.",
           "When the plan is ready, tell the user to switch to BUILD to implement on disk."
         ].join(" ") : [
           "BUILD phase \u2014 IMPLEMENT ON DISK (mandatory when the user wants code/file changes).",
           "Prior chat may contain a plan or synthesis: that text is a SPEC to apply, NOT proof that files already changed.",
-          "You MUST call write_file and/or edit_file for every file you change before saying you are done.",
+          "You MUST call write_file and/or edit for every file you change before saying you are done.",
           "After read_file: if the planned change is missing, WRITE it \u2014 do not stop at analysis.",
           'Never claim "already implemented" / "tutto fatto" based only on reading a plan or skimming code.',
           "Only claim done after successful mutating tool calls in THIS turn (or after proving the exact planned diff already exists on disk via read_file of the real files)."
@@ -65696,8 +66043,8 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs43.mkdir(path85.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-          await fs43.writeFile(opts.exportSessionPath, json3, "utf8");
+          await fs44.mkdir(path86.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs44.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
     } catch {
@@ -65841,6 +66188,8 @@ var init_policy2 = __esm({
     DEFAULT_WALL_MS = 45 * 60 * 1e3;
     GAUNTLET_PARENT_BLOCKED_TOOLS = [
       "write_file",
+      "edit",
+      // ADR-0033 t77: legacy names stay blocked (past sessions may replay them).
       "edit_file",
       "apply_diff",
       "bash"
@@ -66672,10 +67021,10 @@ __export(triggerLock_exports, {
   lockPath: () => lockPath,
   releaseLock: () => releaseLock
 });
-import { promises as fs44 } from "node:fs";
-import * as path86 from "node:path";
+import { promises as fs45 } from "node:fs";
+import * as path87 from "node:path";
 function lockPath(projectRoot) {
-  return path86.join(projectRoot, ".zelari", "trigger.lock");
+  return path87.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -66688,10 +67037,10 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path86.dirname(lp);
-  await fs44.mkdir(dir, { recursive: true });
+  const dir = path87.dirname(lp);
+  await fs45.mkdir(dir, { recursive: true });
   try {
-    const raw = await fs44.readFile(lp, "utf8");
+    const raw = await fs45.readFile(lp, "utf8");
     const existing = JSON.parse(raw);
     if (existing.pid && isPidAlive(existing.pid)) {
       return { acquired: false, heldBy: existing.pid, lockPath: lp };
@@ -66702,13 +67051,13 @@ async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date())
     pid: process.pid,
     acquiredAt: now().toISOString()
   };
-  await fs44.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  await fs45.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
   return { acquired: true, lockPath: lp };
 }
 async function releaseLock(projectRoot) {
   const lp = lockPath(projectRoot);
   try {
-    await fs44.unlink(lp);
+    await fs45.unlink(lp);
   } catch {
   }
 }
@@ -66719,8 +67068,8 @@ var init_triggerLock = __esm({
 });
 
 // src/cli/runHeadless.ts
-import { promises as fs45 } from "node:fs";
-import path87 from "node:path";
+import { promises as fs46 } from "node:fs";
+import path88 from "node:path";
 import { randomUUID as randomUUID10 } from "node:crypto";
 async function runHeadless(opts) {
   resetTaskSpawnCount();
@@ -66964,11 +67313,11 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   try {
     let preflightGraph;
     if (opts.runPlan && opts.runPlan.trim() !== "") {
-      const planPath = path87.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      const planPath = path88.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
-        raw = await fs45.readFile(planPath, "utf8");
+        raw = await fs46.readFile(planPath, "utf8");
       } catch (e) {
         log(`plan file not found: ${planPath} (${e.message})`);
         exitCode = 1;
@@ -67007,10 +67356,10 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
       const planId = randomUUID10();
-      const planDir = path87.join(cwd, ".zelari", "radio");
-      const planPath = path87.join(planDir, `plan-${planId}.json`);
-      await fs45.mkdir(planDir, { recursive: true });
-      await fs45.writeFile(
+      const planDir = path88.join(cwd, ".zelari", "radio");
+      const planPath = path88.join(planDir, `plan-${planId}.json`);
+      await fs46.mkdir(planDir, { recursive: true });
+      await fs46.writeFile(
         planPath,
         JSON.stringify(
           { id: graph.id, nodes: [...graph.nodes.values()] },
@@ -67355,8 +67704,8 @@ async function runHeadlessCouncil(opts, provider, model, providerStream, extras)
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs45.mkdir(path87.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-          await fs45.writeFile(opts.exportSessionPath, json3, "utf8");
+          await fs46.mkdir(path88.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs46.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
     } catch {
@@ -67579,7 +67928,7 @@ ${ragContext}` : slicePrompt;
             }
             if (event.type === "tool_execution_end") {
               const name = event.toolName ?? event.name ?? "";
-              if (name === "write_file" || name === "edit_file" || name === "apply_diff") {
+              if (name === "write_file" || name === "edit" || name === "edit_file" || name === "apply_diff") {
                 writeCount += 1;
               }
             }
@@ -67782,8 +68131,8 @@ ${ragContext}` : slicePrompt;
         if (json3) {
           if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
           else {
-            await fs45.mkdir(path87.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-            await fs45.writeFile(opts.exportSessionPath, json3, "utf8");
+            await fs46.mkdir(path88.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs46.writeFile(opts.exportSessionPath, json3, "utf8");
           }
         }
       } catch {
@@ -68395,7 +68744,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path93 = skillFilePath(dir, name);
+  const path94 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -68404,13 +68753,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path93);
+  const parsed = parseSkillMd(content, path94);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync21(dirname13(path93), { recursive: true });
-  writeFileSync24(path93, content, "utf8");
-  return { ok: true, path: path93 };
+  mkdirSync21(dirname13(path94), { recursive: true });
+  writeFileSync24(path94, content, "utf8");
+  return { ok: true, path: path94 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -68428,8 +68777,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join46(dir, name);
-  const path93 = skillFilePath(dir, name);
-  if (!existsSync53(path93) && !existsSync53(skillDir)) {
+  const path94 = skillFilePath(dir, name);
+  if (!existsSync53(path94) && !existsSync53(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -68440,7 +68789,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path93 };
+  return { ok: true, path: path94 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -68560,7 +68909,7 @@ var init_jsonApi = __esm({
 });
 
 // src/cli/memory/mcpAdapter.ts
-import * as path88 from "node:path";
+import * as path89 from "node:path";
 var id2, projectId, source, SearchSchema, AddSchema, LinkSchema, RetractSchema, MEMORY_MCP_TOOLS, MemoryMcpAdapter;
 var init_mcpAdapter = __esm({
   "src/cli/memory/mcpAdapter.ts"() {
@@ -68730,8 +69079,8 @@ var init_mcpAdapter = __esm({
         this.takeWrite();
         const externalFile = args.source?.file;
         if (externalFile) {
-          const normalized = path88.normalize(externalFile);
-          if (path88.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path88.sep}`)) {
+          const normalized = path89.normalize(externalFile);
+          if (path89.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path89.sep}`)) {
             throw new Error("source.file must be project-relative and cannot escape the project");
           }
         }
@@ -69259,12 +69608,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path93 = getCompanionConfigPath();
-  if (!existsSync54(path93)) {
+  const path94 = getCompanionConfigPath();
+  if (!existsSync54(path94)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync41(path93, "utf8"));
+    const raw = JSON.parse(readFileSync41(path94, "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) => ({
@@ -69302,16 +69651,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path93 = getCompanionTokenPath();
-  if (existsSync54(path93)) {
-    const t = readFileSync41(path93, "utf8").trim();
+  const path94 = getCompanionTokenPath();
+  if (existsSync54(path94)) {
+    const t = readFileSync41(path94, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes7(24).toString("base64url");
-  writeFileSync25(path93, token + "\n", "utf8");
+  writeFileSync25(path94, token + "\n", "utf8");
   try {
-    const fs47 = __require("node:fs");
-    fs47.chmodSync?.(path93, 384);
+    const fs48 = __require("node:fs");
+    fs48.chmodSync?.(path94, 384);
   } catch {
   }
   return { token, created: true };
@@ -69336,17 +69685,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path93 = raw.trim();
-    if (!path93) continue;
-    let id3 = slugFromPath(path93);
+    const path94 = raw.trim();
+    if (!path94) continue;
+    let id3 = slugFromPath(path94);
     let n = 2;
-    while (byId.has(id3) && byId.get(id3).path !== path93) {
-      id3 = `${slugFromPath(path93)}-${n++}`;
+    while (byId.has(id3) && byId.get(id3).path !== path94) {
+      id3 = `${slugFromPath(path94)}-${n++}`;
     }
     byId.set(id3, {
       id: id3,
-      name: slugFromPath(path93),
-      path: path93
+      name: slugFromPath(path94),
+      path: path94
     });
   }
   return [...byId.values()];
@@ -69394,8 +69743,8 @@ var init_config = __esm({
 });
 
 // src/cli/serve/spineLockSweep.ts
-import { promises as fs46 } from "node:fs";
-import path89 from "node:path";
+import { promises as fs47 } from "node:fs";
+import path90 from "node:path";
 async function sweepOrphanSpineLocks(sessionsDir, options = {}) {
   const dir = sessionsDir ?? resolveSessionsDir();
   const onSwept = options.onSwept ?? ((sessionId2, reason) => {
@@ -69408,14 +69757,14 @@ async function sweepOrphanSpineLocks(sessionsDir, options = {}) {
   const result = { swept: 0, kept: 0, errors: 0 };
   let entries;
   try {
-    entries = await fs46.readdir(dir);
+    entries = await fs47.readdir(dir);
   } catch {
     return result;
   }
   for (const sessionId2 of entries) {
-    const lockPath2 = path89.join(dir, sessionId2, "writer.lock");
+    const lockPath2 = path90.join(dir, sessionId2, "writer.lock");
     try {
-      const raw = await fs46.readFile(lockPath2, "utf-8");
+      const raw = await fs47.readFile(lockPath2, "utf-8");
       let lockInfo = {};
       try {
         lockInfo = JSON.parse(raw);
@@ -69432,7 +69781,7 @@ async function sweepOrphanSpineLocks(sessionsDir, options = {}) {
         result.kept += 1;
         continue;
       }
-      await fs46.rm(lockPath2, { force: true });
+      await fs47.rm(lockPath2, { force: true });
       result.swept += 1;
       onSwept(sessionId2, verdict.reason);
     } catch (err) {
@@ -70383,9 +70732,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path93 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path94 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path93 === "/health" || path93 === "/v1/health")) {
+      if (req.method === "GET" && (path94 === "/health" || path94 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -70397,18 +70746,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path93.startsWith("/v1")) {
+      if (path94.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path93 === "/v1/config") {
+      if (req.method === "GET" && path94 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path93 === "/v1/projects") {
+      if (req.method === "GET" && path94 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -70419,7 +70768,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path93 === "/v1/runs") {
+      if (req.method === "GET" && path94 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -70437,7 +70786,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path93 === "/v1/runs") {
+      if (req.method === "POST" && path94 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -70485,7 +70834,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path93);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path94);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -70550,7 +70899,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path93);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path94);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -70561,7 +70910,7 @@ async function runCompanionServe(opts = {}) {
         sendJson2(res, 200, { ok: true, cancelled: runId });
         return;
       }
-      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path93);
+      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path94);
       if (req.method === "POST" && steerMatch) {
         const runId = steerMatch[1];
         const raw = await readBody(req);
@@ -70728,11 +71077,11 @@ import { execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync56, readFileSync as readFileSync42, readlinkSync, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path90 from "node:path";
+import path91 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path90.join(dir, "package.json");
+    const candidate = path91.join(dir, "package.json");
     if (existsSync56(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync42(candidate, "utf8"));
@@ -70740,11 +71089,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path90.dirname(dir);
+    const parent = path91.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path90.resolve(__dirname3, "..", "..", "..");
+  return path91.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -70758,7 +71107,7 @@ function tryExec(cmd) {
 }
 function readPackageJson4() {
   try {
-    const pkgPath = path90.join(packageRoot, "package.json");
+    const pkgPath = path91.join(packageRoot, "package.json");
     return JSON.parse(readFileSync42(pkgPath, "utf8"));
   } catch {
     return null;
@@ -70774,7 +71123,7 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path90.join(prefix, shimName);
+  const shimPath = path91.join(prefix, shimName);
   if (!existsSync56(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
@@ -70802,8 +71151,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path90.resolve(path90.dirname(shimPath), target);
-    const expected = path90.join(
+    const resolved = path91.resolve(path91.dirname(shimPath), target);
+    const expected = path91.join(
       prefix,
       "node_modules",
       pkgName,
@@ -70845,7 +71194,7 @@ function checkNode(pkg) {
   return OK(`node ${raw} (engines.node ${enginesNode ?? ">= 20.0.0"})`);
 }
 function checkBundle() {
-  const bundle = path90.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path91.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync56(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -70866,7 +71215,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path90.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path91.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -71066,7 +71415,7 @@ var init_doctor = __esm({
     init_metrics3();
     init_contextGrowthSummary();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path90.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path91.dirname(fileURLToPath3(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -71250,7 +71599,7 @@ __export(inspectSession_exports, {
   renderInspectReport: () => renderInspectReport,
   runInspectSession: () => runInspectSession
 });
-import path91 from "node:path";
+import path92 from "node:path";
 import { existsSync as existsSync57 } from "node:fs";
 function formatLimit(limit) {
   return `${Math.round(limit / 1e3)}k`;
@@ -71284,8 +71633,8 @@ function renderInspectReport(state3) {
 }
 async function runInspectSession(opts) {
   const sessionsDir = resolveSessionsDir({ workspaceRoot: opts.cwd ?? process.cwd() });
-  const sessionDir = path91.join(sessionsDir, opts.sessionId);
-  const eventsPath = path91.join(sessionDir, "events.jsonl");
+  const sessionDir = path92.join(sessionsDir, opts.sessionId);
+  const eventsPath = path92.join(sessionDir, "events.jsonl");
   if (!existsSync57(sessionDir)) {
     console.error(`zelari-code inspect: no session directory at ${sessionDir}`);
     return 1;
@@ -71319,15 +71668,15 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path92 from "node:path";
+import path93 from "node:path";
 import { existsSync as existsSync58, readFileSync as readFileSync43, readdirSync as readdirSync12 } from "node:fs";
 import { homedir as homedir17 } from "node:os";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
   const snap = listSkillsSnapshot(cwd);
   const mcp = listMcpServers(cwd);
-  const userMcpPath = path92.join(homedir17(), ".zelari-code", "mcp.json");
-  const projectMcpPath = path92.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path93.join(homedir17(), ".zelari-code", "mcp.json");
+  const projectMcpPath = path93.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -71355,9 +71704,9 @@ async function collectInspectReport(cwd = process.cwd()) {
     configSources: [
       { path: userMcpPath, exists: existsSync58(userMcpPath) },
       { path: projectMcpPath, exists: existsSync58(projectMcpPath) },
-      { path: path92.join(homedir17(), ".zelari-code", "provider.json"), exists: existsSync58(path92.join(homedir17(), ".zelari-code", "provider.json")) },
-      { path: path92.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync58(path92.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path92.join(cwd, "AGENTS.md"), exists: existsSync58(path92.join(cwd, "AGENTS.md")) }
+      { path: path93.join(homedir17(), ".zelari-code", "provider.json"), exists: existsSync58(path93.join(homedir17(), ".zelari-code", "provider.json")) },
+      { path: path93.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync58(path93.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path93.join(cwd, "AGENTS.md"), exists: existsSync58(path93.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -71397,8 +71746,8 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path92.join(cwd, "AGENTS.md"),
-    path92.join(cwd, ".zelari", "AGENTS.md")
+    path93.join(cwd, "AGENTS.md"),
+    path93.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
@@ -74970,7 +75319,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           "# Work Phase: PLAN",
           "You are in PLAN mode. Explore and design only.",
           "- Do NOT implement production code or run destructive shell commands.",
-          "- write_file / edit_file / bash / apply_diff are unavailable.",
+          "- write_file / edit / bash are unavailable.",
           "- inspect_command IS available: allowlisted read-only inspector (no shell). Use it for git_status/git_log/git_diff/git_show/git_branch_current/git_ls_files/typecheck/node_version/npm_ls/npm_outdated/npm_view - it turns claims into execution-verified observations.",
           "- OBSERVATION INTEGRITY: negative evidence is valid only from a completed observation. Never conclude that code/symbols/files do not exist from degraded results, zero files examined, or unavailable backends (grep_content SEARCH_EMPTY_SCOPE, ast/LSP degraded status, inspect_command unsupported shapes).",
           "- Produce a clear plan, ask clarifying questions (---QUESTION---), use workspace plan tools when relevant.",
@@ -74979,7 +75328,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           "# Work Phase: BUILD",
           "Implement on disk. Prefer acting over describing.",
           "- Prior plan/synthesis text is a SPEC to apply \u2014 not proof files already changed.",
-          "- You MUST use write_file/edit_file for every file you change before claiming done.",
+          "- You MUST use write_file/edit for every file you change before claiming done.",
           "- After read_file: if the planned change is missing, WRITE it \u2014 do not stop at analysis.",
           "- Never claim already-implemented based only on reading a plan or skimming code.",
           hasPlan ? "- A draft plan exists under .zelari/ \u2014 implement grounded tasks and update statuses; do not treat design docs as shipped code." : ""
@@ -75965,7 +76314,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
         streamMemberId = null;
         membersCompleted++;
       } else if (event.type === "tool_execution_start") {
-        if (event.toolName === "write_file" || event.toolName === "edit_file") {
+        if (event.toolName === "write_file" || event.toolName === "edit_file" || event.toolName === "edit") {
           luciferWriteCount++;
         }
         if (streamContent) {
@@ -77590,12 +77939,12 @@ function handleCacheStats(ctx) {
 // src/cli/slashHandlers/memory.ts
 init_messageHelpers();
 init_serviceFactory();
-import { promises as fs34 } from "node:fs";
-import * as path72 from "node:path";
+import { promises as fs35 } from "node:fs";
+import * as path73 from "node:path";
 
 // src/cli/memory/promotion.ts
-import { promises as fs33 } from "node:fs";
-import * as path71 from "node:path";
+import { promises as fs34 } from "node:fs";
+import * as path72 from "node:path";
 var START = "<!-- zelari:memory-promotions:start -->";
 var END = "<!-- zelari:memory-promotions:end -->";
 var DURABLE_KINDS = /* @__PURE__ */ new Set(["fact", "decision", "constraint", "preference", "procedure"]);
@@ -77606,22 +77955,22 @@ function lineFor(node) {
 }
 async function promoteMemoryToAgentsMd(projectRoot, node) {
   if (node.status !== "active") {
-    return { added: false, path: path71.join(projectRoot, "AGENTS.md"), reason: `memory is ${node.status}` };
+    return { added: false, path: path72.join(projectRoot, "AGENTS.md"), reason: `memory is ${node.status}` };
   }
   if (!DURABLE_KINDS.has(node.kind)) {
-    return { added: false, path: path71.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
+    return { added: false, path: path72.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
   }
-  const root = await fs33.realpath(projectRoot).catch(() => path71.resolve(projectRoot));
-  const target = path71.join(root, "AGENTS.md");
+  const root = await fs34.realpath(projectRoot).catch(() => path72.resolve(projectRoot));
+  const target = path72.join(root, "AGENTS.md");
   try {
-    const stat7 = await fs33.lstat(target);
+    const stat7 = await fs34.lstat(target);
     if (stat7.isSymbolicLink() || !stat7.isFile()) throw new Error("AGENTS.md must be a regular project file.");
   } catch (error51) {
     if (error51.code !== "ENOENT") throw error51;
   }
   let current = "";
   try {
-    current = await fs33.readFile(target, "utf8");
+    current = await fs34.readFile(target, "utf8");
   } catch (error51) {
     if (error51.code !== "ENOENT") throw error51;
   }
@@ -77644,11 +77993,11 @@ ${END}
 `;
   }
   const temporary = `${target}.tmp-${process.pid}-${Date.now()}`;
-  await fs33.writeFile(temporary, updated, { encoding: "utf8", flag: "wx" });
+  await fs34.writeFile(temporary, updated, { encoding: "utf8", flag: "wx" });
   try {
-    await fs33.rename(temporary, target);
+    await fs34.rename(temporary, target);
   } catch (error51) {
-    await fs33.unlink(temporary).catch(() => void 0);
+    await fs34.unlink(temporary).catch(() => void 0);
     throw error51;
   }
   return { added: true, path: target };
@@ -77677,24 +78026,24 @@ function sourceLine(source2) {
   return entries.length ? entries.map(([key, value]) => `${key}=${value}`).join(" \xB7 ") : "unknown";
 }
 function isInside(root, target) {
-  const relative6 = path72.relative(root, target);
-  return relative6 === "" || !relative6.startsWith("..") && !path72.isAbsolute(relative6);
+  const relative6 = path73.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path73.isAbsolute(relative6);
 }
 async function safeExportPath(cwd, requested) {
-  const lexicalRoot = path72.resolve(cwd);
-  const root = await fs34.realpath(lexicalRoot).catch(() => lexicalRoot);
-  const fallback = path72.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
-  const target = requested?.trim() ? path72.resolve(root, requested.trim()) : fallback;
+  const lexicalRoot = path73.resolve(cwd);
+  const root = await fs35.realpath(lexicalRoot).catch(() => lexicalRoot);
+  const fallback = path73.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
+  const target = requested?.trim() ? path73.resolve(root, requested.trim()) : fallback;
   if (!isInside(root, target)) {
     throw new Error("Export path must stay inside the active project.");
   }
-  const parent = path72.dirname(target);
-  const relativeParent = path72.relative(root, parent);
+  const parent = path73.dirname(target);
+  const relativeParent = path73.relative(root, parent);
   let cursor = root;
-  for (const segment of relativeParent.split(path72.sep).filter(Boolean)) {
-    cursor = path72.join(cursor, segment);
+  for (const segment of relativeParent.split(path73.sep).filter(Boolean)) {
+    cursor = path73.join(cursor, segment);
     try {
-      const stat7 = await fs34.lstat(cursor);
+      const stat7 = await fs35.lstat(cursor);
       if (stat7.isSymbolicLink()) {
         throw new Error("Export path must not traverse a symbolic link.");
       }
@@ -77704,7 +78053,7 @@ async function safeExportPath(cwd, requested) {
     }
   }
   try {
-    if ((await fs34.lstat(target)).isSymbolicLink()) {
+    if ((await fs35.lstat(target)).isSymbolicLink()) {
       throw new Error("Export target must not be a symbolic link.");
     }
   } catch (error51) {
@@ -77864,13 +78213,13 @@ ${message}` : message
       }
       case "export": {
         const target = await safeExportPath(ctx.cwd, args.join(" ").trim() || void 0);
-        await fs34.mkdir(path72.dirname(target), { recursive: true });
-        const root = await fs34.realpath(ctx.cwd).catch(() => path72.resolve(ctx.cwd));
-        const realParent = await fs34.realpath(path72.dirname(target));
+        await fs35.mkdir(path73.dirname(target), { recursive: true });
+        const root = await fs35.realpath(ctx.cwd).catch(() => path73.resolve(ctx.cwd));
+        const realParent = await fs35.realpath(path73.dirname(target));
         if (!isInside(root, realParent)) {
           throw new Error("Export path resolves outside the active project.");
         }
-        await fs34.writeFile(target, JSON.stringify(await memory.export(), null, 2) + "\n", "utf8");
+        await fs35.writeFile(target, JSON.stringify(await memory.export(), null, 2) + "\n", "utf8");
         emit(`[memory] export written to ${target}`);
         return;
       }
@@ -78064,13 +78413,13 @@ ${digest}
 init_auditLogger();
 init_toolRegistry();
 init_messageHelpers();
-import { promises as fs36 } from "node:fs";
+import { promises as fs37 } from "node:fs";
 
 // src/cli/tools/krakenCsvFanout.ts
 init_zod();
 init_taskTool();
-import { promises as fs35 } from "node:fs";
-import path73 from "node:path";
+import { promises as fs36 } from "node:fs";
+import path74 from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
@@ -78091,7 +78440,7 @@ var CsvFanoutArgsSchema = external_exports.object({
   max_runtime_seconds: external_exports.number().int().positive().optional()
 });
 async function readCsv(filePath) {
-  const text = await fs35.readFile(filePath, "utf8");
+  const text = await fs36.readFile(filePath, "utf8");
   return parseCsv(text);
 }
 function parseCsv(text) {
@@ -78164,8 +78513,8 @@ function resolveMaxConcurrency(env = process.env) {
 }
 async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
-  const absCsv = path73.isAbsolute(args.csv_path) ? args.csv_path : path73.join(opts.parentCwd, args.csv_path);
-  const absOut = path73.isAbsolute(args.output_csv_path) ? args.output_csv_path : path73.join(opts.parentCwd, args.output_csv_path);
+  const absCsv = path74.isAbsolute(args.csv_path) ? args.csv_path : path74.join(opts.parentCwd, args.csv_path);
+  const absOut = path74.isAbsolute(args.output_csv_path) ? args.output_csv_path : path74.join(opts.parentCwd, args.output_csv_path);
   const { headers: headers2, rows } = await readCsv(absCsv);
   if (headers2.length === 0) {
     throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
@@ -78221,7 +78570,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs35.mkdir(path73.dirname(absOut), { recursive: true });
+      await fs36.mkdir(path74.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -78243,8 +78592,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 fs35.writeFile(tmp, contents, "utf8");
-  await fs35.rename(tmp, file2);
+  await fs36.writeFile(tmp, contents, "utf8");
+  await fs36.rename(tmp, file2);
 }
 
 // src/cli/slashHandlers/krakenFanout.ts
@@ -78342,7 +78691,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 fs36.access(absCsv);
+    await fs37.access(absCsv);
   } catch {
     appendSystem(ctx.setMessages, `[kraken fanout] source CSV not found: ${absCsv}`);
     return;
@@ -78415,8 +78764,8 @@ function splitArgs(s) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
-import { promises as fs37 } from "node:fs";
-import path74 from "node:path";
+import { promises as fs38 } from "node:fs";
+import path75 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
 var EMPTY = {
@@ -78533,15 +78882,15 @@ function formatWorkbenchForTerminal(p3) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 async function handleKrakenWorkbench(ctx) {
-  const dir = path74.join(ctx.cwd, ".zelari", "radio");
+  const dir = path75.join(ctx.cwd, ".zelari", "radio");
   let latest = null;
   let latestMtime = 0;
   try {
-    const files = await fs37.readdir(dir);
+    const files = await fs38.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
-      const full = path74.join(dir, f);
-      const stat7 = await fs37.stat(full);
+      const full = path75.join(dir, f);
+      const stat7 = await fs38.stat(full);
       if (stat7.mtimeMs > latestMtime) {
         latestMtime = stat7.mtimeMs;
         latest = full;
@@ -78553,14 +78902,14 @@ async function handleKrakenWorkbench(ctx) {
     appendSystem(ctx.setMessages, "[kraken workbench] no workbench file found (.zelari/radio/workbench-*.md)");
     return;
   }
-  const content = await fs37.readFile(latest, "utf8");
+  const content = await fs38.readFile(latest, "utf8");
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
-    appendSystem(ctx.setMessages, `[kraken workbench] ${path74.basename(latest)}: (no nodes / no events yet)`);
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path75.basename(latest)}: (no nodes / no events yet)`);
     return;
   }
-  appendSystem(ctx.setMessages, `[kraken workbench] ${path74.basename(latest)}:
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path75.basename(latest)}:
 ${rendered}`);
 }
 
@@ -78866,17 +79215,17 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 
 // src/cli/slashHandlers/promoteMember.ts
 init_messageHelpers();
-import { promises as fs38 } from "node:fs";
-import path77 from "node:path";
+import { promises as fs39 } from "node:fs";
+import path78 from "node:path";
 import os12 from "node:os";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
-    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path77.join(os12.homedir(), ".tmp", "zelari-code", "skills");
-    await fs38.mkdir(skillDir, { recursive: true });
-    const filePath = path77.join(skillDir, `${skill.id}.md`);
-    await fs38.writeFile(filePath, markdown, "utf8");
+    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path78.join(os12.homedir(), ".tmp", "zelari-code", "skills");
+    await fs39.mkdir(skillDir, { recursive: true });
+    const filePath = path78.join(skillDir, `${skill.id}.md`);
+    await fs39.writeFile(filePath, markdown, "utf8");
     appendSystem(
       ctx.setMessages,
       `[promote-member] ${skill.name} (${memberId}) \u2192 ${filePath}
@@ -78892,25 +79241,25 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs39, existsSync as existsSync49, readFileSync as readFileSync37, writeFileSync as writeFileSync23, mkdirSync as mkdirSync19, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
-import path78 from "node:path";
+import { promises as fs40, existsSync as existsSync49, readFileSync as readFileSync37, writeFileSync as writeFileSync23, mkdirSync as mkdirSync19, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
+import path79 from "node:path";
 import os13 from "node:os";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
-  return process.env.ANATHEMA_BRANCHES_DIR ?? path78.join(os13.homedir(), ".tmp", "zelari-code", "branches");
+  return process.env.ANATHEMA_BRANCHES_DIR ?? path79.join(os13.homedir(), ".tmp", "zelari-code", "branches");
 }
 function getSessionsBaseDir() {
-  return process.env.ANATHEMA_SESSIONS_DIR ?? path78.join(os13.homedir(), ".tmp", "zelari-code", "sessions");
+  return process.env.ANATHEMA_SESSIONS_DIR ?? path79.join(os13.homedir(), ".tmp", "zelari-code", "sessions");
 }
 function branchPathFor(name, baseDir) {
-  return path78.join(baseDir, name);
+  return path79.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path78.join(baseDir, name, META_FILENAME);
+  return path79.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path78.join(baseDir, name, SESSIONS_SUBDIR);
+  return path79.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -78935,13 +79284,13 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync19(path78.dirname(metaPath), { recursive: true });
+  mkdirSync19(path79.dirname(metaPath), { recursive: true });
   writeFileSync23(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
   try {
-    const entries = await fs39.readdir(sessionsPath);
+    const entries = await fs40.readdir(sessionsPath);
     return entries.filter((e) => e.endsWith(".jsonl")).length;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
@@ -78986,15 +79335,15 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path78.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path79.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync49(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync19(branchSessionsPath, { recursive: true });
-  const destPath = path78.join(branchSessionsPath, `${fromSessionId}.jsonl`);
-  await fs39.copyFile(sourcePath, destPath);
+  const destPath = path79.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  await fs40.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
     createdAt: Date.now(),
@@ -79012,7 +79361,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
 async function listBranches(baseDir = getBranchesBaseDir()) {
   let entries;
   try {
-    entries = await fs39.readdir(baseDir);
+    entries = await fs40.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -79096,26 +79445,26 @@ async function handleBranchCheckout(ctx, branchName) {
 
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
-import { promises as fs40 } from "node:fs";
-import path79 from "node:path";
+import { promises as fs41 } from "node:fs";
+import path80 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path79.join(process.cwd(), ".zelari");
+    const zelari = path80.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path79.join(zelari, "plan.md");
+        const planPath = path80.join(zelari, "plan.md");
         try {
-          content = await fs40.readFile(planPath, "utf-8");
+          content = await fs41.readFile(planPath, "utf-8");
         } catch {
           content = "(no plan.md yet \u2014 run a council session first)";
         }
         break;
       }
       case "decisions": {
-        const decisionsDir = path79.join(zelari, "decisions");
+        const decisionsDir = path80.join(zelari, "decisions");
         try {
-          const files = (await fs40.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs41.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
             content = "(no ADRs yet \u2014 invoke /council to generate some)";
           } else {
@@ -79123,7 +79472,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 fs40.readFile(path79.join(decisionsDir, f), "utf-8");
+              const raw = await fs41.readFile(path80.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}`);
@@ -79136,27 +79485,27 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path79.join(zelari, "risks.md");
+        const risksPath = path80.join(zelari, "risks.md");
         try {
-          content = await fs40.readFile(risksPath, "utf-8");
+          content = await fs41.readFile(risksPath, "utf-8");
         } catch {
           content = "(no risks.md yet)";
         }
         break;
       }
       case "agents": {
-        const agentsPath = path79.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path80.join(process.cwd(), "AGENTS.MD");
         try {
-          content = await fs40.readFile(agentsPath, "utf-8");
+          content = await fs41.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 = path79.join(zelari, "docs");
+        const docsDir = path80.join(zelari, "docs");
         try {
-          const files = (await fs40.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs41.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
 
 ` + files.map((f) => `- ${f}`).join("\n") : "(no docs drafts yet)";
@@ -79196,8 +79545,8 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path79.join(process.cwd(), ".zelari");
-    await fs40.rm(target, { recursive: true, force: true });
+    const target = path80.join(process.cwd(), ".zelari");
+    await fs41.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)}`);
@@ -79208,16 +79557,16 @@ async function handleWorkspaceReset(ctx, force) {
 init_provider2();
 
 // src/cli/slashHandlers/skills.ts
-import path80 from "node:path";
+import path81 from "node:path";
 import os14 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs41, existsSync as existsSync50, statSync as statSync8, renameSync as renameSync5, appendFileSync as appendFileSync4, mkdirSync as mkdirSync20 } from "node:fs";
+import { promises as fs42, existsSync as existsSync50, statSync as statSync8, renameSync as renameSync5, appendFileSync as appendFileSync4, mkdirSync as mkdirSync20 } from "node:fs";
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
   try {
-    raw = await fs41.readFile(file2, "utf-8");
+    raw = await fs42.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -79337,7 +79686,7 @@ function handleSkillPicker(ctx, skills, openPicker, fallbackMessage) {
   });
 }
 async function handleSkillStats(ctx, skillId) {
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path80.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path81.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const records = await readSkillHistory(historyFile);
     const stats = getSkillStats(records, skillId);
@@ -79353,7 +79702,7 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
     appendSystem(ctx.setMessages, fallbackMessage ?? "[skill-compare] missing args");
     return;
   }
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path80.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path81.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const formatted = await compareSkillsFromFile(ids[0], ids[1], historyFile);
     appendSystem(ctx.setMessages, formatted);
@@ -81054,8 +81403,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 path93 = 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 = path93 && /^[a-z0-9]/.test(path93) ? path93 : "imported-skill";
+      const path94 = 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 = path94 && /^[a-z0-9]/.test(path94) ? path94 : "imported-skill";
     } catch {
       name = "imported-skill";
     }