zelari-code 1.2.0 → 1.3.0

package/dist/cli/main.bundled.js

@@ -308,7 +308,7 @@ async function refreshGrokToken(options) {
   return parseTokenResponseBody(obj, accessToken);
 }
 async function openBrowser(url2) {
-  const { spawn: spawn7 } = await import("node:child_process");
+  const { spawn: spawn8 } = await import("node:child_process");
   const cmd = (() => {
     switch (process.platform) {
       case "darwin":
@@ -321,7 +321,7 @@ async function openBrowser(url2) {
   })();
   return new Promise((resolve, reject) => {
     try {
-      const child = spawn7(cmd.bin, cmd.args, {
+      const child = spawn8(cmd.bin, cmd.args, {
         stdio: "ignore",
         detached: true
       });
@@ -1535,10 +1535,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path27) {
-  if (!path27)
+function getElementAtPath(obj, path33) {
+  if (!path33)
     return obj;
-  return path27.reduce((acc, key) => acc?.[key], obj);
+  return path33.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1866,11 +1866,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path27, issues) {
+function prefixIssues(path33, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path27);
+    iss.path.unshift(path33);
     return iss;
   });
 }
@@ -2088,16 +2088,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path27 = []) => {
+  const processError = (error52, path33 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path27, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path33, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path27, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path33, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path27, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path33, ...issue2.path]);
       } else {
-        const fullpath = [...path27, ...issue2.path];
+        const fullpath = [...path33, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -2124,17 +2124,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path27 = []) => {
+  const processError = (error52, path33 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path27, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path33, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path27, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path33, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path27, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path33, ...issue2.path]);
       } else {
-        const fullpath = [...path27, ...issue2.path];
+        const fullpath = [...path33, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2166,8 +2166,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path27 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path27) {
+  const path33 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path33) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -15670,13 +15670,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path27 = ref.slice(1).split("/").filter(Boolean);
-  if (path27.length === 0) {
+  const path33 = ref.slice(1).split("/").filter(Boolean);
+  if (path33.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path27[0] === defsKey) {
-    const key = path27[1];
+  if (path33[0] === defsKey) {
+    const key = path33[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -16836,7 +16836,7 @@ var init_walk = __esm({
 // packages/core/dist/core/tools/builtin/search.js
 import { promises as fs6 } from "node:fs";
 import path7 from "node:path";
-async function searchFile(absPath, relPath, regex, contextLines, remainingSlots) {
+async function searchFile(absPath, relPath2, regex, contextLines, remainingSlots) {
   let buf;
   try {
     buf = await fs6.readFile(absPath, "utf-8");
@@ -16856,7 +16856,7 @@ async function searchFile(absPath, relPath, regex, contextLines, remainingSlots)
         const endAfter = Math.min(lines.length - 1, i + contextLines);
         matches.push({
           file: absPath,
-          relPath,
+          relPath: relPath2,
           line: i + 1,
           text: lines[i],
           context: {
@@ -17706,11 +17706,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path27 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path33 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path27,
+            path: path33,
             title,
             content,
             format: "markdown",
@@ -17719,7 +17719,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path27}".`;
+          return `Document "${title}" created at "${path33}".`;
         }
       }
     ];
@@ -20105,7 +20105,7 @@ var init_parseCssMotion = __esm({
 });
 
 // packages/core/dist/council/verification/citeVerify.js
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
 import { join } from "node:path";
 function extractCitations(text) {
   const out = [];
@@ -20129,7 +20129,7 @@ function verifyCitations(projectRoot, synthesisText) {
   const results = [];
   for (const cite of extractCitations(synthesisText)) {
     const abs = join(projectRoot, cite.file);
-    if (!existsSync8(abs)) {
+    if (!existsSync9(abs)) {
       results.push({
         id: "synthesis.cite-invalid",
         severity: "error",
@@ -20142,7 +20142,7 @@ function verifyCitations(projectRoot, synthesisText) {
       });
       continue;
     }
-    const lines = readFileSync5(abs, "utf8").split(/\r?\n/);
+    const lines = readFileSync7(abs, "utf8").split(/\r?\n/);
     if (cite.line > lines.length) {
       results.push({
         id: "synthesis.cite-invalid",
@@ -20405,14 +20405,14 @@ var init_synthesisAudit = __esm({
 });
 
 // packages/core/dist/council/verification/runChecks.js
-import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join2 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path27 = join2(zelariRoot, "nfr-spec.json");
-  if (!existsSync9(path27))
+  const path33 = join2(zelariRoot, "nfr-spec.json");
+  if (!existsSync10(path33))
     return null;
   try {
-    const raw = JSON.parse(readFileSync6(path27, "utf8"));
+    const raw = JSON.parse(readFileSync8(path33, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -20423,11 +20423,11 @@ function loadNfrSpec(zelariRoot) {
 function resolveTargets(projectRoot, spec) {
   const found = [];
   for (const rel2 of spec.targets) {
-    if (existsSync9(join2(projectRoot, rel2))) {
+    if (existsSync10(join2(projectRoot, rel2))) {
       found.push(rel2);
     }
   }
-  if (found.length === 0 && existsSync9(join2(projectRoot, "index.html"))) {
+  if (found.length === 0 && existsSync10(join2(projectRoot, "index.html"))) {
     return ["index.html"];
   }
   return found;
@@ -20483,17 +20483,17 @@ function checkDeadCssHooks(html, relFile) {
 }
 function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
   const planPath = join2(zelariRoot, "plan.json");
-  if (!existsSync9(planPath) || keywords.length === 0)
+  if (!existsSync10(planPath) || keywords.length === 0)
     return [];
   let plan;
   try {
-    plan = JSON.parse(readFileSync6(planPath, "utf8"));
+    plan = JSON.parse(readFileSync8(planPath, "utf8"));
   } catch {
     return [];
   }
   const milestoneText = (plan.milestones ?? []).map((m) => `${m.name ?? ""} ${m.description ?? ""}`).join(" ").toLowerCase();
   const results = [];
-  const targetContent = targets.map((t) => readFileSync6(join2(projectRoot, t), "utf8").toLowerCase()).join("\n");
+  const targetContent = targets.map((t) => readFileSync8(join2(projectRoot, t), "utf8").toLowerCase()).join("\n");
   for (const kw of keywords) {
     const low = kw.toLowerCase();
     if (!milestoneText.includes(low))
@@ -20523,13 +20523,13 @@ function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
 }
 function checkReadmeStale(projectRoot, targets) {
   const readmePath = join2(projectRoot, "README.md");
-  if (!existsSync9(readmePath) || targets.length === 0)
+  if (!existsSync10(readmePath) || targets.length === 0)
     return [];
-  const readme = readFileSync6(readmePath, "utf8");
+  const readme = readFileSync8(readmePath, "utf8");
   const htmlPath = join2(projectRoot, targets[0]);
-  if (!existsSync9(htmlPath))
+  if (!existsSync10(htmlPath))
     return [];
-  const html = readFileSync6(htmlPath, "utf8");
+  const html = readFileSync8(htmlPath, "utf8");
   const sectionCount = (html.match(/<section\s+id=/gi) ?? []).length;
   const readmeSections = readme.match(/(\d+)\s+sezioni/i);
   if (readmeSections) {
@@ -20567,7 +20567,7 @@ function runImplementationVerification(input) {
     forbidLayoutProps: anim.forbidLayoutProps ?? true
   };
   for (const rel2 of targets) {
-    const html = readFileSync6(join2(input.projectRoot, rel2), "utf8");
+    const html = readFileSync8(join2(input.projectRoot, rel2), "utf8");
     for (const v of scanKeyframesViolations(html, scanOpts)) {
       results.push({
         id: "motion.keyframes",
@@ -20653,7 +20653,7 @@ var init_runChecks = __esm({
 });
 
 // packages/core/dist/council/verification/microGate.js
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
 import { join as join3 } from "node:path";
 function checkDeadHooksInHtml(html) {
   const warnings = [];
@@ -20681,9 +20681,9 @@ function checkDeadHooksInHtml(html) {
   }
   return warnings;
 }
-function runMicroVerificationOnFile(projectRoot, relPath, zelariRoot) {
-  const abs = join3(projectRoot, relPath);
-  if (!existsSync10(abs) || !/\.html?$/i.test(relPath))
+function runMicroVerificationOnFile(projectRoot, relPath2, zelariRoot) {
+  const abs = join3(projectRoot, relPath2);
+  if (!existsSync11(abs) || !/\.html?$/i.test(relPath2))
     return [];
   const spec = (zelariRoot ? loadNfrSpec(zelariRoot) : null) ?? DEFAULT_NFR_SPEC;
   const anim = spec.animation ?? { compositorOnly: true, forbidLayoutProps: true };
@@ -20691,13 +20691,13 @@ function runMicroVerificationOnFile(projectRoot, relPath, zelariRoot) {
     compositorOnly: anim.compositorOnly ?? true,
     forbidLayoutProps: anim.forbidLayoutProps ?? true
   };
-  const html = readFileSync7(abs, "utf8");
+  const html = readFileSync9(abs, "utf8");
   const warnings = [];
   for (const v of scanKeyframesViolations(html, scanOpts)) {
     warnings.push({
       id: "motion.keyframes",
       message: `@keyframes uses non-allowed property "${v.property}"`,
-      file: relPath,
+      file: relPath2,
       line: v.line
     });
   }
@@ -20705,12 +20705,12 @@ function runMicroVerificationOnFile(projectRoot, relPath, zelariRoot) {
     warnings.push({
       id: "motion.transitions",
       message: `transition uses non-allowed property "${v.property}"`,
-      file: relPath,
+      file: relPath2,
       line: v.line
     });
   }
   for (const w of checkDeadHooksInHtml(html)) {
-    warnings.push({ ...w, file: relPath });
+    warnings.push({ ...w, file: relPath2 });
   }
   return warnings;
 }
@@ -21047,7 +21047,7 @@ var init_implementationDelivery = __esm({
 });
 
 // packages/core/dist/council/verification/inlineJsAutofix.js
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join4 } from "node:path";
 function minifyInlineJs(js) {
   let out = js.replace(/\/\*[\s\S]*?\*\//g, "");
@@ -21094,7 +21094,7 @@ function applyInlineJsAutofix(projectRoot, report) {
     const abs = join4(projectRoot, rel2);
     let html;
     try {
-      html = readFileSync8(abs, "utf8");
+      html = readFileSync10(abs, "utf8");
     } catch {
       continue;
     }
@@ -21127,7 +21127,7 @@ var init_inlineJsAutofix = __esm({
 });
 
 // packages/core/dist/agents/councilApi.js
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { join as join5 } from "node:path";
 function parseClarificationRequest(text) {
   const start = text.indexOf(QUESTION_MARKER);
@@ -21648,7 +21648,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         const zelariRoot = `${chairmanProjectRoot}/.zelari`;
         const spec = loadNfrSpec(zelariRoot) ?? DEFAULT_NFR_SPEC;
         for (const rel2 of spec.targets) {
-          if (!existsSync11(join5(chairmanProjectRoot, rel2)))
+          if (!existsSync12(join5(chairmanProjectRoot, rel2)))
             continue;
           changedTargetFiles.add(rel2);
           for (const w of runChairmanMicroGate({ projectRoot: chairmanProjectRoot, relPath: rel2, zelariRoot })) {
@@ -21668,7 +21668,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         const zelariRootReplay = `${chairmanProjectRoot}/.zelari`;
         const specReplay = loadNfrSpec(zelariRootReplay) ?? DEFAULT_NFR_SPEC;
         for (const rel2 of specReplay.targets) {
-          if (!existsSync11(join5(chairmanProjectRoot, rel2)))
+          if (!existsSync12(join5(chairmanProjectRoot, rel2)))
             continue;
           changedTargetFiles.add(rel2);
           for (const w of runChairmanMicroGate({
@@ -22039,8 +22039,8 @@ async function* runChairmanFixLoop(args) {
       break;
     }
     const rescanned = /* @__PURE__ */ new Map();
-    for (const relPath of args.changedFiles) {
-      for (const w of runChairmanMicroGate({ projectRoot: args.projectRoot, relPath, zelariRoot })) {
+    for (const relPath2 of args.changedFiles) {
+      for (const w of runChairmanMicroGate({ projectRoot: args.projectRoot, relPath: relPath2, zelariRoot })) {
         rescanned.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
       }
     }
@@ -22376,7 +22376,7 @@ var init_types = __esm({
 });
 
 // packages/core/dist/council/verification/motionAutofix.js
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
 import { join as join6 } from "node:path";
 function sanitizeTransitionPart(part) {
   const tokens = part.trim().split(/\s+/);
@@ -22455,7 +22455,7 @@ function applyMotionAutofix(projectRoot, report) {
     const abs = join6(projectRoot, rel2);
     let html;
     try {
-      html = readFileSync9(abs, "utf8");
+      html = readFileSync11(abs, "utf8");
     } catch {
       continue;
     }
@@ -22527,7 +22527,7 @@ var init_motionAutofix = __esm({
 });
 
 // packages/core/dist/council/verification/autofix.js
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join7 } from "node:path";
 function applyDeterministicAutofix(projectRoot, report) {
   const motion = applyMotionAutofix(projectRoot, report);
@@ -22543,7 +22543,7 @@ function applyDeterministicAutofix(projectRoot, report) {
     if (!m || m[1] === "rm")
       continue;
     const abs = join7(projectRoot, rel2);
-    let html = readFileSync10(abs, "utf8");
+    let html = readFileSync12(abs, "utf8");
     const snippet = m[0];
     if (!html.includes(snippet))
       continue;
@@ -22598,12 +22598,12 @@ var init_types2 = __esm({
 });
 
 // packages/core/dist/council/lessons/io.js
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 import { join as join8 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path27 = join8(zelariRoot, LESSONS_FILE);
+  const path33 = join8(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync11(path27, "utf8");
+    const raw = readFileSync13(path33, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -22704,8 +22704,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path27 = join9(zelariRoot, LESSONS_FILE);
-  appendFileSync2(path27, `${JSON.stringify(lesson)}
+  const path33 = join9(zelariRoot, LESSONS_FILE);
+  appendFileSync2(path33, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -23242,18 +23242,18 @@ var init_council = __esm({
 import {
   mkdirSync as mkdirSync6,
   writeFileSync as writeFileSync10,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   accessSync,
   constants,
   realpathSync
 } from "node:fs";
 import { join as join11, basename } from "node:path";
-import { homedir as homedir3 } from "node:os";
-import { createHash } from "node:crypto";
+import { homedir as homedir4 } from "node:os";
+import { createHash as createHash2 } from "node:crypto";
 function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   const candidates = [
     join11(projectRoot, ".zelari"),
-    join11(homedir3(), ".zelari-code", "workspace", hashProject(projectRoot))
+    join11(homedir4(), ".zelari-code", "workspace", hashProject(projectRoot))
   ];
   for (const candidate of candidates) {
     if (isWritableDir(projectRoot) || candidate !== candidates[0]) {
@@ -23265,11 +23265,11 @@ function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   return candidates[0];
 }
 function hashProject(projectPath) {
-  return createHash("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+  return createHash2("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
 }
 function isWritableDir(dir) {
   try {
-    if (!existsSync12(dir)) return false;
+    if (!existsSync13(dir)) return false;
     accessSync(dir, constants.W_OK);
     return true;
   } catch {
@@ -23278,9 +23278,9 @@ function isWritableDir(dir) {
 }
 function ensureWorkspaceDir(workspaceDir) {
   mkdirSync6(workspaceDir, { recursive: true });
-  if (workspaceDir.endsWith("/.zelari") && existsSync12(join11(workspaceDir, "..", ".git"))) {
+  if (workspaceDir.endsWith("/.zelari") && existsSync13(join11(workspaceDir, "..", ".git"))) {
     const gitignorePath = join11(workspaceDir, ".gitignore");
-    if (!existsSync12(gitignorePath)) {
+    if (!existsSync13(gitignorePath)) {
       writeFileSync10(gitignorePath, "*\n!.gitignore\n");
     }
   }
@@ -23315,7 +23315,7 @@ __export(workspaceSummary_exports, {
   buildWorkspaceSummary: () => buildWorkspaceSummary,
   buildZelariReadHint: () => buildZelariReadHint
 });
-import { existsSync as existsSync13, readFileSync as readFileSync12, readdirSync, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync14, readdirSync, statSync as statSync3 } from "node:fs";
 import { join as join12, relative as relative2 } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30 } = options;
@@ -23344,10 +23344,10 @@ function formatTaskLine(t) {
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
   const planPath = join12(zelariRoot, "plan.json");
-  if (!existsSync13(planPath)) return null;
+  if (!existsSync14(planPath)) return null;
   let plan;
   try {
-    plan = JSON.parse(readFileSync12(planPath, "utf8"));
+    plan = JSON.parse(readFileSync14(planPath, "utf8"));
   } catch {
     return null;
   }
@@ -23477,7 +23477,7 @@ function pickNextTask(open) {
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
   const planPath = join12(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync13(planPath)) return "";
+  if (!existsSync14(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/)",
     "This project has a council workspace: .zelari/plan.json holds the plan (phases, tasks, milestones) and .zelari/plan-tasks/ holds one detail file per task.",
@@ -23493,9 +23493,9 @@ function safeProjectName(root) {
 }
 function readPackageJson(projectRoot) {
   const p3 = join12(projectRoot, "package.json");
-  if (!existsSync13(p3)) return null;
+  if (!existsSync14(p3)) return null;
   try {
-    return JSON.parse(readFileSync12(p3, "utf8"));
+    return JSON.parse(readFileSync14(p3, "utf8"));
   } catch {
     return null;
   }
@@ -23584,9 +23584,9 @@ __export(storage_exports, {
   workspaceMutex: () => workspaceMutex
 });
 import {
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync15,
   writeFileSync as writeFileSync11,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync7,
   readdirSync as readdirSync2,
   renameSync as renameSync2
@@ -23845,32 +23845,32 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path27) {
-        if (!existsSync14(path27)) {
-          throw new Error(`File not found: ${path27}`);
+      read(path33) {
+        if (!existsSync15(path33)) {
+          throw new Error(`File not found: ${path33}`);
         }
-        const md = readFileSync13(path27, "utf8");
+        const md = readFileSync15(path33, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path27) {
-        if (!existsSync14(path27)) return null;
-        return this.read(path27);
+      readIfExists(path33) {
+        if (!existsSync15(path33)) return null;
+        return this.read(path33);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path27, meta3, body) {
-        mkdirSync7(dirname(path27), { recursive: true });
-        const tmp = path27 + ".tmp-" + process.pid;
+      write(path33, meta3, body) {
+        mkdirSync7(dirname(path33), { recursive: true });
+        const tmp = path33 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync11(tmp, md, "utf8");
-        renameSync2(tmp, path27);
+        renameSync2(tmp, path33);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
-        if (!existsSync14(dir)) return [];
+        if (!existsSync15(dir)) return [];
         return readdirSync2(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join13(dir, f));
       }
     };
@@ -23910,10 +23910,10 @@ __export(stubs_exports, {
   resolveWorkspaceRoot: () => resolveWorkspaceRoot
 });
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync12,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync16,
   mkdirSync as mkdirSync8,
   renameSync as renameSync3
 } from "node:fs";
@@ -23931,10 +23931,10 @@ function planJsonPath(ctx) {
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
-  if (existsSync15(jsonPath)) {
+  if (existsSync16(jsonPath)) {
     try {
       const parsed = JSON.parse(
-        readFileSync14(jsonPath, "utf8")
+        readFileSync16(jsonPath, "utf8")
       );
       return {
         phases: Array.isArray(parsed.phases) ? parsed.phases : [],
@@ -23944,8 +23944,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path27 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path27);
+  const path33 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path33);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -24026,7 +24026,7 @@ function renderPlanBody(summary) {
 }
 function nextAdrId(ctx) {
   const decisionsDir = join14(ctx.rootDir, "decisions");
-  if (!existsSync15(decisionsDir)) return "001";
+  if (!existsSync16(decisionsDir)) return "001";
   const existing = readdirSync3(decisionsDir).filter((f) => f.endsWith(".md")).map((f) => f.match(/^(\d+)-/)).filter((m) => !!m).map((m) => parseInt(m[1], 10));
   const max = existing.length === 0 ? 0 : Math.max(...existing);
   return String(max + 1).padStart(3, "0");
@@ -24110,7 +24110,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path27 = join14(ctx.rootDir, "milestones", `${id}.md`);
+  const path33 = join14(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -24127,7 +24127,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path27, meta3, body);
+  ctx.storage.write(path33, meta3, body);
   return { id, created: true };
 }
 function readPlanSummary(ctx) {
@@ -24331,7 +24331,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path27 = workspaceArtifact(ctx.rootDir, "decisions", id);
+        const path33 = workspaceArtifact(ctx.rootDir, "decisions", id);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -24357,7 +24357,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path27, meta3, body);
+        ctx.storage.write(path33, meta3, body);
         return `ADR ${id} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -24439,14 +24439,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path27 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path33 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path27, meta3, content);
+        ctx.storage.write(path33, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -24482,8 +24482,8 @@ function searchDocumentsStub(ctx) {
       ];
       const results = [];
       for (const file2 of files) {
-        if (!existsSync15(file2)) continue;
-        const raw = readFileSync14(file2, "utf8");
+        if (!existsSync16(file2)) continue;
+        const raw = readFileSync16(file2, "utf8");
         const content = raw.toLowerCase();
         let idx = -1;
         let matchLen = 0;
@@ -24677,21 +24677,21 @@ __export(updater_exports, {
   resolveBundledNpmCli: () => resolveBundledNpmCli
 });
 import { createRequire } from "node:module";
-import { spawn as spawn3 } from "node:child_process";
-import { existsSync as existsSync16 } from "node:fs";
-import path16 from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+import { existsSync as existsSync17 } from "node:fs";
+import path22 from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveBundledNpmCli(execPath = process.execPath) {
-  const dir = path16.dirname(execPath);
+  const dir = path22.dirname(execPath);
   const candidates = [
     // Windows: C:\...\node.exe → C:\...\node_modules\npm\bin\npm-cli.js
-    path16.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
+    path22.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
     // POSIX: <prefix>/bin/node → <prefix>/lib/node_modules/npm/bin/npm-cli.js
-    path16.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+    path22.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
   ];
   for (const candidate of candidates) {
     try {
-      if (existsSync16(candidate)) return candidate;
+      if (existsSync17(candidate)) return candidate;
     } catch {
     }
   }
@@ -24704,7 +24704,7 @@ function looksLikeBrokenShim(exitCode, output) {
 }
 function getCurrentVersion() {
   try {
-    const pkgPath = path16.resolve(__dirname2, "..", "..", "package.json");
+    const pkgPath = path22.resolve(__dirname2, "..", "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {
@@ -24764,7 +24764,7 @@ async function checkForUpdate(fetcher = fetch, registryUrl) {
     updateAvailable: cmp < 0
   };
 }
-async function performUpdate(packageName = "zelari-code", executor = spawn3, resolveNpmCli = resolveBundledNpmCli) {
+async function performUpdate(packageName = "zelari-code", executor = spawn4, resolveNpmCli = resolveBundledNpmCli) {
   const args = ["install", "-g", `${packageName}@latest`];
   const primary = await runNpm(executor, args, "shim");
   if (primary.ok) return primary;
@@ -24816,13 +24816,13 @@ var init_updater = __esm({
     "use strict";
     init_cmdline();
     require2 = createRequire(import.meta.url);
-    __dirname2 = path16.dirname(fileURLToPath(import.meta.url));
+    __dirname2 = path22.dirname(fileURLToPath(import.meta.url));
     REGISTRY_URL = "https://registry.npmjs.org/zelari-code/latest";
   }
 });
 
 // src/cli/mcp/mcpClient.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var DEFAULT_REQUEST_TIMEOUT_MS, INIT_TIMEOUT_MS, MCP_PROTOCOL_VERSION, McpClient;
 var init_mcpClient = __esm({
   "src/cli/mcp/mcpClient.ts"() {
@@ -24850,10 +24850,10 @@ var init_mcpClient = __esm({
           env: { ...process.env, ...this.config.env ?? {} },
           windowsHide: true
         };
-        const child = process.platform === "win32" ? spawn4(buildCmdLine(this.config.command, this.config.args ?? []), {
+        const child = process.platform === "win32" ? spawn5(buildCmdLine(this.config.command, this.config.args ?? []), {
           ...spawnOpts,
           shell: true
-        }) : spawn4(this.config.command, this.config.args ?? [], spawnOpts);
+        }) : spawn5(this.config.command, this.config.args ?? [], spawnOpts);
         this.child = child;
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => this.onStdout(chunk));
@@ -24997,20 +24997,20 @@ __export(mcpManager_exports, {
   readMcpConfig: () => readMcpConfig,
   registerMcpTools: () => registerMcpTools
 });
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync17 } from "node:fs";
 import { join as join15 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 function readMcpConfig(projectRoot = process.cwd()) {
   const merged = {};
   const paths = [
-    join15(homedir4(), ".zelari-code", "mcp.json"),
+    join15(homedir5(), ".zelari-code", "mcp.json"),
     join15(projectRoot, ".zelari", "mcp.json")
     // later = higher precedence
   ];
   for (const p3 of paths) {
-    if (!existsSync17(p3)) continue;
+    if (!existsSync18(p3)) continue;
     try {
-      const parsed = JSON.parse(readFileSync15(p3, "utf8"));
+      const parsed = JSON.parse(readFileSync17(p3, "utf8"));
       for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
         if (!cfg || typeof cfg.command !== "string" || cfg.command.length === 0) continue;
         merged[name] = cfg;
@@ -25142,13 +25142,13 @@ var planDetect_exports = {};
 __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
 import { join as join16 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
   const planPath = join16(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync18(planPath)) return false;
+  if (!existsSync19(planPath)) return false;
   try {
-    const parsed = JSON.parse(readFileSync16(planPath, "utf8"));
+    const parsed = JSON.parse(readFileSync18(planPath, "utf8"));
     return Array.isArray(parsed.phases) && parsed.phases.length > 0;
   } catch {
     return false;
@@ -25245,15 +25245,15 @@ __export(agentsMd_exports, {
   serializeAgentsMd: () => serializeAgentsMd,
   updateAgentsMd: () => updateAgentsMd
 });
-import { existsSync as existsSync19, readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "node:fs";
-import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync20, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
 import { join as join17 } from "node:path";
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path27 = join17(projectRoot, "package.json");
-  if (!existsSync19(path27)) return null;
+  const path33 = join17(projectRoot, "package.json");
+  if (!existsSync20(path33)) return null;
   try {
-    return JSON.parse(await readFile(path27, "utf8"));
+    return JSON.parse(await readFile2(path33, "utf8"));
   } catch {
     return null;
   }
@@ -25276,7 +25276,7 @@ async function genTechStack(ctx) {
 }
 async function genDecisions(ctx) {
   const decisionsDir = join17(ctx.rootDir, "decisions");
-  if (!existsSync19(decisionsDir)) return "_No ADRs yet._";
+  if (!existsSync20(decisionsDir)) return "_No ADRs yet._";
   const files = ctx.storage.listMarkdown(decisionsDir).sort();
   const accepted = [];
   const proposed = [];
@@ -25302,8 +25302,8 @@ async function genDecisions(ctx) {
 async function genConventions(ctx) {
   const lines = [];
   const claudeMd = join17(ctx.projectRoot, "CLAUDE.MD");
-  if (existsSync19(claudeMd)) {
-    const content = readFileSync17(claudeMd, "utf8");
+  if (existsSync20(claudeMd)) {
+    const content = readFileSync19(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
     if (match) {
       lines.push('<!-- Extracted from CLAUDE.MD "Architecture rules" -->');
@@ -25335,9 +25335,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path27 = join17(ctx.rootDir, "risks.md");
-  if (!existsSync19(path27)) return "_No open questions._";
-  const content = readFileSync17(path27, "utf8");
+  const path33 = join17(ctx.rootDir, "risks.md");
+  if (!existsSync20(path33)) return "_No open questions._";
+  const content = readFileSync19(path33, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -25412,8 +25412,8 @@ function titleCase(id) {
 }
 async function updateAgentsMd(ctx, projectRoot) {
   const agentsPath = join17(projectRoot, "AGENTS.MD");
-  if (existsSync19(agentsPath)) {
-    const content = readFileSync17(agentsPath, "utf8");
+  if (existsSync20(agentsPath)) {
+    const content = readFileSync19(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id) => content.includes(MARKER_OPEN(id)));
     if (!hasAnyMarker) {
       return {
@@ -25428,8 +25428,8 @@ async function updateAgentsMd(ctx, projectRoot) {
     newSections.set(id, await GENERATORS[id](ctx));
   }
   let manualContent = "";
-  if (existsSync19(agentsPath)) {
-    const { manualBlocks } = parseAgentsMd(readFileSync17(agentsPath, "utf8"));
+  if (existsSync20(agentsPath)) {
+    const { manualBlocks } = parseAgentsMd(readFileSync19(agentsPath, "utf8"));
     manualContent = manualBlocks.after;
   } else {
     const projectName2 = projectName(projectRoot);
@@ -25445,7 +25445,7 @@ async function updateAgentsMd(ctx, projectRoot) {
       ""
     ].join("\n");
   }
-  const oldContent = existsSync19(agentsPath) ? readFileSync17(agentsPath, "utf8") : "";
+  const oldContent = existsSync20(agentsPath) ? readFileSync19(agentsPath, "utf8") : "";
   const { sections: oldSections } = parseAgentsMd(oldContent);
   const changedSections = [];
   for (const id of AUTO_SECTIONS) {
@@ -25461,7 +25461,7 @@ async function updateAgentsMd(ctx, projectRoot) {
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
-  return createHash2("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(s).digest("hex").slice(0, 16);
 }
 var AUTO_SECTIONS, MARKER_OPEN, MARKER_CLOSE, GENERATORS;
 var init_agentsMd = __esm({
@@ -25582,8 +25582,8 @@ var init_completeDesign = __esm({
 });
 
 // src/cli/workspace/projectSmoke.ts
-import { spawn as spawn5 } from "node:child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync18 } from "node:fs";
+import { spawn as spawn6 } from "node:child_process";
+import { existsSync as existsSync21, readFileSync as readFileSync20 } from "node:fs";
 import { join as join18 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
@@ -25597,12 +25597,12 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS) {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
   const pkgPath = join18(projectRoot, "package.json");
-  if (!existsSync20(pkgPath)) {
+  if (!existsSync21(pkgPath)) {
     return { ran: false, reason: "no package.json (skipped)" };
   }
   let scripts = {};
   try {
-    const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync20(pkgPath, "utf8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return { ran: false, reason: "package.json unreadable (skipped)" };
@@ -25613,7 +25613,7 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS) {
   }
   return await new Promise((resolveRun) => {
     const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-    const child = spawn5(npmCmd, ["run", script], {
+    const child = spawn6(npmCmd, ["run", script], {
       cwd: projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env,
@@ -25685,8 +25685,8 @@ __export(postCouncilHook_exports, {
   runImplementationVerificationHook: () => runImplementationVerificationHook,
   runPostCouncilHook: () => runPostCouncilHook
 });
-import { spawn as spawn6 } from "node:child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync19 } from "node:fs";
+import { spawn as spawn7 } from "node:child_process";
+import { existsSync as existsSync22, readFileSync as readFileSync21 } from "node:fs";
 import { join as join19 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
@@ -25700,7 +25700,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   }
   const planJsonPath2 = join19(ctx.rootDir, "plan.json");
   const scriptPath = join19(ctx.projectRoot, "complete-design.mjs");
-  if (!existsSync21(planJsonPath2)) {
+  if (!existsSync22(planJsonPath2)) {
     return {
       ran: false,
       reason: ".zelari/plan.json missing (not design-phase)"
@@ -25708,7 +25708,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   }
   let phaseCount = 0;
   try {
-    const parsed = JSON.parse(readFileSync19(planJsonPath2, "utf8"));
+    const parsed = JSON.parse(readFileSync21(planJsonPath2, "utf8"));
     phaseCount = Array.isArray(parsed.phases) ? parsed.phases.length : 0;
   } catch {
     return { ran: false, reason: ".zelari/plan.json corrupt" };
@@ -25716,7 +25716,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (phaseCount === 0) {
     return { ran: false, reason: ".zelari/plan.json has no phases" };
   }
-  if (!existsSync21(scriptPath)) {
+  if (!existsSync22(scriptPath)) {
     try {
       const builtin = await runBuiltinCompleteDesign(ctx);
       return {
@@ -25734,7 +25734,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
     }
   }
   return await new Promise((resolveRun) => {
-    const child = spawn6(process.execPath, [scriptPath], {
+    const child = spawn7(process.execPath, [scriptPath], {
       cwd: ctx.projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -25900,8 +25900,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path27 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path27, completion };
+      const path33 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path33, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -25937,12 +25937,12 @@ var buildLessonsSummary_exports = {};
 __export(buildLessonsSummary_exports, {
   buildLessonsSummary: () => buildLessonsSummary
 });
-import { existsSync as existsSync22 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { join as join20 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync22(join20(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync23(join20(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -25964,14 +25964,14 @@ __export(councilFeedback_exports, {
   FeedbackStore: () => FeedbackStore
 });
 import {
-  promises as fs12,
-  existsSync as existsSync23,
-  readFileSync as readFileSync20,
+  promises as fs13,
+  existsSync as existsSync24,
+  readFileSync as readFileSync22,
   writeFileSync as writeFileSync14,
   mkdirSync as mkdirSync9
 } from "node:fs";
-import path17 from "node:path";
-import os7 from "node:os";
+import path23 from "node:path";
+import os8 from "node:os";
 var FeedbackStore;
 var init_councilFeedback = __esm({
   "src/cli/councilFeedback.ts"() {
@@ -25981,7 +25981,7 @@ var init_councilFeedback = __esm({
       now;
       entries = [];
       constructor(options = {}) {
-        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path17.join(os7.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
+        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path23.join(os8.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
         this.now = options.now ?? Date.now;
         this.load();
       }
@@ -26074,9 +26074,9 @@ var init_councilFeedback = __esm({
       }
       // --- persistence ---------------------------------------------------------
       load() {
-        if (!existsSync23(this.file)) return;
+        if (!existsSync24(this.file)) return;
         try {
-          const raw = readFileSync20(this.file, "utf-8");
+          const raw = readFileSync22(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -26087,7 +26087,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync9(path17.dirname(this.file), { recursive: true });
+        mkdirSync9(path23.dirname(this.file), { recursive: true });
         writeFileSync14(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -26097,7 +26097,7 @@ var init_councilFeedback = __esm({
       /** Async variant of load for callers that prefer async IO. */
       async loadAsync() {
         try {
-          const raw = await fs12.readFile(this.file, "utf-8");
+          const raw = await fs13.readFile(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -26121,8 +26121,8 @@ __export(fileBackend_exports, {
   isMemoryEnabled: () => isMemoryEnabled
 });
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { promises as fs13 } from "node:fs";
-import * as path18 from "node:path";
+import { promises as fs14 } from "node:fs";
+import * as path24 from "node:path";
 function tokenize(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -26160,9 +26160,9 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path18.join(projectRoot, ".zelari", "memory");
-        this.logPath = path18.join(this.memoryDir, "log.jsonl");
-        await fs13.mkdir(this.memoryDir, { recursive: true });
+        this.memoryDir = path24.join(projectRoot, ".zelari", "memory");
+        this.logPath = path24.join(this.memoryDir, "log.jsonl");
+        await fs14.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata = {}, graph) {
         const fact = {
@@ -26172,7 +26172,7 @@ var init_fileBackend = __esm({
           ...graph ? { graph } : {},
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await fs13.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
+        await fs14.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
         return fact.id;
       }
       async search(query, options = {}) {
@@ -26200,7 +26200,7 @@ var init_fileBackend = __esm({
       async readAll() {
         let raw;
         try {
-          raw = await fs13.readFile(this.logPath, "utf8");
+          raw = await fs14.readFile(this.logPath, "utf8");
         } catch {
           return [];
         }
@@ -26236,7 +26236,7 @@ import { execFile as execFile2 } from "node:child_process";
 import { promisify } from "node:util";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import path19 from "node:path";
+import path25 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 async function git(cwd, args, env) {
   const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
@@ -26256,8 +26256,8 @@ async function isGitRepo(cwd) {
   return await gitSafe(cwd, ["rev-parse", "--is-inside-work-tree"]) === "true";
 }
 async function withTempIndex(fn) {
-  const dir = mkdtempSync(path19.join(tmpdir(), "zelari-ckpt-"));
-  const indexFile = path19.join(dir, "index");
+  const dir = mkdtempSync(path25.join(tmpdir(), "zelari-ckpt-"));
+  const indexFile = path25.join(dir, "index");
   try {
     return await fn(indexFile);
   } finally {
@@ -26348,7 +26348,7 @@ async function restoreCheckpoint(cwd, id) {
     const deleted = [];
     for (const rel2 of added) {
       try {
-        rmSync(path19.join(cwd, rel2), { force: true });
+        rmSync(path25.join(cwd, rel2), { force: true });
         deleted.push(rel2);
       } catch {
       }
@@ -26377,8 +26377,8 @@ __export(zelariMission_exports, {
   runZelariMission: () => runZelariMission
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { promises as fs14 } from "node:fs";
-import * as path20 from "node:path";
+import { promises as fs15 } from "node:fs";
+import * as path26 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;
@@ -26394,10 +26394,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state2) {
-  const dir = path20.join(projectRoot, ".zelari");
-  await fs14.mkdir(dir, { recursive: true });
-  await fs14.writeFile(
-    path20.join(dir, "mission-state.json"),
+  const dir = path26.join(projectRoot, ".zelari");
+  await fs15.mkdir(dir, { recursive: true });
+  await fs15.writeFile(
+    path26.join(dir, "mission-state.json"),
     JSON.stringify(state2, null, 2) + "\n",
     "utf8"
   );
@@ -26540,26 +26540,26 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { execSync } from "node:child_process";
-import { existsSync as existsSync28, readFileSync as readFileSync23, readlinkSync, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync25, readlinkSync, statSync as statSync6 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import path26 from "node:path";
+import path32 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path26.join(dir, "package.json");
-    if (existsSync28(candidate)) {
+    const candidate = path32.join(dir, "package.json");
+    if (existsSync29(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync23(candidate, "utf8"));
+        const pkg = JSON.parse(readFileSync25(candidate, "utf8"));
         if (pkg.name === "zelari-code") return dir;
       } catch {
       }
     }
-    const parent = path26.dirname(dir);
+    const parent = path32.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path26.resolve(__dirname3, "..", "..", "..");
+  return path32.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -26573,8 +26573,8 @@ function tryExec(cmd) {
 }
 function readPackageJson3() {
   try {
-    const pkgPath = path26.join(packageRoot, "package.json");
-    return JSON.parse(readFileSync23(pkgPath, "utf8"));
+    const pkgPath = path32.join(packageRoot, "package.json");
+    return JSON.parse(readFileSync25(pkgPath, "utf8"));
   } catch {
     return null;
   }
@@ -26589,8 +26589,8 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path26.join(prefix, shimName);
-  if (!existsSync28(shimPath)) {
+  const shimPath = path32.join(prefix, shimName);
+  if (!existsSync29(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
          fix:  npm install -g ${pkgName}@latest --force`
@@ -26599,7 +26599,7 @@ function checkShim(pkgName) {
   try {
     const st = statSync6(shimPath);
     if (isWin) {
-      const content = readFileSync23(shimPath, "utf8");
+      const content = readFileSync25(shimPath, "utf8");
       if (content.includes(`${pkgName}\\bin\\`) || content.includes(`${pkgName}/bin/`)) {
         return OK(`shim OK at ${shimPath} (${st.size} bytes)`);
       }
@@ -26617,8 +26617,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path26.resolve(path26.dirname(shimPath), target);
-    const expected = path26.join(
+    const resolved = path32.resolve(path32.dirname(shimPath), target);
+    const expected = path32.join(
       prefix,
       "node_modules",
       pkgName,
@@ -26657,8 +26657,8 @@ function checkNode(pkg) {
   return OK(`node ${raw}`);
 }
 function checkBundle() {
-  const bundle = path26.join(packageRoot, "dist", "cli", "main.bundled.js");
-  if (!existsSync28(bundle)) {
+  const bundle = path32.join(packageRoot, "dist", "cli", "main.bundled.js");
+  if (!existsSync29(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
          fix:  npm run build:cli   (then reinstall or run via tsx)`
@@ -26678,7 +26678,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire2(path26.join(packageRoot, "package.json"));
+      const localReq = createRequire2(path32.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -26760,7 +26760,7 @@ var init_doctor = __esm({
   "src/cli/utils/doctor.ts"() {
     "use strict";
     require3 = createRequire2(import.meta.url);
-    __dirname3 = path26.dirname(fileURLToPath2(import.meta.url));
+    __dirname3 = path32.dirname(fileURLToPath2(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -30741,6 +30741,1166 @@ function createTaskTool(deps) {
   };
 }
 
+// src/cli/lsp/tools.ts
+init_zod();
+init_toolTypes();
+import path16 from "node:path";
+
+// src/cli/lsp/protocol.ts
+function encodeMessage(message) {
+  const json2 = JSON.stringify(message);
+  const contentLength = Buffer.byteLength(json2, "utf8");
+  return `Content-Length: ${contentLength}\r
+\r
+${json2}`;
+}
+function createMessageParser() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const out = [];
+      for (; ; ) {
+        const headerEnd = buffer.indexOf("\r\n\r\n");
+        if (headerEnd === -1) break;
+        const header = buffer.slice(0, headerEnd);
+        const match = /Content-Length:\s*(\d+)/i.exec(header);
+        if (!match) {
+          buffer = buffer.slice(headerEnd + 4);
+          continue;
+        }
+        const length = Number(match[1]);
+        const bodyStart = headerEnd + 4;
+        const rest = Buffer.from(buffer.slice(bodyStart), "utf8");
+        if (rest.length < length) break;
+        const body = rest.subarray(0, length).toString("utf8");
+        buffer = rest.subarray(length).toString("utf8");
+        try {
+          out.push(JSON.parse(body));
+        } catch {
+        }
+      }
+      return out;
+    }
+  };
+}
+function pathToUri(filePath) {
+  let p3 = filePath.replace(/\\/g, "/");
+  if (!p3.startsWith("/")) p3 = `/${p3}`;
+  const encoded = p3.split("/").map((seg) => encodeURIComponent(seg)).join("/");
+  return `file://${encoded}`;
+}
+function uriToPath(uri) {
+  if (!uri.startsWith("file://")) return uri;
+  const withoutScheme = decodeURIComponent(uri.slice("file://".length));
+  return /^\/[A-Za-z]:/.test(withoutScheme) ? withoutScheme.slice(1) : withoutScheme;
+}
+
+// src/cli/lsp/tools.ts
+function fmtLocation(loc, relativeTo) {
+  const file2 = uriToPath(loc.uri);
+  const rel2 = relativeTo ? relPath(relativeTo, file2) : file2;
+  const line = (loc.range?.start?.line ?? 0) + 1;
+  const col = (loc.range?.start?.character ?? 0) + 1;
+  return `${rel2}:${line}:${col}`;
+}
+function relPath(from, to) {
+  try {
+    const r = path16.relative(from, to);
+    return r && !r.startsWith("..") ? r : to;
+  } catch {
+    return to;
+  }
+}
+var PosArgs = external_exports.object({
+  path: external_exports.string().min(1).describe("File path (relative to the project root or absolute)."),
+  line: external_exports.number().int().positive().describe("1-based line number of the symbol."),
+  column: external_exports.number().int().positive().describe("1-based column of the symbol.")
+});
+function createLspTools(provider, root = process.cwd()) {
+  const goToDefinition = {
+    name: "go_to_definition",
+    description: "Jump to where the symbol at a position is defined (via the language server). Returns the defining file:line:col \u2014 use it instead of guessing with grep.",
+    permissions: ["read"],
+    inputSchema: PosArgs,
+    execute: async (args) => {
+      const a = args;
+      const locs = await provider.definition(a.path, a.line - 1, a.column - 1);
+      return typedOk({
+        definitions: locs.map((l) => fmtLocation(l, root)),
+        count: locs.length
+      });
+    }
+  };
+  const findReferences = {
+    name: "find_references",
+    description: "Find every reference to the symbol at a position across the workspace (via the language server). Returns a list of file:line:col \u2014 reliable where a text grep would miss shadowed names or match strings/comments.",
+    permissions: ["read"],
+    inputSchema: PosArgs,
+    execute: async (args) => {
+      const a = args;
+      const locs = await provider.references(a.path, a.line - 1, a.column - 1);
+      return typedOk({
+        references: locs.map((l) => fmtLocation(l, root)),
+        count: locs.length
+      });
+    }
+  };
+  const hoverType = {
+    name: "hover_type",
+    description: "Get the resolved type signature and documentation for the symbol at a position (via the language server) \u2014 the real type the compiler sees.",
+    permissions: ["read"],
+    inputSchema: PosArgs,
+    execute: async (args) => {
+      const a = args;
+      const text = await provider.hover(a.path, a.line - 1, a.column - 1);
+      return typedOk({ hover: text ?? "(no hover information)" });
+    }
+  };
+  const documentSymbols = {
+    name: "document_symbols",
+    description: "List the symbols (functions, classes, methods, variables) declared in a file with their line numbers \u2014 a fast structural outline via the language server.",
+    permissions: ["read"],
+    inputSchema: external_exports.object({
+      path: external_exports.string().min(1).describe("File path to outline.")
+    }),
+    execute: async (args) => {
+      const a = args;
+      const symbols = await provider.documentSymbols(a.path);
+      return typedOk({
+        symbols: symbols.map((s) => `${s.kind} ${s.name} (line ${s.line})`),
+        count: symbols.length
+      });
+    }
+  };
+  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.",
+    permissions: ["read"],
+    inputSchema: PosArgs.extend({
+      newName: external_exports.string().min(1).describe("The new symbol name.")
+    }),
+    execute: async (args) => {
+      const a = args;
+      const result = await provider.rename(a.path, a.line - 1, a.column - 1, a.newName);
+      if (!result) {
+        return typedOk({ preview: "no rename available at this position (symbol not found or not renameable)" });
+      }
+      return typedOk({
+        totalEdits: result.totalEdits,
+        files: result.files.map((f) => `${relPath(root, f.file)} (${f.count} edit${f.count === 1 ? "" : "s"})`)
+      });
+    }
+  };
+  return [goToDefinition, findReferences, hoverType, documentSymbols, renameSymbol];
+}
+
+// src/cli/lsp/manager.ts
+import { spawn as spawn3 } from "node:child_process";
+import { readFileSync as readFileSync5 } from "node:fs";
+
+// src/cli/lsp/client.ts
+var LspClient = class {
+  constructor(transport, options = {}) {
+    this.transport = transport;
+    this.timeoutMs = options.timeoutMs ?? 15e3;
+    transport.onData((chunk) => this.onData(chunk));
+    transport.onClose(() => this.onClose());
+  }
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  parser = createMessageParser();
+  closed = false;
+  timeoutMs;
+  /** Send a request and await the matching response. */
+  request(method, params) {
+    if (this.closed) return Promise.reject(new Error("LSP transport is closed"));
+    const id = this.nextId++;
+    const msg = { jsonrpc: "2.0", id, method, ...params !== void 0 ? { params } : {} };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`LSP request "${method}" timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.transport.send(encodeMessage(msg));
+    });
+  }
+  /** Fire a notification (no response expected). */
+  notify(method, params) {
+    if (this.closed) return;
+    const msg = { jsonrpc: "2.0", method, ...params !== void 0 ? { params } : {} };
+    this.transport.send(encodeMessage(msg));
+  }
+  onData(chunk) {
+    for (const message of this.parser.push(chunk)) {
+      this.handleMessage(message);
+    }
+  }
+  handleMessage(message) {
+    if (message.method === void 0 && message.id !== void 0) {
+      const entry = this.pending.get(message.id);
+      if (!entry) return;
+      this.pending.delete(message.id);
+      clearTimeout(entry.timer);
+      if (message.error) {
+        entry.reject(new Error(`LSP error ${message.error.code}: ${message.error.message}`));
+      } else {
+        entry.resolve(message.result);
+      }
+      return;
+    }
+    if (message.method !== void 0 && message.id !== void 0) {
+      this.transport.send(
+        encodeMessage({ jsonrpc: "2.0", id: message.id, result: null })
+      );
+      return;
+    }
+  }
+  onClose() {
+    this.closed = true;
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error("LSP transport closed before response"));
+    }
+    this.pending.clear();
+  }
+  dispose() {
+    this.onClose();
+    this.transport.dispose();
+  }
+};
+
+// src/cli/lsp/servers.ts
+import path17 from "node:path";
+var LSP_SERVERS = [
+  {
+    language: "typescript",
+    bin: "typescript-language-server",
+    args: ["--stdio"],
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]
+  },
+  {
+    language: "python",
+    bin: "pyright-langserver",
+    args: ["--stdio"],
+    extensions: [".py"]
+  },
+  {
+    language: "go",
+    bin: "gopls",
+    args: [],
+    extensions: [".go"]
+  },
+  {
+    language: "rust",
+    bin: "rust-analyzer",
+    args: [],
+    extensions: [".rs"]
+  }
+];
+function languageIdForFile(file2) {
+  const ext = path17.extname(file2).toLowerCase();
+  const map2 = {
+    ".ts": "typescript",
+    ".tsx": "typescriptreact",
+    ".js": "javascript",
+    ".jsx": "javascriptreact",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust"
+  };
+  return map2[ext] ?? "plaintext";
+}
+function serverForFile(file2, servers = LSP_SERVERS) {
+  const ext = path17.extname(file2).toLowerCase();
+  return servers.find((s) => s.extensions.includes(ext)) ?? null;
+}
+function resolveServerCommand(file2, cwd, servers = LSP_SERVERS) {
+  const spec = serverForFile(file2, servers);
+  if (!spec) return null;
+  const command = resolveBin(spec.bin, cwd);
+  return {
+    language: spec.language,
+    command,
+    args: spec.args,
+    resolved: command !== spec.bin
+  };
+}
+
+// src/cli/lsp/manager.ts
+function processTransport(child) {
+  return {
+    send: (data) => {
+      if (child.stdin.writable) child.stdin.write(data);
+    },
+    onData: (cb) => child.stdout.on("data", (b) => cb(b.toString("utf8"))),
+    onClose: (cb) => child.on("exit", cb),
+    dispose: () => {
+      try {
+        child.kill();
+      } catch {
+      }
+    }
+  };
+}
+var SYMBOL_KINDS = {
+  1: "File",
+  2: "Module",
+  3: "Namespace",
+  4: "Package",
+  5: "Class",
+  6: "Method",
+  7: "Property",
+  8: "Field",
+  9: "Constructor",
+  10: "Enum",
+  11: "Interface",
+  12: "Function",
+  13: "Variable",
+  14: "Constant",
+  15: "String",
+  16: "Number",
+  17: "Boolean",
+  18: "Array",
+  19: "Object",
+  20: "Key",
+  21: "Null",
+  22: "EnumMember",
+  23: "Struct",
+  24: "Event",
+  25: "Operator",
+  26: "TypeParameter"
+};
+var LspManager = class {
+  cwd;
+  spawnImpl;
+  timeoutMs;
+  servers = /* @__PURE__ */ new Map();
+  // language → entry (null = unavailable)
+  constructor(options = {}) {
+    this.cwd = options.cwd ?? process.cwd();
+    this.spawnImpl = options.spawnImpl ?? spawn3;
+    this.timeoutMs = options.timeoutMs ?? 15e3;
+  }
+  /** Lazily start (or reuse) the server for a file's language. Null if none. */
+  getServer(file2) {
+    const cmd = resolveServerCommand(file2, this.cwd);
+    if (!cmd) return null;
+    const cached2 = this.servers.get(cmd.language);
+    if (cached2 !== void 0) return cached2;
+    let entry = null;
+    try {
+      const child = this.spawnImpl(cmd.command, cmd.args, {
+        cwd: this.cwd
+      });
+      const client = new LspClient(processTransport(child), { timeoutMs: this.timeoutMs });
+      const initialized = client.request("initialize", {
+        processId: process.pid,
+        rootUri: pathToUri(this.cwd),
+        capabilities: {},
+        workspaceFolders: [{ uri: pathToUri(this.cwd), name: "root" }]
+      }).then(() => {
+        client.notify("initialized", {});
+      });
+      entry = { client, initialized, opened: /* @__PURE__ */ new Map(), dispose: () => client.dispose() };
+    } catch {
+      entry = null;
+    }
+    this.servers.set(cmd.language, entry);
+    return entry;
+  }
+  /** Ensure a document is open (or synced) on the server. */
+  async openDoc(entry, file2) {
+    await entry.initialized;
+    const uri = pathToUri(file2);
+    let text;
+    try {
+      text = readFileSync5(file2, "utf8");
+    } catch {
+      text = "";
+    }
+    const prev2 = entry.opened.get(uri);
+    if (prev2 === void 0) {
+      entry.client.notify("textDocument/didOpen", {
+        textDocument: { uri, languageId: languageIdForFile(file2), version: 1, text }
+      });
+      entry.opened.set(uri, 1);
+    } else {
+      const version2 = prev2 + 1;
+      entry.client.notify("textDocument/didChange", {
+        textDocument: { uri, version: version2 },
+        contentChanges: [{ text }]
+      });
+      entry.opened.set(uri, version2);
+    }
+    return uri;
+  }
+  async withDoc(file2, fn, fallback) {
+    const entry = this.getServer(file2);
+    if (!entry) return fallback;
+    try {
+      const uri = await this.openDoc(entry, file2);
+      return await fn(entry, uri);
+    } catch {
+      return fallback;
+    }
+  }
+  async definition(file2, line, character) {
+    return this.withDoc(
+      file2,
+      async (entry, uri) => {
+        const res = await entry.client.request("textDocument/definition", {
+          textDocument: { uri },
+          position: { line, character }
+        });
+        return normalizeLocations(res);
+      },
+      []
+    );
+  }
+  async references(file2, line, character) {
+    return this.withDoc(
+      file2,
+      async (entry, uri) => {
+        const res = await entry.client.request("textDocument/references", {
+          textDocument: { uri },
+          position: { line, character },
+          context: { includeDeclaration: true }
+        });
+        return normalizeLocations(res);
+      },
+      []
+    );
+  }
+  async hover(file2, line, character) {
+    return this.withDoc(
+      file2,
+      async (entry, uri) => {
+        const res = await entry.client.request("textDocument/hover", {
+          textDocument: { uri },
+          position: { line, character }
+        });
+        return extractHoverText(res);
+      },
+      null
+    );
+  }
+  async documentSymbols(file2) {
+    return this.withDoc(
+      file2,
+      async (entry, uri) => {
+        const res = await entry.client.request("textDocument/documentSymbol", {
+          textDocument: { uri }
+        });
+        return normalizeSymbols(res);
+      },
+      []
+    );
+  }
+  async rename(file2, line, character, newName) {
+    return this.withDoc(
+      file2,
+      async (entry, uri) => {
+        const res = await entry.client.request("textDocument/rename", {
+          textDocument: { uri },
+          position: { line, character },
+          newName
+        });
+        return normalizeRename(res);
+      },
+      null
+    );
+  }
+  dispose() {
+    for (const entry of this.servers.values()) entry?.dispose();
+    this.servers.clear();
+  }
+};
+var shared = null;
+function getSharedLspManager(cwd = process.cwd()) {
+  if (shared && shared.cwd === cwd) return shared.manager;
+  shared?.manager.dispose();
+  const manager = new LspManager({ cwd });
+  shared = { cwd, manager };
+  return manager;
+}
+if (typeof process !== "undefined" && typeof process.once === "function") {
+  process.once("exit", () => {
+    try {
+      shared?.manager.dispose();
+    } catch {
+    }
+  });
+}
+function normalizeLocations(res) {
+  if (!res) return [];
+  const arr = Array.isArray(res) ? res : [res];
+  const out = [];
+  for (const item of arr) {
+    if (!item || typeof item !== "object") continue;
+    const loc = item;
+    const uri = loc.uri ?? loc.targetUri;
+    const range = loc.range ?? loc.targetRange;
+    if (typeof uri === "string" && range) out.push({ uri, range });
+  }
+  return out;
+}
+function extractHoverText(res) {
+  if (!res || !res.contents) return null;
+  const c = res.contents;
+  if (typeof c === "string") return c.trim() || null;
+  if (Array.isArray(c)) {
+    return c.map((x) => typeof x === "string" ? x : x?.value ?? "").filter(Boolean).join("\n").trim() || null;
+  }
+  if (typeof c === "object" && "value" in c) {
+    return (c.value ?? "").trim() || null;
+  }
+  return null;
+}
+function normalizeSymbols(res) {
+  if (!Array.isArray(res)) return [];
+  const out = [];
+  const visit = (nodes) => {
+    for (const n of nodes) {
+      if (!n || typeof n !== "object") continue;
+      const s = n;
+      const line0 = s.range?.start?.line ?? s.location?.range?.start?.line;
+      if (typeof s.name === "string" && typeof line0 === "number") {
+        out.push({ name: s.name, kind: SYMBOL_KINDS[s.kind ?? 0] ?? "Symbol", line: line0 + 1 });
+      }
+      if (Array.isArray(s.children)) visit(s.children);
+    }
+  };
+  visit(res);
+  return out;
+}
+function normalizeRename(res) {
+  if (!res) return null;
+  const files = [];
+  let total = 0;
+  if (res.changes && typeof res.changes === "object") {
+    for (const [uri, edits] of Object.entries(res.changes)) {
+      const count = Array.isArray(edits) ? edits.length : 0;
+      files.push({ file: uriToPath(uri), count });
+      total += count;
+    }
+  }
+  if (Array.isArray(res.documentChanges)) {
+    for (const dc of res.documentChanges) {
+      const d = dc;
+      if (d?.textDocument?.uri) {
+        const count = Array.isArray(d.edits) ? d.edits.length : 0;
+        files.push({ file: uriToPath(d.textDocument.uri), count });
+        total += count;
+      }
+    }
+  }
+  if (files.length === 0) return null;
+  return { files, totalEdits: total };
+}
+
+// src/cli/ast/tools.ts
+init_zod();
+init_toolTypes();
+
+// src/cli/ast/engine.ts
+import { readFile } from "node:fs/promises";
+import path18 from "node:path";
+var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+function isAstSupported(file2) {
+  return TS_EXTENSIONS.has(path18.extname(file2).toLowerCase());
+}
+var tsPromise;
+function loadTs() {
+  if (!tsPromise) {
+    tsPromise = import("typescript").then((m) => m.default ?? m).catch(() => null);
+  }
+  return tsPromise;
+}
+async function parseFileSymbols(file2) {
+  if (!isAstSupported(file2)) return [];
+  const ts = await loadTs();
+  if (!ts) return [];
+  let text;
+  try {
+    text = await readFile(file2, "utf8");
+  } catch {
+    return [];
+  }
+  let source;
+  try {
+    source = ts.createSourceFile(path18.basename(file2), text, ts.ScriptTarget.Latest, true);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const lineOf = (pos) => source.getLineAndCharacterOfPosition(pos).line + 1;
+  const hasExport = (node) => {
+    const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+    return !!mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+  };
+  const record2 = (name, kind, node, exported) => {
+    out.push({
+      name,
+      kind,
+      line: lineOf(node.getStart(source)),
+      endLine: lineOf(node.getEnd()),
+      exported,
+      text: node.getText(source)
+    });
+  };
+  const visit = (node) => {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      record2(node.name.text, "function", node, hasExport(node));
+    } else if (ts.isClassDeclaration(node) && node.name) {
+      record2(node.name.text, "class", node, hasExport(node));
+      for (const member of node.members) {
+        if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+          record2(member.name.text, "method", member, false);
+        }
+      }
+    } else if (ts.isInterfaceDeclaration(node)) {
+      record2(node.name.text, "interface", node, hasExport(node));
+    } else if (ts.isTypeAliasDeclaration(node)) {
+      record2(node.name.text, "type", node, hasExport(node));
+    } else if (ts.isEnumDeclaration(node)) {
+      record2(node.name.text, "enum", node, hasExport(node));
+    } else if (ts.isVariableStatement(node)) {
+      const exported = hasExport(node);
+      for (const decl of node.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name)) continue;
+        const init = decl.initializer;
+        const isFn = !!init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init));
+        record2(decl.name.text, isFn ? "function" : "variable", node, exported);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return out;
+}
+async function astOutline(file2) {
+  const symbols = await parseFileSymbols(file2);
+  return symbols.map(({ text: _text, ...rest }) => rest);
+}
+async function findSymbol(file2, name) {
+  const symbols = await parseFileSymbols(file2);
+  return symbols.find((s) => s.name === name) ?? null;
+}
+
+// src/cli/ast/tools.ts
+var MAX_TEXT_CHARS = 4e3;
+function createAstTools() {
+  const outline = {
+    name: "ast_outline",
+    description: "Structural outline of a TS/JS file: every declaration (function, class, method, interface, type, enum, variable) with its line range and whether it's exported. Faster and more precise than reading the whole file to find where things are. TS/JS only.",
+    permissions: ["read"],
+    inputSchema: external_exports.object({
+      path: external_exports.string().min(1).describe("Path to the TS/JS file to outline.")
+    }),
+    execute: async (args) => {
+      const { path: file2 } = args;
+      const symbols = await astOutline(file2);
+      if (symbols.length === 0) {
+        return typedOk({ symbols: [], note: "no declarations found (or not a TS/JS file / TypeScript unavailable)" });
+      }
+      return typedOk({
+        count: symbols.length,
+        symbols: symbols.map(
+          (s) => `${s.exported ? "export " : ""}${s.kind} ${s.name} (lines ${s.line}-${s.endLine})`
+        )
+      });
+    }
+  };
+  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. TS/JS only.",
+    permissions: ["read"],
+    inputSchema: external_exports.object({
+      path: external_exports.string().min(1).describe("Path to the TS/JS file."),
+      name: external_exports.string().min(1).describe("The declaration name to find (function/class/method/etc).")
+    }),
+    execute: async (args) => {
+      const { path: file2, name } = args;
+      const sym = await findSymbol(file2, name);
+      if (!sym) {
+        return typedOk({ found: false, note: `no declaration named "${name}" found in ${file2}` });
+      }
+      const truncated = sym.text.length > MAX_TEXT_CHARS;
+      return typedOk({
+        found: true,
+        kind: sym.kind,
+        exported: sym.exported,
+        line: sym.line,
+        endLine: sym.endLine,
+        text: truncated ? `${sym.text.slice(0, MAX_TEXT_CHARS)}
+\u2026 (truncated, ${sym.text.length} chars total)` : sym.text
+      });
+    }
+  };
+  return [outline, findSymbolTool];
+}
+
+// src/cli/semantic/tools.ts
+init_zod();
+init_toolTypes();
+import path20 from "node:path";
+
+// src/cli/semantic/index.ts
+import { promises as fs12, existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import path19 from "node:path";
+import { createHash } from "node:crypto";
+
+// src/cli/semantic/store.ts
+function chunkFile(file2, text, opts = {}) {
+  const maxLines = Math.max(1, opts.maxLines ?? 40);
+  const overlap = Math.max(0, Math.min(opts.overlap ?? 8, maxLines - 1));
+  const lines = text.split("\n");
+  const step = maxLines - overlap;
+  const chunks = [];
+  for (let start = 0; start < lines.length; start += step) {
+    const end = Math.min(start + maxLines, lines.length);
+    const slice = lines.slice(start, end);
+    if (slice.join("").trim().length > 0) {
+      chunks.push({
+        file: file2,
+        startLine: start + 1,
+        endLine: end,
+        text: slice.join("\n")
+      });
+    }
+    if (end >= lines.length) break;
+  }
+  return chunks;
+}
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+function searchIndex(data, queryEmbedding, k = 8) {
+  const scored = [];
+  for (const chunk of data.chunks) {
+    const score = cosineSimilarity(queryEmbedding, chunk.embedding);
+    scored.push({
+      file: chunk.file,
+      startLine: chunk.startLine,
+      endLine: chunk.endLine,
+      text: chunk.text,
+      score
+    });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, Math.max(0, k));
+}
+
+// src/cli/semantic/index.ts
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".rb",
+  ".php",
+  ".c",
+  ".h",
+  ".cc",
+  ".cpp",
+  ".hpp",
+  ".cs",
+  ".swift",
+  ".kt",
+  ".scala",
+  ".sh",
+  ".md"
+]);
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache",
+  "vendor",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".tmp"
+]);
+function getIndexPath(root) {
+  const hash3 = createHash("sha1").update(path19.resolve(root)).digest("hex").slice(0, 16);
+  return process.env.ZELARI_SEMANTIC_FILE ?? path19.join(homedir3(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
+}
+async function collectSourceFiles(root, maxFiles = 1500) {
+  const out = [];
+  const walk2 = async (dir) => {
+    if (out.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = await fs12.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.length >= maxFiles) return;
+      if (entry.name.startsWith(".") && entry.name !== ".") {
+        if (entry.isDirectory() && IGNORE_DIRS.has(entry.name)) continue;
+        if (entry.isDirectory()) continue;
+      }
+      const full = path19.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        await walk2(full);
+      } else if (SOURCE_EXTENSIONS.has(path19.extname(entry.name).toLowerCase())) {
+        out.push(full);
+      }
+    }
+  };
+  await walk2(root);
+  return out;
+}
+async function buildIndex(files, embed, options) {
+  const batchSize = options.batchSize ?? 64;
+  const maxChunkChars = options.maxChunkChars ?? 8e3;
+  const chunks = [];
+  let filesIndexed = 0;
+  for (const file2 of files) {
+    let text;
+    try {
+      text = await fs12.readFile(file2, "utf8");
+    } catch {
+      continue;
+    }
+    const fileChunks = chunkFile(file2, text, options).filter((c) => c.text.length <= maxChunkChars);
+    if (fileChunks.length > 0) filesIndexed += 1;
+    chunks.push(...fileChunks);
+  }
+  if (chunks.length === 0) {
+    return { error: "no indexable source found", filesIndexed: 0, chunksIndexed: 0 };
+  }
+  const indexed = [];
+  for (let i = 0; i < chunks.length; i += batchSize) {
+    const batch = chunks.slice(i, i + batchSize);
+    const res = await embed(batch.map((c) => c.text));
+    if ("error" in res) {
+      return { error: res.error, filesIndexed, chunksIndexed: 0 };
+    }
+    if (res.length !== batch.length) {
+      return { error: "embedding count mismatch", filesIndexed, chunksIndexed: 0 };
+    }
+    batch.forEach((c, j) => indexed.push({ ...c, embedding: res[j] }));
+  }
+  const data = {
+    model: options.model,
+    dim: indexed[0]?.embedding.length ?? 0,
+    chunks: indexed,
+    builtAt: Date.now()
+  };
+  return { data, filesIndexed, chunksIndexed: indexed.length };
+}
+async function saveIndex(root, data) {
+  const file2 = getIndexPath(root);
+  await fs12.mkdir(path19.dirname(file2), { recursive: true });
+  const tmp = `${file2}.tmp-${process.pid}`;
+  await fs12.writeFile(tmp, JSON.stringify(data), "utf8");
+  await fs12.rename(tmp, file2);
+}
+function loadIndex(root) {
+  const file2 = getIndexPath(root);
+  if (!existsSync8(file2)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync6(file2, "utf8"));
+    if (parsed && Array.isArray(parsed.chunks)) return parsed;
+  } catch {
+  }
+  return null;
+}
+async function semanticSearch(root, query, embed, k = 8) {
+  const data = loadIndex(root);
+  if (!data) return { error: "no semantic index \u2014 run /index first" };
+  const res = await embed([query]);
+  if ("error" in res) return { error: res.error };
+  const vector = res[0];
+  if (!vector) return { error: "query embedding failed" };
+  return { hits: searchIndex(data, vector, k) };
+}
+
+// src/cli/semantic/provider.ts
+init_openai_compatible();
+
+// src/cli/semantic/embeddings.ts
+function parseEmbeddingsResponse(json2, expected) {
+  if (!json2 || typeof json2 !== "object") return null;
+  const data = json2.data;
+  if (!Array.isArray(data)) return null;
+  const rows = [];
+  for (const item of data) {
+    if (!item || typeof item !== "object") continue;
+    const it = item;
+    if (!Array.isArray(it.embedding)) continue;
+    const embedding = it.embedding.filter((n) => typeof n === "number");
+    if (embedding.length === 0) continue;
+    rows.push({ index: typeof it.index === "number" ? it.index : rows.length, embedding });
+  }
+  if (rows.length === 0) return null;
+  rows.sort((a, b) => a.index - b.index);
+  const out = rows.map((r) => r.embedding);
+  return out.length === expected ? out : null;
+}
+async function embedTexts(texts, config2, fetchImpl = fetch) {
+  if (texts.length === 0) return { embeddings: [] };
+  const url2 = `${config2.baseUrl.replace(/\/$/, "")}/embeddings`;
+  let response;
+  try {
+    response = await fetchImpl(url2, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config2.apiKey}`
+      },
+      body: JSON.stringify({ model: config2.model, input: texts })
+    });
+  } catch (err) {
+    return { error: `network error contacting ${url2}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    return { error: `HTTP ${response.status} from ${url2}: ${body.slice(0, 160)}` };
+  }
+  let json2;
+  try {
+    json2 = await response.json();
+  } catch (err) {
+    return { error: `invalid JSON from ${url2}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const embeddings = parseEmbeddingsResponse(json2, texts.length);
+  if (!embeddings) return { error: `unexpected embeddings response shape from ${url2}` };
+  return { embeddings };
+}
+
+// src/cli/semantic/provider.ts
+var DEFAULT_EMBED_MODEL = "text-embedding-3-small";
+function embedModel() {
+  return process.env.ZELARI_EMBED_MODEL ?? DEFAULT_EMBED_MODEL;
+}
+async function buildProviderEmbedFn() {
+  const cfg = await providerFromEnv();
+  if (!cfg) return null;
+  const embedCfg = { apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, model: embedModel() };
+  return async (texts) => {
+    const res = await embedTexts(texts, embedCfg);
+    return "error" in res ? { error: res.error } : res.embeddings;
+  };
+}
+
+// src/cli/semantic/tools.ts
+function createSemanticTool(deps) {
+  const buildEmbedFn = deps.buildEmbedFn ?? buildProviderEmbedFn;
+  return {
+    name: "semantic_search",
+    description: 'Concept-level search over the indexed codebase: describe what you are looking for in plain language ("where is rate-limit backoff handled?") and get the most relevant code chunks (file:line + snippet), even when they share no exact keyword with your query. Requires an index \u2014 if none exists, ask the user to run /index. Complements grep_content (exact matches).',
+    permissions: ["read"],
+    inputSchema: external_exports.object({
+      query: external_exports.string().min(1).describe("Natural-language description of the code you want."),
+      k: external_exports.number().int().positive().max(25).optional().describe("Max results (default 8).")
+    }),
+    execute: async (args) => {
+      const { query, k } = args;
+      if (!loadIndex(deps.root)) {
+        return typedOk({ results: [], note: "no semantic index yet \u2014 run /index to build one, then retry" });
+      }
+      const embed = await buildEmbedFn();
+      if (!embed) {
+        return typedOk({ results: [], note: "no provider/API key configured for embeddings" });
+      }
+      const res = await semanticSearch(deps.root, query, embed, k ?? 8);
+      if ("error" in res) {
+        return typedOk({ results: [], note: `semantic search unavailable: ${res.error}` });
+      }
+      return typedOk({
+        count: res.hits.length,
+        results: res.hits.map((h) => ({
+          location: `${path20.relative(deps.root, h.file) || h.file}:${h.startLine}-${h.endLine}`,
+          score: Number(h.score.toFixed(3)),
+          preview: h.text.length > 400 ? `${h.text.slice(0, 400)}\u2026` : h.text
+        }))
+      });
+    }
+  };
+}
+
+// src/cli/browser/tools.ts
+init_zod();
+init_toolTypes();
+import path21 from "node:path";
+import os7 from "node:os";
+
+// src/cli/browser/driver.ts
+var defaultPlaywrightLoader = async () => {
+  try {
+    const pkg = "playwright";
+    const mod = await import(pkg);
+    if (mod && mod.chromium && typeof mod.chromium.launch === "function") return mod;
+    return null;
+  } catch {
+    return null;
+  }
+};
+async function runBrowserCheck(options, loader = defaultPlaywrightLoader) {
+  const consoleErrors = [];
+  const pageErrors = [];
+  const failedRequests = [];
+  const base = { ok: false, consoleErrors, pageErrors, failedRequests };
+  const pw = await loader();
+  if (!pw) {
+    return {
+      ...base,
+      error: "browser automation unavailable \u2014 install Playwright (`npm i -D playwright && npx playwright install chromium`) to enable browser_check"
+    };
+  }
+  const timeout = options.timeoutMs ?? 15e3;
+  let browser;
+  try {
+    browser = await pw.chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    page.on("console", (msg) => {
+      if (msg.type() === "error") consoleErrors.push(msg.text());
+    });
+    page.on("pageerror", (err) => pageErrors.push(err.message));
+    page.on("requestfailed", (req) => {
+      const f = req.failure();
+      failedRequests.push(`${req.url()}${f ? ` (${f.errorText})` : ""}`);
+    });
+    await page.goto(options.url, { waitUntil: "load", timeout });
+    for (const action of options.actions ?? []) {
+      switch (action.type) {
+        case "click":
+          await page.click(action.selector, { timeout });
+          break;
+        case "fill":
+          await page.fill(action.selector, action.value, { timeout });
+          break;
+        case "goto":
+          await page.goto(action.url, { waitUntil: "load", timeout });
+          break;
+        case "wait":
+          await page.waitForTimeout(action.ms);
+          break;
+        default:
+          break;
+      }
+    }
+    let selectorFound;
+    if (options.waitForSelector) {
+      try {
+        await page.waitForSelector(options.waitForSelector, { timeout });
+        selectorFound = true;
+      } catch {
+        selectorFound = false;
+      }
+    }
+    let screenshotPath;
+    if (options.screenshotPath) {
+      try {
+        await page.screenshot({ path: options.screenshotPath });
+        screenshotPath = options.screenshotPath;
+      } catch {
+      }
+    }
+    const title = await page.title().catch(() => void 0);
+    return {
+      ok: true,
+      consoleErrors,
+      pageErrors,
+      failedRequests,
+      url: page.url(),
+      ...title !== void 0 ? { title } : {},
+      ...selectorFound !== void 0 ? { selectorFound } : {},
+      ...screenshotPath ? { screenshotPath } : {}
+    };
+  } catch (err) {
+    return { ...base, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    try {
+      await browser?.close();
+    } catch {
+    }
+  }
+}
+
+// src/cli/browser/tools.ts
+var ActionSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("click"), selector: external_exports.string().min(1) }),
+  external_exports.object({ type: external_exports.literal("fill"), selector: external_exports.string().min(1), value: external_exports.string() }),
+  external_exports.object({ type: external_exports.literal("wait"), ms: external_exports.number().int().positive().max(3e4) }),
+  external_exports.object({ type: external_exports.literal("goto"), url: external_exports.string().min(1) })
+]);
+function createBrowserTool(deps = {}) {
+  return {
+    name: "browser_check",
+    description: 'Open a URL in a headless browser to VERIFY a web change: optionally run click/fill/goto/wait actions, then report console errors, uncaught page exceptions, failed network requests, the final title/URL, whether an expected selector appeared, and a screenshot path. Use it to confirm UI edits actually render and run \u2014 stronger than "tests pass" for front-end. Requires Playwright (optional dependency).',
+    permissions: ["network"],
+    // A browser launch + navigation can take a while.
+    timeoutMs: 6e4,
+    inputSchema: external_exports.object({
+      url: external_exports.string().min(1).describe("URL to open (e.g. http://localhost:3000)."),
+      actions: external_exports.array(ActionSchema).optional().describe("Optional sequence of interactions before checking."),
+      waitForSelector: external_exports.string().optional().describe("Assert this CSS selector is present after actions."),
+      screenshot: external_exports.boolean().optional().describe("Save a screenshot (default true).")
+    }),
+    execute: async (args) => {
+      const a = args;
+      const dir = deps.screenshotDir ?? os7.tmpdir();
+      const screenshotPath = a.screenshot === false ? void 0 : path21.join(dir, `zelari-browser-${Date.now()}.png`);
+      const result = await runBrowserCheck(
+        {
+          url: a.url,
+          ...a.actions ? { actions: a.actions } : {},
+          ...a.waitForSelector ? { waitForSelector: a.waitForSelector } : {},
+          ...screenshotPath ? { screenshotPath } : {}
+        },
+        deps.loader
+      );
+      if (!result.ok) {
+        return typedOk({ ok: false, note: result.error ?? "browser check failed" });
+      }
+      const clean = result.consoleErrors.length === 0 && result.pageErrors.length === 0 && result.failedRequests.length === 0 && result.selectorFound !== false;
+      return typedOk({
+        ok: true,
+        clean,
+        title: result.title,
+        url: result.url,
+        consoleErrors: result.consoleErrors,
+        pageErrors: result.pageErrors,
+        failedRequests: result.failedRequests,
+        ...result.selectorFound !== void 0 ? { selectorFound: result.selectorFound } : {},
+        ...result.screenshotPath ? { screenshotPath: result.screenshotPath } : {}
+      });
+    }
+  };
+}
+
 // src/cli/toolRegistry.ts
 init_openai_compatible();
 function createBuiltinToolRegistry(options = {}) {
@@ -30790,6 +31950,30 @@ function createBuiltinToolRegistry(options = {}) {
     description: t.description,
     permissions: t.permissions ?? []
   }));
+  if (process.env.ZELARI_AST !== "0") {
+    for (const t of createAstTools()) {
+      registry3.register(t);
+      tools.push({ name: t.name, description: t.description, permissions: t.permissions ?? [] });
+    }
+  }
+  if (process.env.ZELARI_SEMANTIC !== "0") {
+    const semanticTool = createSemanticTool({ root });
+    registry3.register(semanticTool);
+    tools.push({
+      name: semanticTool.name,
+      description: semanticTool.description,
+      permissions: semanticTool.permissions ?? []
+    });
+  }
+  if (!readOnly && process.env.ZELARI_BROWSER !== "0") {
+    const browserTool = createBrowserTool();
+    registry3.register(browserTool);
+    tools.push({
+      name: browserTool.name,
+      description: browserTool.description,
+      permissions: browserTool.permissions ?? []
+    });
+  }
   if (!readOnly && options.enableTask !== false) {
     const taskTool = createTaskTool({
       createSubAgentContext: async () => {
@@ -30822,6 +32006,13 @@ function createBuiltinToolRegistry(options = {}) {
       permissions: taskTool.permissions ?? []
     });
   }
+  if (!readOnly && process.env.ZELARI_LSP !== "0" && options.lspProvider !== null) {
+    const lspTools = options.lspProvider ? createLspTools(options.lspProvider, root) : createLspTools(getSharedLspManager(root), root);
+    for (const t of lspTools) {
+      registry3.register(t);
+      tools.push({ name: t.name, description: t.description, permissions: t.permissions ?? [] });
+    }
+  }
   return { registry: registry3, tools };
 }
 function wrapWithSandbox(original, pathArgs, root, audit, sessionId) {
@@ -32021,6 +33212,8 @@ function handleSlashCommand(text, availableSkills) {
   /undo [--yes] \u2014 revert working-tree changes (destructive! requires --yes)
   /checkpoint [label] \u2014 snapshot the working tree as a restore point
   /rollback [id|latest] \u2014 restore the working tree to a checkpoint (no arg: list)
+  /index [status] \u2014 build the semantic code index for semantic_search
+  /mode [agent|council|zelari] \u2014 switch dispatch mode (same as shift+tab; no arg cycles)
   /help \u2014 show this help
   /exit \u2014 exit the CLI
 
@@ -32358,6 +33551,19 @@ ${formatSkillList(availableSkills)}`
         message: "\u26A0 /undo is DESTRUCTIVE \u2014 it reverts all unstaged modifications and unstages everything.\nUse `/undo --yes` (or `/undo -y`) to confirm."
       };
     }
+    case "mode": {
+      const target = args[0]?.trim().toLowerCase();
+      if (target && ["agent", "council", "zelari"].includes(target)) {
+        return { handled: true, kind: "mode_set", modeTarget: target };
+      }
+      if (target) {
+        return { handled: true, kind: "mode_set", message: `[mode] unknown: ${target}. Use agent, council, or zelari (or /mode to cycle).` };
+      }
+      return { handled: true, kind: "mode_set" };
+    }
+    case "index": {
+      return args[0] === "status" ? { handled: true, kind: "index_status" } : { handled: true, kind: "index_build" };
+    }
     case "checkpoint": {
       const label = args.join(" ").trim();
       return {
@@ -32442,7 +33648,7 @@ ${formatSkillList(availableSkills)}`
 // src/cli/gitOps.ts
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-import path21 from "node:path";
+import path27 from "node:path";
 var execFileAsync2 = promisify2(execFile3);
 async function git2(cwd, args) {
   try {
@@ -32488,7 +33694,7 @@ async function undoWorkingChanges(opts = {}) {
   };
 }
 function defaultProjectRoot() {
-  return path21.resolve(__dirname, "..", "..", "..");
+  return path27.resolve(__dirname, "..", "..", "..");
 }
 
 // src/cli/slashHandlers/git.ts
@@ -32583,6 +33789,66 @@ async function handleRollback(ctx, id) {
   }
 }
 
+// src/cli/slashHandlers/semantic.ts
+async function handleIndexBuild(ctx) {
+  const embed = await buildProviderEmbedFn();
+  if (!embed) {
+    appendSystem(ctx.setMessages, "[index] no provider/API key configured \u2014 run /login first.");
+    return;
+  }
+  appendSystem(
+    ctx.setMessages,
+    `[index] scanning source files and embedding with "${embedModel()}"\u2026 (this can take a moment)`
+  );
+  const files = await collectSourceFiles(ctx.cwd);
+  if (files.length === 0) {
+    appendSystem(ctx.setMessages, "[index] no source files found to index.");
+    return;
+  }
+  const result = await buildIndex(files, embed, { model: embedModel() });
+  if (result.error || !result.data) {
+    appendSystem(
+      ctx.setMessages,
+      `[index] \u2717 ${result.error ?? "build failed"}` + (result.error?.includes("HTTP") || result.error?.includes("shape") ? "\n  (does this provider expose /embeddings? set ZELARI_EMBED_MODEL or switch provider.)" : "")
+    );
+    return;
+  }
+  await saveIndex(ctx.cwd, result.data);
+  appendSystem(
+    ctx.setMessages,
+    `[index] \u2713 indexed ${result.chunksIndexed} chunks from ${result.filesIndexed} files (dim ${result.data.dim}). Use semantic_search now. Saved to ${getIndexPath(ctx.cwd)}`
+  );
+}
+function handleIndexStatus(ctx) {
+  const data = loadIndex(ctx.cwd);
+  if (!data) {
+    appendSystem(ctx.setMessages, "[index] no semantic index yet \u2014 run /index to build one.");
+    return;
+  }
+  const ageMin = Math.round((Date.now() - data.builtAt) / 6e4);
+  appendSystem(
+    ctx.setMessages,
+    `[index] ${data.chunks.length} chunks, model "${data.model}", dim ${data.dim}, built ${ageMin}m ago.`
+  );
+}
+
+// src/cli/mode.ts
+var MODES = ["agent", "council", "zelari"];
+function nextMode(current) {
+  const i = MODES.indexOf(current);
+  return MODES[(i + 1) % MODES.length] ?? "agent";
+}
+function describeMode(mode) {
+  switch (mode) {
+    case "council":
+      return "council \u2014 6-member pipeline (Caronte\u2026Lucifero)";
+    case "zelari":
+      return "zelari \u2014 autonomous multi-run mission";
+    default:
+      return "agent \u2014 single LLM turn";
+  }
+}
+
 // src/cli/compaction.ts
 function compactTranscript(messages, options = {}) {
   const threshold = options.threshold ?? 50;
@@ -32720,17 +33986,17 @@ ${output}`.toLowerCase();
 }
 
 // src/cli/slashHandlers/promoteMember.ts
-import { promises as fs15 } from "node:fs";
-import path22 from "node:path";
-import os8 from "node:os";
+import { promises as fs16 } from "node:fs";
+import path28 from "node:path";
+import os9 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 ?? path22.join(os8.homedir(), ".tmp", "zelari-code", "skills");
-    await fs15.mkdir(skillDir, { recursive: true });
-    const filePath = path22.join(skillDir, `${skill.id}.md`);
-    await fs15.writeFile(filePath, markdown, "utf8");
+    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path28.join(os9.homedir(), ".tmp", "zelari-code", "skills");
+    await fs16.mkdir(skillDir, { recursive: true });
+    const filePath = path28.join(skillDir, `${skill.id}.md`);
+    await fs16.writeFile(filePath, markdown, "utf8");
     appendSystem(
       ctx.setMessages,
       `[promote-member] ${skill.name} (${memberId}) \u2192 ${filePath}
@@ -32746,33 +34012,33 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs16, existsSync as existsSync24, readFileSync as readFileSync21, writeFileSync as writeFileSync15, mkdirSync as mkdirSync10, statSync as statSync4, rmSync as rmSync2 } from "node:fs";
-import path23 from "node:path";
-import os9 from "node:os";
+import { promises as fs17, existsSync as existsSync25, readFileSync as readFileSync23, writeFileSync as writeFileSync15, mkdirSync as mkdirSync10, statSync as statSync4, rmSync as rmSync2 } from "node:fs";
+import path29 from "node:path";
+import os10 from "node:os";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
-  return process.env.ANATHEMA_BRANCHES_DIR ?? path23.join(os9.homedir(), ".tmp", "zelari-code", "branches");
+  return process.env.ANATHEMA_BRANCHES_DIR ?? path29.join(os10.homedir(), ".tmp", "zelari-code", "branches");
 }
 function getSessionsBaseDir() {
-  return process.env.ANATHEMA_SESSIONS_DIR ?? path23.join(os9.homedir(), ".tmp", "zelari-code", "sessions");
+  return process.env.ANATHEMA_SESSIONS_DIR ?? path29.join(os10.homedir(), ".tmp", "zelari-code", "sessions");
 }
 function branchPathFor(name, baseDir) {
-  return path23.join(baseDir, name);
+  return path29.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path23.join(baseDir, name, META_FILENAME);
+  return path29.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path23.join(baseDir, name, SESSIONS_SUBDIR);
+  return path29.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
-  if (!existsSync24(metaPath)) {
+  if (!existsSync25(metaPath)) {
     throw new BranchNotFoundError(`Branch "${name}" not found`);
   }
   try {
-    const raw = readFileSync21(metaPath, "utf-8");
+    const raw = readFileSync23(metaPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || typeof parsed.name !== "string" || typeof parsed.createdAt !== "number" || typeof parsed.fromSessionId !== "string") {
       throw new BranchCorruptError(`Branch "${name}" meta.json is malformed`);
@@ -32789,13 +34055,13 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync10(path23.dirname(metaPath), { recursive: true });
+  mkdirSync10(path29.dirname(metaPath), { recursive: true });
   writeFileSync15(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
   try {
-    const entries = await fs16.readdir(sessionsPath);
+    const entries = await fs17.readdir(sessionsPath);
     return entries.filter((e) => e.endsWith(".jsonl")).length;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
@@ -32828,7 +34094,7 @@ var SessionNotFoundError = class extends Error {
 };
 function branchExists(name, baseDir = getBranchesBaseDir()) {
   const bp = branchPathFor(name, baseDir);
-  return existsSync24(bp) && existsSync24(metaPathFor(name, baseDir));
+  return existsSync25(bp) && existsSync25(metaPathFor(name, baseDir));
 }
 async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(), sessionsBaseDir = getSessionsBaseDir()) {
   if (!name || name.trim().length === 0) {
@@ -32840,15 +34106,15 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path23.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
-  if (!existsSync24(sourcePath)) {
+  const sourcePath = path29.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  if (!existsSync25(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync10(branchSessionsPath, { recursive: true });
-  const destPath = path23.join(branchSessionsPath, `${fromSessionId}.jsonl`);
-  await fs16.copyFile(sourcePath, destPath);
+  const destPath = path29.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  await fs17.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
     createdAt: Date.now(),
@@ -32866,7 +34132,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
 async function listBranches(baseDir = getBranchesBaseDir()) {
   let entries;
   try {
-    entries = await fs16.readdir(baseDir);
+    entries = await fs17.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -32874,7 +34140,7 @@ async function listBranches(baseDir = getBranchesBaseDir()) {
   const results = [];
   for (const entry of entries) {
     const metaPath = metaPathFor(entry, baseDir);
-    if (!existsSync24(metaPath)) continue;
+    if (!existsSync25(metaPath)) continue;
     try {
       const meta3 = readBranchMeta(entry, baseDir);
       const sessionCount = await countSessions(entry, baseDir);
@@ -32947,26 +34213,26 @@ async function handleBranchCheckout(ctx, branchName) {
 }
 
 // src/cli/slashHandlers/workspace.ts
-import { promises as fs17 } from "node:fs";
-import path24 from "node:path";
+import { promises as fs18 } from "node:fs";
+import path30 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path24.join(process.cwd(), ".zelari");
+    const zelari = path30.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path24.join(zelari, "plan.md");
+        const planPath = path30.join(zelari, "plan.md");
         try {
-          content = await fs17.readFile(planPath, "utf-8");
+          content = await fs18.readFile(planPath, "utf-8");
         } catch {
           content = "(no plan.md yet \u2014 run a council session first)";
         }
         break;
       }
       case "decisions": {
-        const decisionsDir = path24.join(zelari, "decisions");
+        const decisionsDir = path30.join(zelari, "decisions");
         try {
-          const files = (await fs17.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs18.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
             content = "(no ADRs yet \u2014 invoke /council to generate some)";
           } else {
@@ -32974,7 +34240,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 fs17.readFile(path24.join(decisionsDir, f), "utf-8");
+              const raw = await fs18.readFile(path30.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}`);
@@ -32987,27 +34253,27 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path24.join(zelari, "risks.md");
+        const risksPath = path30.join(zelari, "risks.md");
         try {
-          content = await fs17.readFile(risksPath, "utf-8");
+          content = await fs18.readFile(risksPath, "utf-8");
         } catch {
           content = "(no risks.md yet)";
         }
         break;
       }
       case "agents": {
-        const agentsPath = path24.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path30.join(process.cwd(), "AGENTS.MD");
         try {
-          content = await fs17.readFile(agentsPath, "utf-8");
+          content = await fs18.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 = path24.join(zelari, "docs");
+        const docsDir = path30.join(zelari, "docs");
         try {
-          const files = (await fs17.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs18.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
 
 ` + files.map((f) => `- ${f}`).join("\n") : "(no docs drafts yet)";
@@ -33047,8 +34313,8 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path24.join(process.cwd(), ".zelari");
-    await fs17.rm(target, { recursive: true, force: true });
+    const target = path30.join(process.cwd(), ".zelari");
+    await fs18.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)}`);
@@ -33406,16 +34672,16 @@ function handleModelsRefresh(ctx) {
 }
 
 // src/cli/slashHandlers/skills.ts
-import path25 from "node:path";
-import os10 from "node:os";
+import path31 from "node:path";
+import os11 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs18, existsSync as existsSync25, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync11 } from "node:fs";
+import { promises as fs19, existsSync as existsSync26, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync11 } from "node:fs";
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
   try {
-    raw = await fs18.readFile(file2, "utf-8");
+    raw = await fs19.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -33508,7 +34774,7 @@ async function applySteerInterrupt(options) {
 
 // src/cli/slashHandlers/skills.ts
 async function handleSkillStats(ctx, skillId) {
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path25.join(os10.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path31.join(os11.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const records = await readSkillHistory(historyFile);
     const stats = getSkillStats(records, skillId);
@@ -33524,7 +34790,7 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
     appendSystem(ctx.setMessages, fallbackMessage ?? "[skill-compare] missing args");
     return;
   }
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path25.join(os10.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path31.join(os11.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const formatted = await compareSkillsFromFile(ids[0], ids[1], historyFile);
     appendSystem(ctx.setMessages, formatted);
@@ -33599,7 +34865,8 @@ function useSlashDispatch(params) {
     dispatchPrompt,
     dispatchCouncilPrompt,
     dispatchZelariPrompt,
-    mode = "agent"
+    mode = "agent",
+    setMode
   } = params;
   return useCallback3(async (value) => {
     if (!value.trim()) return;
@@ -33840,6 +35107,29 @@ function useSlashDispatch(params) {
       setInput("");
       return;
     }
+    if (result.kind === "index_build") {
+      await handleIndexBuild({ ...baseCtx, cwd: process.cwd() });
+      setInput("");
+      return;
+    }
+    if (result.kind === "index_status") {
+      handleIndexStatus({ ...baseCtx, cwd: process.cwd() });
+      setInput("");
+      return;
+    }
+    if (result.kind === "mode_set") {
+      if (result.message) {
+        appendSystem(setMessages, result.message);
+      } else if (setMode) {
+        const target = result.modeTarget ?? nextMode(mode);
+        setMode(target);
+        appendSystem(setMessages, `[mode] ${describeMode(target)}`);
+      } else {
+        appendSystem(setMessages, "[mode] switching unavailable in this context");
+      }
+      setInput("");
+      return;
+    }
     if (result.kind === "promote_member" && result.promoteMemberId) {
       await handlePromoteMember(baseCtx, result.promoteMemberId);
       setInput("");
@@ -33906,6 +35196,7 @@ function useSlashDispatch(params) {
     dispatchCouncilPrompt,
     dispatchZelariPrompt,
     mode,
+    setMode,
     params
   ]);
 }
@@ -34034,9 +35325,7 @@ function App() {
   useInput2(
     (_input, key) => {
       if (key.tab && key.shift) {
-        setMode(
-          (m) => m === "agent" ? "council" : m === "council" ? "zelari" : "agent"
-        );
+        setMode(nextMode);
       }
     },
     { isActive: isRawModeSupported === true }
@@ -34094,6 +35383,7 @@ function App() {
     dispatchCouncilPrompt: chatTurn.dispatchCouncilPrompt,
     dispatchZelariPrompt: chatTurn.dispatchZelariPrompt,
     mode,
+    setMode,
     openPicker: setPicker,
     onNewSession,
     onExit,
@@ -34330,9 +35620,9 @@ function SplashGate({
 init_providerConfig();
 
 // src/cli/wizard/firstRun.ts
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 function shouldRunWizard(input) {
-  const exists = input.exists ?? existsSync26;
+  const exists = input.exists ?? existsSync27;
   if (input.hasResetConfigFlag) {
     return { shouldRun: true, reason: "--reset-config flag forced wizard" };
   }
@@ -34822,9 +36112,9 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
 
 // src/cli/skillsMd.ts
 init_skills2();
-import { existsSync as existsSync27, readdirSync as readdirSync4, readFileSync as readFileSync22 } from "node:fs";
+import { existsSync as existsSync28, readdirSync as readdirSync4, readFileSync as readFileSync24 } from "node:fs";
 import { join as join23 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 var CODING_CATEGORIES = /* @__PURE__ */ new Set([
   "plan",
   "refactor",
@@ -34842,7 +36132,7 @@ function skillMdSearchDirs(projectRoot = process.cwd()) {
     join23(projectRoot, ".zelari", "skills"),
     join23(projectRoot, ".claude", "skills"),
     join23(projectRoot, ".opencode", "skills"),
-    join23(homedir5(), ".zelari-code", "skills")
+    join23(homedir6(), ".zelari-code", "skills")
   ];
 }
 function parseSkillMd(content, sourcePath) {
@@ -34900,7 +36190,7 @@ function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
   const summary = { loaded: [], skipped: [] };
   const seen = new Set(options.existingIds ?? []);
   for (const dir of skillMdSearchDirs(projectRoot)) {
-    if (!existsSync27(dir)) continue;
+    if (!existsSync28(dir)) continue;
     let entries;
     try {
       entries = readdirSync4(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -34909,9 +36199,9 @@ function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
     }
     for (const entry of entries) {
       const skillPath = join23(dir, entry, "SKILL.md");
-      if (!existsSync27(skillPath)) continue;
+      if (!existsSync28(skillPath)) continue;
       try {
-        const parsed = parseSkillMd(readFileSync22(skillPath, "utf8"), skillPath);
+        const parsed = parseSkillMd(readFileSync24(skillPath, "utf8"), skillPath);
         if (!parsed) {
           summary.skipped.push({ path: skillPath, reason: "missing/invalid frontmatter (name, description) or empty body" });
           continue;