zelari-code 1.20.0 → 1.22.0

package/dist/cli/main.bundled.js

@@ -19175,6 +19175,55 @@ var init_paths = __esm({
   }
 });
 
+// src/cli/sessionTodos.ts
+function listSessionTodos() {
+  return todos.map((t) => ({ ...t }));
+}
+function clearSessionTodos() {
+  todos = [];
+}
+function writeSessionTodos(items, opts) {
+  const merge2 = opts?.merge === true;
+  const normalized = items.map((it, i) => ({
+    id: (it.id?.trim() || `t${i + 1}`).slice(0, 64),
+    content: it.content.trim().slice(0, 500),
+    status: it.status ?? "pending"
+  })).filter((t) => t.content.length > 0);
+  if (!merge2) {
+    todos = normalized.slice(0, 40);
+    return listSessionTodos();
+  }
+  const byId = new Map(todos.map((t) => [t.id, t]));
+  for (const t of normalized) {
+    byId.set(t.id, t);
+  }
+  todos = [...byId.values()].slice(0, 40);
+  return listSessionTodos();
+}
+function formatTodosForModel(list = todos) {
+  if (list.length === 0) return "(no todos)";
+  return list.map((t) => {
+    const mark = t.status === "completed" ? "x" : t.status === "in_progress" ? ">" : t.status === "cancelled" ? "-" : " ";
+    return `- [${mark}] ${t.id}: ${t.content} (${t.status})`;
+  }).join("\n");
+}
+function formatTodoStatusSummary(list = todos) {
+  if (list.length === 0) return null;
+  const done = list.filter(
+    (t) => t.status === "completed" || t.status === "cancelled"
+  ).length;
+  const active = list.filter((t) => t.status === "in_progress").length;
+  const base = `todos ${done}/${list.length}`;
+  return active > 0 ? `${base} \xB7 ${active} active` : base;
+}
+var todos;
+var init_sessionTodos = __esm({
+  "src/cli/sessionTodos.ts"() {
+    "use strict";
+    todos = [];
+  }
+});
+
 // packages/core/dist/shared/events.js
 function createBrainEvent(type, sessionId, data) {
   return {
@@ -19577,7 +19626,7 @@ function extractToolObjects(text) {
   }
   return out;
 }
-var AgentHarness;
+var AgentHarness, DOOM_LOOP_THRESHOLD;
 var init_AgentHarness = __esm({
   "packages/core/dist/core/AgentHarness.js"() {
     "use strict";
@@ -19603,6 +19652,12 @@ var init_AgentHarness = __esm({
        * real progress. Reset on every `run()` so it does not leak across turns.
        */
       toolCallCache = /* @__PURE__ */ new Map();
+      /**
+       * Count of identical tool+args invocations this run (incl. first).
+       * v1.21.0 doom_loop: after DOOM_LOOP_THRESHOLD, return a hard error so the
+       * model must change approach instead of soft-replaying forever.
+       */
+      toolCallCounts = /* @__PURE__ */ new Map();
       /**
        * How many times this run re-entered the provider because the model emitted
        * tool calls as a `---TOOLS---` text block (fallback format) instead of native
@@ -19690,21 +19745,30 @@ var init_AgentHarness = __esm({
         const maxParallel = Math.max(1, Number.parseInt(process.env.ZELARI_MAX_PARALLEL_TOOLS ?? "6", 10) || 6);
         const inflight = /* @__PURE__ */ new Map();
         const invokeOne = async (p3) => {
-          if (p3.cached !== void 0) {
+          if (p3.skipped || !this.config.toolRegistry) {
             return {
-              content: p3.cached,
-              isError: p3.skipped || p3.cached.startsWith("[skipped]"),
+              content: `[skipped] maxToolCallsPerTurn reached (limit=${maxToolCalls})`,
+              isError: true,
               durationMs: 0
             };
           }
-          if (p3.skipped || !this.config.toolRegistry) {
+          const callKey = hashToolCall(p3.toolName, p3.args);
+          const nextCount = (this.toolCallCounts.get(callKey) ?? 0) + 1;
+          this.toolCallCounts.set(callKey, nextCount);
+          if (nextCount >= DOOM_LOOP_THRESHOLD) {
             return {
-              content: `[skipped] maxToolCallsPerTurn reached (limit=${maxToolCalls})`,
+              content: `[doom_loop] Tool "${p3.toolName}" called ${nextCount} times with identical arguments. Stop repeating. Change approach: different path/args, another tool, or answer with what you already have.`,
               isError: true,
               durationMs: 0
             };
           }
-          const callKey = hashToolCall(p3.toolName, p3.args);
+          if (p3.cached !== void 0) {
+            return {
+              content: p3.cached,
+              isError: p3.cached.startsWith("[skipped]") || p3.cached.startsWith("[doom_loop]"),
+              durationMs: 0
+            };
+          }
           const fromRunCache = this.toolCallCache.get(callKey);
           if (fromRunCache !== void 0) {
             return {
@@ -19857,6 +19921,7 @@ ${shared2.content}`,
         const startTime = Date.now();
         this.activeController = new AbortController();
         this.toolCallCache = /* @__PURE__ */ new Map();
+        this.toolCallCounts = /* @__PURE__ */ new Map();
         this.textToolReentries = 0;
         const startEvent = createBrainEvent("agent_start", this.sessionId, {
           model: this.config.model,
@@ -20343,6 +20408,7 @@ ${cached2}`
         yield msgEnd;
       }
     };
+    DOOM_LOOP_THRESHOLD = 3;
   }
 });
 
@@ -20492,6 +20558,7 @@ var init_sessionJsonl = __esm({
 var harness_exports = {};
 __export(harness_exports, {
   AgentHarness: () => AgentHarness,
+  DOOM_LOOP_THRESHOLD: () => DOOM_LOOP_THRESHOLD,
   SessionJsonlWriter: () => SessionJsonlWriter,
   collapseLoopedAssistantText: () => collapseLoopedAssistantText,
   detectAssistantTextLoop: () => detectAssistantTextLoop,
@@ -20879,27 +20946,112 @@ var init_openai_compatible = __esm({
   }
 });
 
+// packages/core/dist/core/tools/toolOutputSpill.js
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir3, tmpdir } from "node:os";
+import { join } from "node:path";
+function resolveToolOutputDir() {
+  const fromEnv = process.env.ZELARI_TOOL_OUTPUT_DIR?.trim();
+  if (fromEnv)
+    return fromEnv;
+  try {
+    return join(homedir3(), ".tmp", "zelari-code", "tool-output");
+  } catch {
+    return join(tmpdir(), "zelari-code", "tool-output");
+  }
+}
+function isToolSpillEnabled() {
+  const v = process.env.ZELARI_TOOL_SPILL?.trim().toLowerCase();
+  if (v === "0" || v === "false" || v === "off" || v === "no")
+    return false;
+  return true;
+}
+function spillToolOutput(fullText, meta3) {
+  if (!isToolSpillEnabled())
+    return null;
+  if (!fullText)
+    return null;
+  try {
+    const dir = resolveToolOutputDir();
+    if (!existsSync7(dir)) {
+      mkdirSync6(dir, { recursive: true });
+    }
+    const hash3 = createHash("sha256").update(fullText).digest("hex").slice(0, 12);
+    const stamp = Date.now().toString(36);
+    const rnd = randomBytes(3).toString("hex");
+    const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
+    const file2 = `${stamp}-${safeTool}-${hash3}-${rnd}.txt`;
+    const path38 = join(dir, file2);
+    writeFileSync5(path38, fullText, "utf8");
+    return path38;
+  } catch {
+    return null;
+  }
+}
+var init_toolOutputSpill = __esm({
+  "packages/core/dist/core/tools/toolOutputSpill.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/core/tools/registry.js
-function truncateToolResult(text, cap2 = TOOL_RESULT_LINE_CAP) {
+function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
   if (text.length === 0)
     return text;
+  const opts = typeof capOrOpts === "number" ? { cap: capOrOpts } : capOrOpts ?? {};
+  const cap2 = typeof opts.cap === "number" && Number.isFinite(opts.cap) && opts.cap >= 10 ? opts.cap : TOOL_RESULT_LINE_CAP;
+  const doSpill = opts.spill !== false;
   const lines = text.split("\n");
-  if (lines.length <= cap2)
+  const charBudget = cap2 * 80;
+  const overLines = lines.length > cap2;
+  const overChars = text.length > charBudget && lines.length <= cap2;
+  if (!overLines && !overChars)
     return text;
-  const half = Math.floor(cap2 / 2);
-  const head = lines.slice(0, half);
-  const tail = lines.slice(lines.length - half);
-  const omitted = lines.length - cap2;
-  return head.join("\n") + `
-\u2026 [+${omitted} lines omitted \u2014 showing head:${half}, tail:${half} of ${lines.length} total] \u2026
+  let preview;
+  let marker;
+  if (overLines) {
+    const half = Math.floor(cap2 / 2);
+    const head = lines.slice(0, half);
+    const tail = lines.slice(lines.length - half);
+    const omitted = lines.length - cap2;
+    marker = `+${omitted} lines omitted \u2014 showing head:${half}, tail:${half} of ${lines.length} total`;
+    preview = head.join("\n") + `
+\u2026 [${marker}] \u2026
 ` + tail.join("\n");
+  } else {
+    const half = Math.floor(charBudget / 2);
+    const head = text.slice(0, half);
+    const tail = text.slice(text.length - half);
+    const omitted = text.length - charBudget;
+    marker = `+${omitted} chars omitted \u2014 showing head/tail of ${text.length} total (line-sparse payload)`;
+    preview = `${head}
+\u2026 [${marker}] \u2026
+${tail}`;
+  }
+  if (doSpill) {
+    const path38 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path38) {
+      const spillNote = `
+\u2026 [full output spilled to: ${path38} \u2014 re-read with read_file if you need the complete text] \u2026`;
+      if (preview.includes("] \u2026\n")) {
+        preview = preview.replace("] \u2026\n", `] \u2026${spillNote}
+`);
+      } else {
+        preview = preview + spillNote;
+      }
+    }
+  }
+  return preview;
 }
 var TOOL_NAME_ALIASES, TOOL_RESULT_LINE_CAP, ToolRegistry;
 var init_registry = __esm({
   "packages/core/dist/core/tools/registry.js"() {
     "use strict";
     init_zodBridge();
+    init_toolOutputSpill();
     init_toolTypes();
+    init_toolOutputSpill();
     TOOL_NAME_ALIASES = {
       read: "read_file",
       readfile: "read_file",
@@ -20981,13 +21133,19 @@ var init_registry = __esm({
             })
           ]);
           if (result.ok) {
+            const tName = options.toolName ?? name;
             if (typeof result.value === "string") {
-              return { ok: true, value: truncateToolResult(result.value) };
+              return {
+                ok: true,
+                value: truncateToolResult(result.value, {
+                  toolName: tName
+                })
+              };
             }
             if (result.value && typeof result.value === "object") {
               const v = result.value;
               if (typeof v.content === "string") {
-                v.content = truncateToolResult(v.content);
+                v.content = truncateToolResult(v.content, { toolName: tName });
               }
             }
           }
@@ -21213,7 +21371,7 @@ var init_cmdline = __esm({
 
 // src/cli/diagnostics/engine.ts
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import path16 from "node:path";
 function parseEslintJson(stdout, _file2) {
   const json2 = safeJson(stdout);
@@ -21282,7 +21440,7 @@ function resolveBin(bin, cwd) {
   for (let i = 0; i < 6; i += 1) {
     for (const suffix of suffixes) {
       const candidate = path16.join(dir, "node_modules", ".bin", `${bin}${suffix}`);
-      if (existsSync7(candidate)) return candidate;
+      if (existsSync8(candidate)) return candidate;
     }
     const parent = path16.dirname(dir);
     if (parent === dir) break;
@@ -21388,6 +21546,26 @@ var init_engine = __esm({
 });
 
 // src/cli/tools/taskTool.ts
+function systemPromptForAgent(agent) {
+  if (agent === "general") return GENERAL_PROMPT;
+  if (agent === "verify") return VERIFY_PROMPT;
+  return EXPLORE_PROMPT;
+}
+function maxToolCallsForThoroughness(thoroughness, agent) {
+  if (agent === "general") {
+    if (thoroughness === "quick") return 8;
+    if (thoroughness === "deep") return 20;
+    return 12;
+  }
+  if (agent === "verify") {
+    if (thoroughness === "quick") return 6;
+    if (thoroughness === "deep") return 14;
+    return 10;
+  }
+  if (thoroughness === "quick") return 4;
+  if (thoroughness === "deep") return 12;
+  return 6;
+}
 async function runSubAgent(harness) {
   let current = "";
   let lastCompleted = "";
@@ -21417,36 +21595,40 @@ async function runSubAgent(harness) {
 function createTaskTool(deps) {
   return {
     name: "task",
-    description: 'Delegate a focused, READ-ONLY research/exploration sub-task to an isolated sub-agent that has its own fresh context and returns only a concise conclusion. Use it to keep your own context lean \u2014 e.g. "find where feature X is implemented and summarize how it works" \u2014 on large codebases. The sub-agent cannot edit files or run shell commands. Provide a fully self-contained `prompt` (it cannot see this conversation).',
-    // The sub-agent reads the workspace and may hit the network (fetch/search),
-    // but never writes or runs shell commands.
-    permissions: ["read", "network"],
-    // Sub-agents run a full (bounded) agent loop — allow generous wall time.
+    description: "Delegate a focused sub-task to an isolated sub-agent with its own context; returns only a concise conclusion (keeps parent context lean).\n- agent=explore (default): read-only research/search\n- agent=general: can edit files for one bounded unit of work\n- agent=verify: read + bash to run tests/checks\nProvide a fully self-contained `prompt` (sub-agent cannot see this conversation).",
+    permissions: ["read", "network", "write", "execute"],
     timeoutMs: 3e5,
     inputSchema: TaskArgsSchema,
     execute: async (args, ctx) => {
+      const agent = args.agent ?? "explore";
+      const thoroughness = args.thoroughness ?? "medium";
       let sub;
       try {
-        sub = await deps.createSubAgentContext();
+        sub = await deps.createSubAgentContext({ agent, thoroughness });
       } catch (err) {
-        return typedErr(`task: could not initialize sub-agent \u2014 ${err instanceof Error ? err.message : String(err)}`);
+        return typedErr(
+          `task: could not initialize sub-agent \u2014 ${err instanceof Error ? err.message : String(err)}`
+        );
       }
       if (!sub) {
-        return typedErr("task: no provider configured for the sub-agent (set an API key / run /login).");
+        return typedErr(
+          "task: no provider configured for the sub-agent (set an API key / run /login)."
+        );
       }
+      const maxToolCalls = maxToolCallsForThoroughness(thoroughness, agent);
       const config2 = {
         model: sub.model,
         provider: sub.provider,
         messages: [
-          { role: "system", content: SUBAGENT_SYSTEM_PROMPT },
+          { role: "system", content: systemPromptForAgent(agent) },
           { role: "user", content: args.prompt }
         ],
         tools: sub.tools,
         toolRegistry: sub.registry,
         providerStream: sub.providerStream,
         cwd: ctx.cwd,
-        // Guard against a single turn ballooning context on "explore" tasks.
-        maxToolCallsPerTurn: 5
+        maxToolCallsPerTurn: maxToolCalls,
+        maxToolLoopIterations: Math.max(12, maxToolCalls + 4)
       };
       let harness;
       try {
@@ -21457,40 +21639,58 @@ function createTaskTool(deps) {
           harness = new AgentHarness2(config2);
         }
       } catch (err) {
-        return typedErr(`task: failed to start sub-agent \u2014 ${err instanceof Error ? err.message : String(err)}`);
+        return typedErr(
+          `task: failed to start sub-agent \u2014 ${err instanceof Error ? err.message : String(err)}`
+        );
       }
       const { result, error: error51 } = await runSubAgent(harness);
       if (!result) {
-        return typedErr(`task: sub-agent produced no output${error51 ? ` (${error51})` : ""}.`);
+        return typedErr(
+          `task: sub-agent (${agent}) produced no output${error51 ? ` (${error51})` : ""}.`
+        );
       }
-      return typedOk({ result });
+      return typedOk({
+        result: `[sub-agent:${agent}/${thoroughness}]
+${result}`,
+        agent
+      });
     }
   };
 }
-var SUBAGENT_SYSTEM_PROMPT, TaskArgsSchema;
+var EXPLORE_PROMPT, GENERAL_PROMPT, VERIFY_PROMPT, TaskArgsSchema;
 var init_taskTool = __esm({
   "src/cli/tools/taskTool.ts"() {
     "use strict";
     init_zod();
     init_toolTypes();
-    SUBAGENT_SYSTEM_PROMPT = [
-      "You are a focused sub-agent spawned to answer ONE bounded question or",
-      "complete ONE small research task for a parent coding agent.",
-      "",
-      "You have READ-ONLY tools (read files, list files, search, fetch URLs).",
-      "You cannot edit files or run shell commands \u2014 do not attempt to.",
-      "",
-      "Work efficiently: gather only what you need, then STOP and reply with a",
-      "concise, self-contained conclusion the parent can act on. Include concrete",
-      "references (file paths, line numbers, symbol names) but do not paste large",
-      "file dumps. Do not ask the parent follow-up questions \u2014 deliver your best",
-      "answer with what you can find."
+    EXPLORE_PROMPT = [
+      "You are a focused EXPLORE sub-agent for a parent coding agent.",
+      "READ-ONLY tools only (read, list, grep, fetch). No edits, no shell.",
+      "Gather only what you need, then STOP with a concise conclusion:",
+      "file paths, symbols, line refs, and how things connect. No large dumps.",
+      "Do not ask follow-up questions."
+    ].join("\n");
+    GENERAL_PROMPT = [
+      "You are a GENERAL sub-agent that can read AND modify the codebase for one",
+      "bounded unit of work. Prefer small, correct edits. Run checks when needed.",
+      "Return a short report: what changed, files touched, remaining risks.",
+      "Do not spawn further sub-agents. Do not expand scope beyond the prompt."
+    ].join("\n");
+    VERIFY_PROMPT = [
+      "You are a VERIFY sub-agent. Confirm whether work is correct on disk.",
+      "You may read files and run test/build commands via bash. Prefer",
+      "targeted checks over full suite when possible.",
+      "Report: pass/fail, commands run, key output, and gaps."
     ].join("\n");
     TaskArgsSchema = external_exports.object({
       description: external_exports.string().min(1).describe("A 3-6 word label for the sub-task (for logs/UI)."),
       prompt: external_exports.string().min(1).describe(
         "The full, self-contained instruction for the sub-agent. It has no access to this conversation, so include all context it needs."
-      )
+      ),
+      agent: external_exports.enum(["explore", "general", "verify"]).optional().describe(
+        "Sub-agent type: explore (read-only research, default), general (can edit), verify (read + bash tests). Prefer explore for search; general for isolated edits."
+      ),
+      thoroughness: external_exports.enum(["quick", "medium", "deep"]).optional().describe("How deep the sub-agent should go (tool budget). Default medium.")
     });
   }
 });
@@ -21554,6 +21754,253 @@ var init_askUser = __esm({
   }
 });
 
+// src/cli/skillsMd.ts
+import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync5 } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+function skillMdSearchDirs(projectRoot = process.cwd()) {
+  return [
+    join2(projectRoot, ".zelari", "skills"),
+    join2(projectRoot, ".claude", "skills"),
+    join2(projectRoot, ".opencode", "skills"),
+    join2(homedir4(), ".zelari-code", "skills")
+  ];
+}
+function parseSkillMd(content, sourcePath) {
+  const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(content);
+  if (!fmMatch) return null;
+  const [, fmRaw = "", body = ""] = fmMatch;
+  const fields = {};
+  for (const line of fmRaw.split(/\r?\n/)) {
+    const kv = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(line);
+    if (!kv) continue;
+    const key = (kv[1] ?? "").toLowerCase();
+    let value = (kv[2] ?? "").trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    fields[key] = value;
+  }
+  const name = (fields["name"] ?? "").trim().toLowerCase();
+  const description = (fields["description"] ?? "").trim();
+  if (!name || !description) return null;
+  if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) return null;
+  const rawTools = fields["tools"] ?? fields["requiredtools"] ?? fields["required_tools"] ?? "";
+  const requiredTools = rawTools.replace(/^\[|\]$/g, "").split(",").map((t) => t.trim().replace(/^["']|["']$/g, "")).filter((t) => t.length > 0);
+  const rawCategory = (fields["category"] ?? "").trim().toLowerCase();
+  const category = CODING_CATEGORIES.has(rawCategory) ? rawCategory : "maint";
+  const rawCost = (fields["cost"] ?? fields["estimatedcost"] ?? "").trim().toLowerCase();
+  const estimatedCost = rawCost === "low" || rawCost === "high" ? rawCost : "medium";
+  const trimmedBody = body.trim();
+  if (!trimmedBody) return null;
+  return { name, description, category, requiredTools, estimatedCost, body: trimmedBody, sourcePath };
+}
+function toCodingSkillDefinition(parsed) {
+  return {
+    id: parsed.name,
+    name: parsed.name,
+    description: parsed.description,
+    version: "1.0.0",
+    category: parsed.category,
+    systemPromptFragment: parsed.body,
+    requiredTools: parsed.requiredTools,
+    enabledByDefault: true,
+    builtin: false,
+    requires: [],
+    examples: [],
+    triggers: [],
+    antiPatterns: [],
+    requiredRoles: [],
+    estimatedCost: parsed.estimatedCost,
+    outputSchema: "string",
+    relatedSkills: [],
+    tags: ["user", "skill-md"]
+  };
+}
+function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
+  const summary = { loaded: [], skipped: [] };
+  const seen = new Set(options.existingIds ?? []);
+  for (const dir of skillMdSearchDirs(projectRoot)) {
+    if (!existsSync9(dir)) continue;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const skillPath = join2(dir, entry, "SKILL.md");
+      if (!existsSync9(skillPath)) continue;
+      try {
+        const parsed = parseSkillMd(readFileSync5(skillPath, "utf8"), skillPath);
+        if (!parsed) {
+          summary.skipped.push({ path: skillPath, reason: "missing/invalid frontmatter (name, description) or empty body" });
+          continue;
+        }
+        if (seen.has(parsed.name)) {
+          summary.skipped.push({ path: skillPath, reason: `name "${parsed.name}" already registered (earlier dir or builtin wins)` });
+          continue;
+        }
+        registerCodingSkill(toCodingSkillDefinition(parsed));
+        seen.add(parsed.name);
+        summary.loaded.push(parsed.name);
+      } catch (err) {
+        summary.skipped.push({ path: skillPath, reason: err instanceof Error ? err.message : String(err) });
+      }
+    }
+  }
+  return summary;
+}
+var CODING_CATEGORIES;
+var init_skillsMd = __esm({
+  "src/cli/skillsMd.ts"() {
+    "use strict";
+    init_skills2();
+    CODING_CATEGORIES = /* @__PURE__ */ new Set([
+      "plan",
+      "refactor",
+      "debug",
+      "review",
+      "test",
+      "docs",
+      "ops",
+      "git",
+      "db",
+      "maint"
+    ]);
+  }
+});
+
+// src/cli/tools/skillTool.ts
+function formatAvailableSkillsCatalog(cwd = process.cwd()) {
+  try {
+    loadSkillMdSkills(cwd);
+  } catch {
+  }
+  const skills = listCodingSkills();
+  if (skills.length === 0) {
+    return "No skills registered.";
+  }
+  const lines = skills.slice(0, 80).map((s) => {
+    const desc = (s.description || s.id).replace(/\s+/g, " ").trim().slice(0, 160);
+    return `- ${s.id}: ${desc}`;
+  });
+  return lines.join("\n");
+}
+function createSkillTool(opts) {
+  const cwd = opts?.cwd ?? process.cwd();
+  const catalog = formatAvailableSkillsCatalog(cwd);
+  return {
+    name: "skill",
+    description: "Load the full instructions for a named coding skill into this turn. Call when a skill matches the current task. Available skills:\n" + catalog,
+    permissions: ["read"],
+    timeoutMs: 1e4,
+    inputSchema: SkillArgsSchema,
+    execute: async (args) => {
+      try {
+        loadSkillMdSkills(cwd);
+      } catch {
+      }
+      const id = args.name.trim();
+      const skill = getCodingSkillById(id) ?? listCodingSkills().find(
+        (s) => s.id.toLowerCase() === id.toLowerCase() || s.name?.toLowerCase() === id.toLowerCase()
+      );
+      if (!skill) {
+        const known = listCodingSkills().map((s) => s.id).slice(0, 40).join(", ");
+        return typedErr(
+          `Unknown skill "${id}". Known: ${known || "(none)"}. Use /skill or pick from the list.`
+        );
+      }
+      const body = skill.systemPromptFragment?.trim() || skill.description || `(skill ${skill.id} has no body)`;
+      const header = `# Skill: ${skill.id}
+${skill.description ? `> ${skill.description}
+
+` : ""}`;
+      return typedOk({
+        name: skill.id,
+        content: header + body
+      });
+    }
+  };
+}
+var SkillArgsSchema;
+var init_skillTool = __esm({
+  "src/cli/tools/skillTool.ts"() {
+    "use strict";
+    init_zod();
+    init_skills2();
+    init_toolTypes();
+    init_skillsMd();
+    SkillArgsSchema = external_exports.object({
+      name: external_exports.string().min(1).describe("Skill id/name to load (from the available skills list).")
+    });
+  }
+});
+
+// src/cli/tools/todoTools.ts
+function createTodoWriteTool() {
+  return {
+    name: "todo_write",
+    description: "Create or update the session todo list for this multi-step task. Use to track progress (pending \u2192 in_progress \u2192 completed). Prefer small, concrete items. Call todo_read to inspect current list. Not for durable product plans (.zelari/plan.json).",
+    permissions: ["read"],
+    timeoutMs: 5e3,
+    inputSchema: WriteSchema,
+    execute: async (input) => {
+      const list = writeSessionTodos(
+        input.todos.map((t) => ({
+          id: t.id,
+          content: t.content,
+          status: t.status ?? "pending"
+        })),
+        { merge: input.merge === true }
+      );
+      return typedOk({
+        todos: list,
+        formatted: formatTodosForModel(list)
+      });
+    }
+  };
+}
+function createTodoReadTool() {
+  return {
+    name: "todo_read",
+    description: "Read the current session todo list. Use after todo_write or to recall open work mid-task.",
+    permissions: ["read"],
+    timeoutMs: 5e3,
+    inputSchema: ReadSchema,
+    execute: async () => {
+      const list = listSessionTodos();
+      return typedOk({
+        todos: list,
+        formatted: formatTodosForModel(list)
+      });
+    }
+  };
+}
+var StatusSchema, TodoItemSchema, WriteSchema, ReadSchema;
+var init_todoTools = __esm({
+  "src/cli/tools/todoTools.ts"() {
+    "use strict";
+    init_zod();
+    init_toolTypes();
+    init_sessionTodos();
+    StatusSchema = external_exports.enum(["pending", "in_progress", "completed", "cancelled"]);
+    TodoItemSchema = external_exports.object({
+      id: external_exports.string().min(1).max(64).optional().describe("Stable id; auto-generated if omitted"),
+      content: external_exports.string().min(1).max(500).describe("Short task description"),
+      status: StatusSchema.optional().describe("Default pending")
+    });
+    WriteSchema = external_exports.object({
+      todos: external_exports.array(TodoItemSchema).min(1).max(40).describe("Todo items to set (replace list unless merge=true)"),
+      merge: external_exports.boolean().optional().describe("If true, upsert by id and keep unlisted items. Default false = replace.")
+    });
+    ReadSchema = external_exports.object({
+      // empty object so models can call with {}
+      _unused: external_exports.string().optional()
+    });
+  }
+});
+
 // src/cli/lsp/protocol.ts
 function encodeMessage(message) {
   const json2 = JSON.stringify(message);
@@ -21857,7 +22304,7 @@ var init_servers = __esm({
 
 // src/cli/lsp/manager.ts
 import { spawn as spawn3 } from "node:child_process";
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 function processTransport(child) {
   return {
     send: (data) => {
@@ -22060,7 +22507,7 @@ var init_manager = __esm({
         const uri = pathToUri(file2);
         let text;
         try {
-          text = readFileSync5(file2, "utf8");
+          text = readFileSync6(file2, "utf8");
         } catch {
           text = "";
         }
@@ -22382,13 +22829,13 @@ var init_store = __esm({
 });
 
 // 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 { promises as fs12, existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
 import path19 from "node:path";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 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`);
+  const hash3 = createHash2("sha1").update(path19.resolve(root)).digest("hex").slice(0, 16);
+  return process.env.ZELARI_SEMANTIC_FILE ?? path19.join(homedir5(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
   const out = [];
@@ -22466,9 +22913,9 @@ async function saveIndex(root, data) {
 }
 function loadIndex(root) {
   const file2 = getIndexPath(root);
-  if (!existsSync8(file2)) return null;
+  if (!existsSync10(file2)) return null;
   try {
-    const parsed = JSON.parse(readFileSync6(file2, "utf8"));
+    const parsed = JSON.parse(readFileSync7(file2, "utf8"));
     if (parsed && Array.isArray(parsed.chunks)) return parsed;
   } catch {
   }
@@ -22998,19 +23445,19 @@ __export(targets_exports, {
 });
 import {
   chmodSync,
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync5
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname2, join } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 import { spawn as spawn4 } from "node:child_process";
 function getSshTargetsPath() {
-  return join(homedir4(), ".zelari-code", "ssh-targets.json");
+  return join3(homedir6(), ".zelari-code", "ssh-targets.json");
 }
 function getSshSecretsPath() {
-  return join(homedir4(), ".zelari-code", "ssh-secrets.json");
+  return join3(homedir6(), ".zelari-code", "ssh-secrets.json");
 }
 function normalizeAuth(auth) {
   if (auth === "keyPath") return "keyPath";
@@ -23019,17 +23466,17 @@ function normalizeAuth(auth) {
 }
 function readSecrets() {
   const path38 = getSshSecretsPath();
-  if (!existsSync9(path38)) return {};
+  if (!existsSync11(path38)) return {};
   try {
-    return JSON.parse(readFileSync7(path38, "utf8"));
+    return JSON.parse(readFileSync8(path38, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
   const path38 = getSshSecretsPath();
-  mkdirSync6(dirname2(path38), { recursive: true });
-  writeFileSync5(path38, `${JSON.stringify(data, null, 2)}
+  mkdirSync7(dirname2(path38), { recursive: true });
+  writeFileSync6(path38, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
     chmodSync(path38, 384);
@@ -23062,9 +23509,9 @@ function deleteSshPassword(id) {
 }
 function readStore2() {
   const path38 = getSshTargetsPath();
-  if (!existsSync9(path38)) return [];
+  if (!existsSync11(path38)) return [];
   try {
-    const parsed = JSON.parse(readFileSync7(path38, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path38, "utf8"));
     const list = Array.isArray(parsed.targets) ? parsed.targets : [];
     return list.filter(
       (t) => t && typeof t.id === "string" && typeof t.host === "string" && typeof t.user === "string"
@@ -23080,9 +23527,9 @@ function readStore2() {
 }
 function writeStore2(targets) {
   const path38 = getSshTargetsPath();
-  mkdirSync6(dirname2(path38), { recursive: true });
+  mkdirSync7(dirname2(path38), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
-  writeFileSync5(
+  writeFileSync6(
     path38,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
@@ -23183,17 +23630,17 @@ function buildSshBaseArgs(target) {
   return args;
 }
 function ensureAskpassHelper() {
-  const dir = join(homedir4(), ".zelari-code", "ssh-helpers");
-  mkdirSync6(dir, { recursive: true });
-  const cjs = join(dir, "askpass.cjs");
-  writeFileSync5(
+  const dir = join3(homedir6(), ".zelari-code", "ssh-helpers");
+  mkdirSync7(dir, { recursive: true });
+  const cjs = join3(dir, "askpass.cjs");
+  writeFileSync6(
     cjs,
     "process.stdout.write(process.env.ZELARI_SSH_ASKPASS_PASS || '');\n",
     "utf8"
   );
   if (process.platform === "win32") {
-    const cmd = join(dir, "askpass.cmd");
-    writeFileSync5(
+    const cmd = join3(dir, "askpass.cmd");
+    writeFileSync6(
       cmd,
       `@echo off\r
 node "%~dp0askpass.cjs"\r
@@ -23202,8 +23649,8 @@ node "%~dp0askpass.cjs"\r
     );
     return cmd;
   }
-  const sh = join(dir, "askpass.sh");
-  writeFileSync5(
+  const sh = join3(dir, "askpass.sh");
+  writeFileSync6(
     sh,
     `#!/bin/sh
 exec node "$(dirname "$0")/askpass.cjs"
@@ -23276,9 +23723,9 @@ function readSshPublicKey(keyOrPubPath) {
   if (!raw) return { ok: false, error: "Empty path" };
   const candidates = raw.endsWith(".pub") ? [raw] : [`${raw}.pub`, raw];
   for (const p3 of candidates) {
-    if (!existsSync9(p3)) continue;
+    if (!existsSync11(p3)) continue;
     try {
-      const content = readFileSync7(p3, "utf8").trim();
+      const content = readFileSync8(p3, "utf8").trim();
       if (!content) continue;
       if (/BEGIN .*PRIVATE KEY/i.test(content)) {
         return {
@@ -23756,6 +24203,87 @@ ${args.content}
   }
 });
 
+// src/cli/safety/toolPermissions.ts
+function grantSessionTool(toolName) {
+  const n = toolName.trim();
+  if (n) sessionToolGrants.add(n);
+}
+function grantSessionCategory(cat) {
+  sessionCategoryGrants.add(cat);
+}
+function clearSessionPermissionGrants() {
+  sessionToolGrants.clear();
+  sessionCategoryGrants.clear();
+}
+function isSessionGranted(toolName, required2) {
+  if (sessionToolGrants.has(toolName)) return true;
+  if (!required2.length) return false;
+  return required2.every((c) => sessionCategoryGrants.has(c));
+}
+function parseAction(raw, fallback) {
+  const v = raw?.trim().toLowerCase();
+  if (v === "allow" || v === "ask" || v === "deny") return v;
+  return fallback;
+}
+function isAutoPermissions() {
+  const v = process.env.ZELARI_AUTO?.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function defaultPermissionPolicy(overrides) {
+  return {
+    read: parseAction(process.env.ZELARI_PERMISSION_READ, "allow"),
+    write: parseAction(process.env.ZELARI_PERMISSION_WRITE, "allow"),
+    execute: parseAction(process.env.ZELARI_PERMISSION_EXECUTE, "allow"),
+    network: parseAction(process.env.ZELARI_PERMISSION_NETWORK, "allow"),
+    ui: "allow",
+    auto: isAutoPermissions(),
+    ...overrides
+  };
+}
+function resolveToolPermission(toolName, required2, policy) {
+  if (!required2.length) {
+    return { action: "allow", reason: "", categories: [] };
+  }
+  let worst = "allow";
+  const hit = [];
+  for (const cat of required2) {
+    const a = cat === "read" ? policy.read : cat === "write" ? policy.write : cat === "execute" ? policy.execute : cat === "network" ? policy.network : cat === "ui" ? policy.ui : "allow";
+    if (a === "deny") {
+      worst = "deny";
+      hit.push(cat);
+    } else if (a === "ask" && worst !== "deny") {
+      worst = "ask";
+      hit.push(cat);
+    }
+  }
+  if (worst === "allow") {
+    return { action: "allow", reason: "", categories: [] };
+  }
+  if (worst === "deny") {
+    return {
+      action: "deny",
+      reason: `Permission denied for tool "${toolName}" (${hit.join(", ")}). Policy forbids this action.`,
+      categories: hit
+    };
+  }
+  if (policy.auto || isSessionGranted(toolName, hit.length ? hit : required2)) {
+    return { action: "allow", reason: "", categories: [] };
+  }
+  return {
+    action: "ask",
+    reason: `Tool "${toolName}" requires approval (${hit.join(", ")}).`,
+    categories: hit
+  };
+}
+var sessionToolGrants, sessionCategoryGrants;
+var init_toolPermissions = __esm({
+  "src/cli/safety/toolPermissions.ts"() {
+    "use strict";
+    sessionToolGrants = /* @__PURE__ */ new Set();
+    sessionCategoryGrants = /* @__PURE__ */ new Set();
+  }
+});
+
 // src/cli/toolRegistry.ts
 var toolRegistry_exports = {};
 __export(toolRegistry_exports, {
@@ -23780,35 +24308,54 @@ function createBuiltinToolRegistry(options = {}) {
   const safeFetchUrl = wrapWithAudit(fetchUrlTool, audit, sessionId);
   const safeWebSearch = wrapWithAudit(webSearchTool, audit, sessionId);
   const registry3 = new ToolRegistry();
-  const readOnly = options.readOnly === true || options.planMode === true;
-  registry3.register(safeReadFile);
-  registry3.register(safeGrepContent);
-  registry3.register(safeListFiles);
-  registry3.register(safeShowDiff);
-  registry3.register(safeFetchUrl);
-  registry3.register(safeWebSearch);
-  if (!readOnly) {
-    registry3.register(safeWriteFile);
-    registry3.register(safeEditFile);
-    registry3.register(safeBash);
-    registry3.register(safeApplyDiff);
-  }
-  const askUserTool = options.readOnly === true ? null : createAskUserTool(options.onAskUser);
+  const profile = options.profile ?? "full";
+  const readOnly = options.readOnly === true || options.planMode === true || profile === "explore";
+  const verifyMode = profile === "verify";
+  const allowMutators = !readOnly && !verifyMode;
+  const allowBash = allowMutators || verifyMode;
+  const permPolicy = options.permissionPolicy ?? defaultPermissionPolicy();
+  const withPerm = (t) => wrapWithPermissions(t, permPolicy, options.onPermissionAsk);
+  registry3.register(withPerm(safeReadFile));
+  registry3.register(withPerm(safeGrepContent));
+  registry3.register(withPerm(safeListFiles));
+  registry3.register(withPerm(safeShowDiff));
+  registry3.register(withPerm(safeFetchUrl));
+  registry3.register(withPerm(safeWebSearch));
+  if (allowMutators) {
+    registry3.register(withPerm(safeWriteFile));
+    registry3.register(withPerm(safeEditFile));
+    registry3.register(withPerm(safeApplyDiff));
+  }
+  if (allowBash) {
+    registry3.register(withPerm(safeBash));
+  }
+  const askUserTool = options.readOnly === true || profile === "explore" || profile === "verify" ? null : createAskUserTool(options.onAskUser);
   if (askUserTool) {
-    registry3.register(askUserTool);
-  }
-  const summary = readOnly ? [safeReadFile, safeGrepContent, safeListFiles, safeShowDiff, safeFetchUrl, safeWebSearch] : [
+    registry3.register(withPerm(askUserTool));
+  }
+  const enableSkill = options.enableSkill !== false && options.readOnly !== true && profile !== "explore" && profile !== "verify";
+  const skillTool = enableSkill ? withPerm(createSkillTool({ cwd: root })) : null;
+  if (skillTool) {
+    registry3.register(skillTool);
+  }
+  const enableTodos = options.enableTodos !== false && options.readOnly !== true && profile === "full";
+  const todoWrite = enableTodos ? withPerm(createTodoWriteTool()) : null;
+  const todoRead = enableTodos ? withPerm(createTodoReadTool()) : null;
+  if (todoWrite) registry3.register(todoWrite);
+  if (todoRead) registry3.register(todoRead);
+  const summary = [
     safeReadFile,
-    safeWriteFile,
-    safeEditFile,
-    safeBash,
     safeGrepContent,
     safeListFiles,
     safeShowDiff,
-    safeApplyDiff,
     safeFetchUrl,
     safeWebSearch,
-    ...askUserTool ? [askUserTool] : []
+    ...allowMutators ? [safeWriteFile, safeEditFile, safeApplyDiff] : [],
+    ...allowBash ? [safeBash] : [],
+    ...askUserTool ? [askUserTool] : [],
+    ...skillTool ? [skillTool] : [],
+    ...todoWrite ? [todoWrite] : [],
+    ...todoRead ? [todoRead] : []
   ];
   const tools = summary.map((t) => ({
     name: t.name,
@@ -23860,17 +24407,23 @@ function createBuiltinToolRegistry(options = {}) {
       });
     }
   }
-  if (!readOnly && options.enableTask !== false) {
+  const enableTask = options.enableTask !== false && !readOnly && !verifyMode && profile === "full" && !options.planMode;
+  if (enableTask) {
     const taskTool = createTaskTool({
-      createSubAgentContext: async () => {
+      createSubAgentContext: async ({ agent }) => {
         const cfg = await providerFromEnv();
         if (!cfg) return null;
+        const subProfile = taskAgentToProfile(agent);
         const { registry: subRegistry } = createBuiltinToolRegistry({
           root,
           audit,
           sessionId,
-          readOnly: true,
-          diagnostics: false
+          profile: subProfile,
+          enableTask: false,
+          enableSkill: agent === "general",
+          diagnostics: false,
+          lspProvider: null,
+          permissionPolicy: defaultPermissionPolicy({ auto: true })
         });
         return {
           providerStream: openaiCompatibleProvider(cfg),
@@ -23881,11 +24434,12 @@ function createBuiltinToolRegistry(options = {}) {
             name: t.function.name,
             description: t.function.description,
             parameters: t.function.parameters
-          }))
+          })),
+          agent
         };
       }
     });
-    registry3.register(taskTool);
+    registry3.register(withPerm(taskTool));
     tools.push({
       name: taskTool.name,
       description: taskTool.description,
@@ -23922,6 +24476,51 @@ function registerCliToolsIntoCouncilCatalog(registry3) {
     }
   }
 }
+function taskAgentToProfile(agent) {
+  if (agent === "general") return "general";
+  if (agent === "verify") return "verify";
+  return "explore";
+}
+function wrapWithPermissions(original, policy, onAsk) {
+  const required2 = original.permissions ?? [];
+  const decisionProbe = resolveToolPermission(original.name, required2, policy);
+  if (decisionProbe.action === "allow" && !required2.includes("write") && !required2.includes("execute")) {
+  }
+  return {
+    ...original,
+    execute: async (input, ctx) => {
+      const decision = resolveToolPermission(original.name, required2, policy);
+      if (decision.action === "deny") {
+        return typedErr(`[permission] ${decision.reason}`);
+      }
+      if (decision.action === "ask") {
+        if (!onAsk) {
+          return typedErr(
+            `[permission] ${decision.reason} No interactive approval available (set ZELARI_AUTO=1 to auto-allow, or configure onPermissionAsk).`
+          );
+        }
+        try {
+          const ok = await onAsk({
+            toolName: original.name,
+            reason: decision.reason,
+            categories: decision.categories,
+            args: input
+          });
+          if (!ok) {
+            return typedErr(
+              `[permission] User denied "${original.name}" (${decision.categories.join(", ")}).`
+            );
+          }
+        } catch (err) {
+          return typedErr(
+            `[permission] Approval UI failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      return original.execute(input, ctx);
+    }
+  };
+}
 function wrapWithSandbox(original, pathArgs, root, audit, sessionId) {
   return {
     ...original,
@@ -24094,6 +24693,8 @@ var init_toolRegistry = __esm({
     init_engine();
     init_taskTool();
     init_askUser();
+    init_skillTool();
+    init_todoTools();
     init_tools2();
     init_manager();
     init_tools3();
@@ -24102,6 +24703,8 @@ var init_toolRegistry = __esm({
     init_tools6();
     init_worldModel();
     init_openai_compatible();
+    init_toolPermissions();
+    init_toolTypes();
     init_skills2();
     HARNESS_BUILTIN_NAMES = /* @__PURE__ */ new Set([
       "read_file",
@@ -24119,7 +24722,7 @@ var init_toolRegistry = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 import { promises as fs14 } from "node:fs";
 import * as path24 from "node:path";
 function shortId() {
@@ -24171,7 +24774,7 @@ async function getStateStore(projectRoot, env = process.env) {
   }
 }
 function hashStablePrompt(stable) {
-  return createHash2("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
+  return createHash3("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
 }
 var DEFAULT_MATERIALIZE_CHARS, FileDurableStateStore, NoopDurableStateStore;
 var init_fileStateStore = __esm({
@@ -24874,8 +25477,8 @@ var init_parseCssMotion = __esm({
 });
 
 // packages/core/dist/council/verification/citeVerify.js
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
+import { join as join5 } from "node:path";
 function extractCitations(text) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -24897,8 +25500,8 @@ function verifyCitations(projectRoot, synthesisText) {
     return [];
   const results = [];
   for (const cite of extractCitations(synthesisText)) {
-    const abs = join3(projectRoot, cite.file);
-    if (!existsSync10(abs)) {
+    const abs = join5(projectRoot, cite.file);
+    if (!existsSync12(abs)) {
       results.push({
         id: "synthesis.cite-invalid",
         severity: "error",
@@ -24911,7 +25514,7 @@ function verifyCitations(projectRoot, synthesisText) {
       });
       continue;
     }
-    const lines = readFileSync8(abs, "utf8").split(/\r?\n/);
+    const lines = readFileSync9(abs, "utf8").split(/\r?\n/);
     if (cite.line > lines.length) {
       results.push({
         id: "synthesis.cite-invalid",
@@ -25174,14 +25777,14 @@ var init_synthesisAudit = __esm({
 });
 
 // packages/core/dist/council/verification/runChecks.js
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join6 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path38 = join4(zelariRoot, "nfr-spec.json");
-  if (!existsSync11(path38))
+  const path38 = join6(zelariRoot, "nfr-spec.json");
+  if (!existsSync13(path38))
     return null;
   try {
-    const raw = JSON.parse(readFileSync9(path38, "utf8"));
+    const raw = JSON.parse(readFileSync10(path38, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -25192,11 +25795,11 @@ function loadNfrSpec(zelariRoot) {
 function resolveTargets(projectRoot, spec) {
   const found = [];
   for (const rel2 of spec.targets) {
-    if (existsSync11(join4(projectRoot, rel2))) {
+    if (existsSync13(join6(projectRoot, rel2))) {
       found.push(rel2);
     }
   }
-  if (found.length === 0 && existsSync11(join4(projectRoot, "index.html"))) {
+  if (found.length === 0 && existsSync13(join6(projectRoot, "index.html"))) {
     return ["index.html"];
   }
   return found;
@@ -25251,18 +25854,18 @@ function checkDeadCssHooks(html, relFile) {
   return results;
 }
 function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
-  const planPath = join4(zelariRoot, "plan.json");
-  if (!existsSync11(planPath) || keywords.length === 0)
+  const planPath = join6(zelariRoot, "plan.json");
+  if (!existsSync13(planPath) || keywords.length === 0)
     return [];
   let plan;
   try {
-    plan = JSON.parse(readFileSync9(planPath, "utf8"));
+    plan = JSON.parse(readFileSync10(planPath, "utf8"));
   } catch {
     return [];
   }
   const milestoneText = (plan.milestones ?? []).map((m) => `${m.name ?? ""} ${m.description ?? ""}`).join(" ").toLowerCase();
   const results = [];
-  const targetContent = targets.map((t) => readFileSync9(join4(projectRoot, t), "utf8").toLowerCase()).join("\n");
+  const targetContent = targets.map((t) => readFileSync10(join6(projectRoot, t), "utf8").toLowerCase()).join("\n");
   for (const kw of keywords) {
     const low = kw.toLowerCase();
     if (!milestoneText.includes(low))
@@ -25291,14 +25894,14 @@ function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
   return results;
 }
 function checkReadmeStale(projectRoot, targets) {
-  const readmePath = join4(projectRoot, "README.md");
-  if (!existsSync11(readmePath) || targets.length === 0)
+  const readmePath = join6(projectRoot, "README.md");
+  if (!existsSync13(readmePath) || targets.length === 0)
     return [];
-  const readme = readFileSync9(readmePath, "utf8");
-  const htmlPath = join4(projectRoot, targets[0]);
-  if (!existsSync11(htmlPath))
+  const readme = readFileSync10(readmePath, "utf8");
+  const htmlPath = join6(projectRoot, targets[0]);
+  if (!existsSync13(htmlPath))
     return [];
-  const html = readFileSync9(htmlPath, "utf8");
+  const html = readFileSync10(htmlPath, "utf8");
   const sectionCount = (html.match(/<section\s+id=/gi) ?? []).length;
   const readmeSections = readme.match(/(\d+)\s+sezioni/i);
   if (readmeSections) {
@@ -25336,7 +25939,7 @@ function runImplementationVerification(input) {
     forbidLayoutProps: anim.forbidLayoutProps ?? true
   };
   for (const rel2 of targets) {
-    const html = readFileSync9(join4(input.projectRoot, rel2), "utf8");
+    const html = readFileSync10(join6(input.projectRoot, rel2), "utf8");
     for (const v of scanKeyframesViolations(html, scanOpts)) {
       results.push({
         id: "motion.keyframes",
@@ -25392,8 +25995,8 @@ function runImplementationVerification(input) {
   };
 }
 function writeVerificationReport(zelariRoot, report) {
-  const outPath = join4(zelariRoot, "verification-report.json");
-  writeFileSync6(outPath, JSON.stringify(report, null, 2), "utf8");
+  const outPath = join6(zelariRoot, "verification-report.json");
+  writeFileSync7(outPath, JSON.stringify(report, null, 2), "utf8");
   return outPath;
 }
 var DEFAULT_NFR_SPEC;
@@ -25422,8 +26025,8 @@ var init_runChecks = __esm({
 });
 
 // packages/core/dist/council/verification/microGate.js
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "node:fs";
+import { join as join7 } from "node:path";
 function checkDeadHooksInHtml(html) {
   const warnings = [];
   const scripts = [];
@@ -25451,8 +26054,8 @@ function checkDeadHooksInHtml(html) {
   return warnings;
 }
 function runMicroVerificationOnFile(projectRoot, relPath, zelariRoot) {
-  const abs = join5(projectRoot, relPath);
-  if (!existsSync12(abs) || !/\.html?$/i.test(relPath))
+  const abs = join7(projectRoot, relPath);
+  if (!existsSync14(abs) || !/\.html?$/i.test(relPath))
     return [];
   const spec = (zelariRoot ? loadNfrSpec(zelariRoot) : null) ?? DEFAULT_NFR_SPEC;
   const anim = spec.animation ?? { compositorOnly: true, forbidLayoutProps: true };
@@ -25460,7 +26063,7 @@ function runMicroVerificationOnFile(projectRoot, relPath, zelariRoot) {
     compositorOnly: anim.compositorOnly ?? true,
     forbidLayoutProps: anim.forbidLayoutProps ?? true
   };
-  const html = readFileSync10(abs, "utf8");
+  const html = readFileSync11(abs, "utf8");
   const warnings = [];
   for (const v of scanKeyframesViolations(html, scanOpts)) {
     warnings.push({
@@ -25816,8 +26419,8 @@ var init_implementationDelivery = __esm({
 });
 
 // packages/core/dist/council/verification/inlineJsAutofix.js
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join6 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join8 } from "node:path";
 function minifyInlineJs(js) {
   let out = js.replace(/\/\*[\s\S]*?\*\//g, "");
   out = out.split("\n").map((line) => line.replace(/\/\/.*$/, "").trimEnd()).filter((line) => line.trim().length > 0).join("\n");
@@ -25860,10 +26463,10 @@ function applyInlineJsAutofix(projectRoot, report) {
   const fixes = [];
   for (const r of fails) {
     const rel2 = r.file ?? "index.html";
-    const abs = join6(projectRoot, rel2);
+    const abs = join8(projectRoot, rel2);
     let html;
     try {
-      html = readFileSync11(abs, "utf8");
+      html = readFileSync12(abs, "utf8");
     } catch {
       continue;
     }
@@ -25876,7 +26479,7 @@ function applyInlineJsAutofix(projectRoot, report) {
     if (!changed || afterBytes > maxBytes)
       continue;
     const nextHtml = html.replace(SCRIPT_RE, `<script>${after}</script>`);
-    writeFileSync7(abs, nextHtml, "utf8");
+    writeFileSync8(abs, nextHtml, "utf8");
     filesChanged.push(rel2);
     fixes.push(`${rel2}: trimmed inline script ${Buffer.byteLength(before, "utf8")}\u2192${afterBytes} bytes`);
   }
@@ -25896,8 +26499,8 @@ var init_inlineJsAutofix = __esm({
 });
 
 // packages/core/dist/agents/councilApi.js
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync15 } from "node:fs";
+import { join as join9 } from "node:path";
 function extractBalancedJsonObject(s) {
   const start = s.indexOf("{");
   if (start < 0)
@@ -26524,7 +27127,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 (!existsSync13(join7(chairmanProjectRoot, rel2)))
+          if (!existsSync15(join9(chairmanProjectRoot, rel2)))
             continue;
           changedTargetFiles.add(rel2);
           for (const w of runChairmanMicroGate({ projectRoot: chairmanProjectRoot, relPath: rel2, zelariRoot })) {
@@ -26544,7 +27147,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 (!existsSync13(join7(chairmanProjectRoot, rel2)))
+          if (!existsSync15(join9(chairmanProjectRoot, rel2)))
             continue;
           changedTargetFiles.add(rel2);
           for (const w of runChairmanMicroGate({
@@ -27156,8 +27759,8 @@ function inferStack(msg) {
   return [...found];
 }
 function firstSentence(msg, max = 160) {
-  const oneLine = msg.replace(/\s+/g, " ").trim();
-  return oneLine.length <= max ? oneLine : oneLine.slice(0, max - 1).trimEnd() + "\u2026";
+  const oneLine2 = msg.replace(/\s+/g, " ").trim();
+  return oneLine2.length <= max ? oneLine2 : oneLine2.slice(0, max - 1).trimEnd() + "\u2026";
 }
 function deliverableFor(intent, msg) {
   const s = firstSentence(msg);
@@ -27262,8 +27865,8 @@ var init_types2 = __esm({
 });
 
 // packages/core/dist/council/verification/motionAutofix.js
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join8 } from "node:path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join10 } from "node:path";
 function sanitizeTransitionPart(part) {
   const tokens = part.trim().split(/\s+/);
   if (tokens.length === 0)
@@ -27338,10 +27941,10 @@ function applyMotionAutofix(projectRoot, report) {
     forbidLayoutProps: DEFAULT_NFR_SPEC.animation?.forbidLayoutProps ?? true
   };
   for (const rel2 of targets) {
-    const abs = join8(projectRoot, rel2);
+    const abs = join10(projectRoot, rel2);
     let html;
     try {
-      html = readFileSync12(abs, "utf8");
+      html = readFileSync13(abs, "utf8");
     } catch {
       continue;
     }
@@ -27356,7 +27959,7 @@ function applyMotionAutofix(projectRoot, report) {
     const afterK = scanKeyframesViolations(final, scanOpts).length;
     const afterT = scanTransitionViolations(final, scanOpts).length;
     if (final !== html || beforeK > afterK || beforeT > afterT) {
-      writeFileSync8(abs, final, "utf8");
+      writeFileSync9(abs, final, "utf8");
       filesChanged.push(rel2);
       if (beforeK > afterK)
         fixes.push(`${rel2}: sanitized ${beforeK - afterK} keyframe violation(s)`);
@@ -27367,7 +27970,7 @@ function applyMotionAutofix(projectRoot, report) {
       if (!fixes.some((f) => f.startsWith(rel2)))
         fixes.push(`${rel2}: motion CSS sanitized`);
     } else if (motionChanged) {
-      writeFileSync8(abs, final, "utf8");
+      writeFileSync9(abs, final, "utf8");
       filesChanged.push(rel2);
       fixes.push(`${rel2}: motion CSS sanitized`);
     }
@@ -27413,8 +28016,8 @@ var init_motionAutofix = __esm({
 });
 
 // packages/core/dist/council/verification/autofix.js
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join9 } from "node:path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join11 } from "node:path";
 function applyDeterministicAutofix(projectRoot, report) {
   const motion = applyMotionAutofix(projectRoot, report);
   const inlineJs = applyInlineJsAutofix(projectRoot, report);
@@ -27428,8 +28031,8 @@ function applyDeterministicAutofix(projectRoot, report) {
     const m = r.evidence?.match(/classList\.add\(\s*['"]([\w-]+)['"]\s*\)/);
     if (!m || m[1] === "rm")
       continue;
-    const abs = join9(projectRoot, rel2);
-    let html = readFileSync13(abs, "utf8");
+    const abs = join11(projectRoot, rel2);
+    let html = readFileSync14(abs, "utf8");
     const snippet = m[0];
     if (!html.includes(snippet))
       continue;
@@ -27437,7 +28040,7 @@ function applyDeterministicAutofix(projectRoot, report) {
     const filtered = lines.filter((line) => !line.includes(snippet));
     if (filtered.length === lines.length)
       continue;
-    writeFileSync9(abs, filtered.join("\n"), "utf8");
+    writeFileSync10(abs, filtered.join("\n"), "utf8");
     filesChanged.push(rel2);
     fixes.push(`removed dead hook line in ${rel2}: ${snippet}`);
   }
@@ -27484,12 +28087,12 @@ var init_types3 = __esm({
 });
 
 // packages/core/dist/council/lessons/io.js
-import { readFileSync as readFileSync14 } from "node:fs";
-import { join as join10 } from "node:path";
+import { readFileSync as readFileSync15 } from "node:fs";
+import { join as join12 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path38 = join10(zelariRoot, LESSONS_FILE);
+  const path38 = join12(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync14(path38, "utf8");
+    const raw = readFileSync15(path38, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -27580,7 +28183,7 @@ var init_signatures = __esm({
 
 // packages/core/dist/council/lessons/recordFailure.js
 import { appendFileSync as appendFileSync2 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 function methodologyFor(check2) {
   return METHODOLOGY[check2.id] ?? `When ${check2.id} fails, fix the underlying issue and cite grep/tool evidence before claiming PASS.`;
 }
@@ -27590,7 +28193,7 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path38 = join11(zelariRoot, LESSONS_FILE);
+  const path38 = join13(zelariRoot, LESSONS_FILE);
   appendFileSync2(path38, `${JSON.stringify(lesson)}
 `, "utf8");
 }
@@ -27747,8 +28350,8 @@ var init_types4 = __esm({
 });
 
 // packages/core/dist/council/completion/buildCompletion.js
-import { writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join12 } from "node:path";
+import { writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join14 } from "node:path";
 function openFailsFromReport(report) {
   if (!report)
     return [];
@@ -27776,8 +28379,8 @@ function tierSummary(report) {
 function promptSummaryFrom(synthesisText) {
   if (!synthesisText?.trim())
     return void 0;
-  const oneLine = synthesisText.replace(/\s+/g, " ").trim();
-  return oneLine.length > 240 ? `${oneLine.slice(0, 237)}...` : oneLine;
+  const oneLine2 = synthesisText.replace(/\s+/g, " ").trim();
+  return oneLine2.length > 240 ? `${oneLine2.slice(0, 237)}...` : oneLine2;
 }
 function buildCouncilCompletion(input) {
   const openFails = openFailsFromReport(input.verification?.report);
@@ -27807,8 +28410,8 @@ function buildCouncilCompletion(input) {
   };
 }
 function writeCouncilCompletion(zelariRoot, completion) {
-  const outPath = join12(zelariRoot, "completion.json");
-  writeFileSync10(outPath, JSON.stringify(completion, null, 2), "utf8");
+  const outPath = join14(zelariRoot, "completion.json");
+  writeFileSync11(outPath, JSON.stringify(completion, null, 2), "utf8");
   return outPath;
 }
 var init_buildCompletion = __esm({
@@ -28134,33 +28737,241 @@ var init_council = __esm({
     init_systemPromptBuilder();
     init_promptModules();
   }
-});
-
-// packages/core/dist/memory/types.js
-var init_types5 = __esm({
-  "packages/core/dist/memory/types.js"() {
+});
+
+// packages/core/dist/memory/types.js
+var init_types5 = __esm({
+  "packages/core/dist/memory/types.js"() {
+    "use strict";
+  }
+});
+
+// packages/core/dist/state/index.js
+var init_state = __esm({
+  "packages/core/dist/state/index.js"() {
+    "use strict";
+  }
+});
+
+// packages/core/dist/index.js
+var init_dist = __esm({
+  "packages/core/dist/index.js"() {
+    "use strict";
+    init_events2();
+    init_types();
+    init_harness();
+    init_council();
+    init_skills2();
+    init_types5();
+    init_state();
+  }
+});
+
+// src/cli/budget/historySummary.ts
+function extractiveHistorySummary(dropped, opts) {
+  const maxChars = opts?.maxChars ?? MAX_SUMMARY_CHARS;
+  if (dropped.length === 0) return "No prior turns.";
+  const userGoals = [];
+  const assistantNotes = [];
+  const tools = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Set();
+  let toolResults = 0;
+  for (const m of dropped) {
+    if (m.role === "user" && m.content.trim()) {
+      userGoals.push(oneLine(m.content, 220));
+    } else if (m.role === "assistant") {
+      if (m.content.trim()) {
+        assistantNotes.push(oneLine(m.content, 180));
+      }
+      if (m.toolCalls) {
+        for (const tc of m.toolCalls) {
+          tools.set(tc.name, (tools.get(tc.name) ?? 0) + 1);
+          collectPaths(tc.args, files);
+        }
+      }
+    } else if (m.role === "tool") {
+      toolResults += 1;
+      collectPathsFromText(m.content, files);
+    }
+  }
+  const parts = [
+    "[history-summary] Earlier turns were compacted to stay within the context budget.",
+    `Dropped ${dropped.length} message(s) (${userGoals.length} user, ${assistantNotes.length} assistant notes, ${toolResults} tool results).`
+  ];
+  if (userGoals.length) {
+    parts.push("## User goals / requests");
+    for (const g of userGoals.slice(-6)) parts.push(`- ${g}`);
+  }
+  if (assistantNotes.length) {
+    parts.push("## Assistant conclusions (truncated)");
+    for (const a of assistantNotes.slice(-5)) parts.push(`- ${a}`);
+  }
+  if (tools.size) {
+    const ranked = [...tools.entries()].sort((a, b) => b[1] - a[1]).slice(0, 12).map(([n, c]) => `${n}\xD7${c}`);
+    parts.push(`## Tools used: ${ranked.join(", ")}`);
+  }
+  if (files.size) {
+    const list = [...files].slice(0, 24);
+    parts.push(`## Paths mentioned: ${list.join(", ")}`);
+  }
+  parts.push(
+    "Continue from the recent messages below; do not re-ask goals already answered above unless the user changes them."
+  );
+  let out = parts.join("\n");
+  if (out.length > maxChars) {
+    out = `${out.slice(0, maxChars - 1)}\u2026`;
+  }
+  return out;
+}
+function formatDroppedForLlm(dropped) {
+  const lines = [];
+  for (const m of dropped) {
+    if (m.role === "user") {
+      lines.push(`USER: ${oneLine(m.content, 400)}`);
+    } else if (m.role === "assistant") {
+      const tools = m.toolCalls?.map((t) => t.name).join(",") || "";
+      const body2 = oneLine(m.content, 300);
+      lines.push(
+        tools ? `ASSISTANT(tools=${tools}): ${body2}` : `ASSISTANT: ${body2}`
+      );
+    } else if (m.role === "tool") {
+      lines.push(`TOOL(${m.toolCallId ?? "?"}): ${oneLine(m.content, 160)}`);
+    } else if (m.role === "system") {
+      lines.push(`SYSTEM: ${oneLine(m.content, 200)}`);
+    }
+  }
+  let body = lines.join("\n");
+  if (body.length > MAX_LLM_INPUT_CHARS) {
+    body = body.slice(body.length - MAX_LLM_INPUT_CHARS);
+  }
+  return body;
+}
+function oneLine(s, max) {
+  const t = s.replace(/\s+/g, " ").trim();
+  if (t.length <= max) return t;
+  return `${t.slice(0, max - 1)}\u2026`;
+}
+function collectPaths(args, out) {
+  if (!args || typeof args !== "object") return;
+  const obj = args;
+  for (const key of ["path", "file", "filepath", "filePath", "target", "cwd"]) {
+    const v = obj[key];
+    if (typeof v === "string" && v.length > 1 && v.length < 260) {
+      out.add(v.replace(/\\/g, "/"));
+    }
+  }
+  if (typeof obj.file_path === "string") out.add(String(obj.file_path));
+}
+function collectPathsFromText(text, out) {
+  const re = /(?:^|[\s"'`])((?:[\w.-]+\/)+[\w.-]+\.\w{1,8})/g;
+  let m;
+  let n = 0;
+  while ((m = re.exec(text)) !== null && n < 8) {
+    out.add(m[1]);
+    n += 1;
+  }
+}
+var MAX_SUMMARY_CHARS, MAX_LLM_INPUT_CHARS;
+var init_historySummary = __esm({
+  "src/cli/budget/historySummary.ts"() {
     "use strict";
+    MAX_SUMMARY_CHARS = 3500;
+    MAX_LLM_INPUT_CHARS = 24e3;
   }
 });
 
-// packages/core/dist/state/index.js
-var init_state = __esm({
-  "packages/core/dist/state/index.js"() {
-    "use strict";
+// src/cli/budget/llmCompact.ts
+function isLlmCompactEnabled() {
+  const v = process.env.ZELARI_LLM_COMPACT?.trim().toLowerCase();
+  if (v === "0" || v === "false" || v === "off" || v === "no") return false;
+  return true;
+}
+async function llmSummarizeHistory(input) {
+  if (!isLlmCompactEnabled()) return null;
+  if (!input.droppedTranscript.trim()) return null;
+  let config2 = null;
+  try {
+    config2 = await resolveCompactProviderConfig();
+  } catch {
+    return null;
   }
-});
+  if (!config2) return null;
+  const model = process.env.ZELARI_COMPACT_MODEL?.trim() || config2.model;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 45e3);
+  const onOuterAbort = () => controller.abort();
+  input.signal?.addEventListener("abort", onOuterAbort, { once: true });
+  try {
+    const url2 = `${config2.baseUrl.replace(/\/$/, "")}/chat/completions`;
+    const res = await fetch(url2, {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${config2.apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        temperature: 0.1,
+        max_tokens: 900,
+        stream: false,
+        messages: [
+          { role: "system", content: COMPACT_SYSTEM },
+          {
+            role: "user",
+            content: `Extractive sketch (may be incomplete):
+${input.extractive.slice(0, 2500)}
 
-// packages/core/dist/index.js
-var init_dist = __esm({
-  "packages/core/dist/index.js"() {
+Transcript of dropped turns:
+${input.droppedTranscript}`
+          }
+        ]
+      })
+    });
+    if (!res.ok) return null;
+    const json2 = await res.json();
+    const text = json2.choices?.[0]?.message?.content?.trim();
+    if (!text) return null;
+    return "[history-summary \xB7 llm]\n" + text + "\n\nContinue from the recent messages below; honor decisions already made above.";
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+    input.signal?.removeEventListener("abort", onOuterAbort);
+  }
+}
+async function resolveCompactProviderConfig() {
+  const active = getProviderConfig().activeProviderId;
+  const meta3 = await resolveApiKeyWithMeta(active);
+  const apiKey = meta3?.apiKey;
+  if (!apiKey) return null;
+  const custom2 = getCustomEndpoint(active);
+  let baseUrl = custom2 || (active === "openai-compatible" || active === "custom" ? process.env.OPENAI_BASE_URL ?? PROVIDER_ENDPOINTS[active] : PROVIDER_ENDPOINTS[active]);
+  if (!baseUrl) return null;
+  const model = getModelForProvider(active);
+  return {
+    apiKey,
+    baseUrl,
+    model,
+    providerId: active
+  };
+}
+var COMPACT_SYSTEM;
+var init_llmCompact = __esm({
+  "src/cli/budget/llmCompact.ts"() {
     "use strict";
-    init_events2();
-    init_types();
-    init_harness();
-    init_council();
-    init_skills2();
-    init_types5();
-    init_state();
+    init_providerConfig();
+    init_keyStore();
+    init_openai_compatible();
+    COMPACT_SYSTEM = `You compress earlier turns of a coding-agent session into a dense continuity brief.
+Output plain text (no markdown fences) with these sections:
+1) Goal \u2014 what the user wants
+2) Decisions \u2014 choices already made
+3) Done \u2014 completed work / files changed
+4) Open \u2014 remaining tasks / blockers
+5) Constraints \u2014 important rules the agent must keep
+
+Be factual and concise. Max ~400 words. Do not invent work that was not present.`;
   }
 });
 
@@ -28231,24 +29042,77 @@ function findValidCutIndex(messages, naiveCut) {
   return cut;
 }
 function compactHistory(messages, opts) {
+  return compactHistoryDetailed(messages, opts).messages;
+}
+function compactHistoryDetailed(messages, opts) {
   const maxMessages = resolveMaxMessages(opts);
-  if (maxMessages === 0) return [];
-  if (messages.length <= maxMessages * 2) return messages;
+  if (maxMessages === 0) {
+    return { messages: [], compacted: true, messagesRemoved: messages.length, summary: "" };
+  }
+  if (messages.length <= maxMessages * 2) {
+    return {
+      messages,
+      compacted: false,
+      messagesRemoved: 0,
+      summary: ""
+    };
+  }
   const naiveCut = messages.length - maxMessages;
   const cut = findValidCutIndex(messages, naiveCut);
-  const dropped = cut;
-  if (dropped === 0) return messages;
+  if (cut === 0) {
+    return {
+      messages,
+      compacted: false,
+      messagesRemoved: 0,
+      summary: ""
+    };
+  }
+  const droppedMsgs = messages.slice(0, cut);
   const kept = messages.slice(cut);
+  const summaryText = extractiveHistorySummary(droppedMsgs);
   const summary = {
     role: "system",
-    content: `${COMPACT_MARKER} ${dropped} earlier message(s) dropped.`
+    content: summaryText || `${COMPACT_MARKER} ${cut} earlier message(s) dropped.`
+  };
+  return {
+    messages: [summary, ...kept],
+    compacted: true,
+    messagesRemoved: cut,
+    summary: summary.content
+  };
+}
+async function compactHistoryAsync(messages, opts) {
+  const base = compactHistoryDetailed(messages, opts);
+  if (!base.compacted || base.messagesRemoved === 0) return base;
+  const cut = base.messagesRemoved;
+  const droppedMsgs = messages.slice(0, cut);
+  const extractive = extractiveHistorySummary(droppedMsgs);
+  const droppedTranscript = formatDroppedForLlm(droppedMsgs);
+  let summaryText = extractive;
+  try {
+    const llm = await llmSummarizeHistory({
+      extractive,
+      droppedTranscript,
+      signal: opts?.signal
+    });
+    if (llm && llm.trim().length > 40) summaryText = llm.trim();
+  } catch {
+  }
+  const kept = messages.slice(cut);
+  const summary = { role: "system", content: summaryText };
+  return {
+    messages: [summary, ...kept],
+    compacted: true,
+    messagesRemoved: cut,
+    summary: summaryText
   };
-  return [summary, ...kept];
 }
 var COMPACT_MARKER;
 var init_historyCompaction = __esm({
   "src/cli/hooks/historyCompaction.ts"() {
     "use strict";
+    init_historySummary();
+    init_llmCompact();
     init_envNumber();
     COMPACT_MARKER = "[history] Earlier turns were compacted to stay within the context budget.";
   }
@@ -28276,8 +29140,8 @@ __export(conversationContext_exports, {
   setHistory: () => setHistory,
   setLastClarification: () => setLastClarification
 });
-import { existsSync as existsSync14 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { join as join15 } from "node:path";
 function getHistory() {
   return history;
 }
@@ -28285,7 +29149,7 @@ function setHistory(messages) {
   history = [...messages];
 }
 function compactInPlace(cwd = process.cwd()) {
-  const durableStatePresent = existsSync14(join13(cwd, ".zelari", "state", "HEAD.json"));
+  const durableStatePresent = existsSync16(join15(cwd, ".zelari", "state", "HEAD.json"));
   history = compactHistory(history, { durableStatePresent });
 }
 function appendMessages(msgs) {
@@ -28295,6 +29159,8 @@ function appendMessages(msgs) {
 function clearHistory() {
   history = [];
   lastClarification = null;
+  clearSessionTodos();
+  clearSessionPermissionGrants();
 }
 function serializeHistory() {
   return [...history];
@@ -28441,11 +29307,15 @@ function truncate(s, max) {
 function _resetConversationContextForTests() {
   history = [];
   lastClarification = null;
+  clearSessionTodos();
+  clearSessionPermissionGrants();
 }
 var history, lastClarification, SHORT_CONTINUE, SHORT_CONTINUE_LOOSE;
 var init_conversationContext = __esm({
   "src/cli/hooks/conversationContext.ts"() {
     "use strict";
+    init_toolPermissions();
+    init_sessionTodos();
     init_historyCompaction();
     history = [];
     lastClarification = null;
@@ -28530,14 +29400,14 @@ var init_phase = __esm({
 });
 
 // src/cli/workspace/projectInstructions.ts
-import { existsSync as existsSync15, readFileSync as readFileSync15 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync16 } from "node:fs";
+import { join as join16 } from "node:path";
 function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
   for (const name of CANDIDATES) {
-    const full = join14(projectRoot, name);
-    if (!existsSync15(full)) continue;
+    const full = join16(projectRoot, name);
+    if (!existsSync17(full)) continue;
     try {
-      let raw = readFileSync15(full, "utf8");
+      let raw = readFileSync16(full, "utf8");
       raw = raw.replace(/\r\n/g, "\n").trim();
       if (!raw) continue;
       if (raw.length <= maxChars) {
@@ -28574,20 +29444,20 @@ var init_projectInstructions = __esm({
 
 // src/cli/workspace/paths.ts
 import {
-  mkdirSync as mkdirSync7,
-  writeFileSync as writeFileSync11,
-  existsSync as existsSync16,
+  mkdirSync as mkdirSync8,
+  writeFileSync as writeFileSync12,
+  existsSync as existsSync18,
   accessSync,
   constants,
   realpathSync
 } from "node:fs";
-import { join as join15, basename } from "node:path";
-import { homedir as homedir5 } from "node:os";
-import { createHash as createHash3 } from "node:crypto";
+import { join as join17, basename } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { createHash as createHash4 } from "node:crypto";
 function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   const candidates = [
-    join15(projectRoot, ".zelari"),
-    join15(homedir5(), ".zelari-code", "workspace", hashProject(projectRoot))
+    join17(projectRoot, ".zelari"),
+    join17(homedir7(), ".zelari-code", "workspace", hashProject(projectRoot))
   ];
   for (const candidate of candidates) {
     if (isWritableDir(projectRoot) || candidate !== candidates[0]) {
@@ -28599,11 +29469,11 @@ function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   return candidates[0];
 }
 function hashProject(projectPath) {
-  return createHash3("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+  return createHash4("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
 }
 function isWritableDir(dir) {
   try {
-    if (!existsSync16(dir)) return false;
+    if (!existsSync18(dir)) return false;
     accessSync(dir, constants.W_OK);
     return true;
   } catch {
@@ -28611,26 +29481,26 @@ function isWritableDir(dir) {
   }
 }
 function ensureWorkspaceDir(workspaceDir) {
-  mkdirSync7(workspaceDir, { recursive: true });
-  if (workspaceDir.endsWith("/.zelari") && existsSync16(join15(workspaceDir, "..", ".git"))) {
-    const gitignorePath = join15(workspaceDir, ".gitignore");
-    if (!existsSync16(gitignorePath)) {
-      writeFileSync11(gitignorePath, "*\n!.gitignore\n");
+  mkdirSync8(workspaceDir, { recursive: true });
+  if (workspaceDir.endsWith("/.zelari") && existsSync18(join17(workspaceDir, "..", ".git"))) {
+    const gitignorePath = join17(workspaceDir, ".gitignore");
+    if (!existsSync18(gitignorePath)) {
+      writeFileSync12(gitignorePath, "*\n!.gitignore\n");
     }
   }
 }
 function workspaceFile(rootDir, kind) {
   switch (kind) {
     case "plan":
-      return join15(rootDir, "plan.md");
+      return join17(rootDir, "plan.md");
     case "risks":
-      return join15(rootDir, "risks.md");
+      return join17(rootDir, "risks.md");
     case "index":
-      return join15(rootDir, "workspace.json");
+      return join17(rootDir, "workspace.json");
   }
 }
 function workspaceArtifact(rootDir, subdir, slug) {
-  return join15(rootDir, subdir, `${slug}.md`);
+  return join17(rootDir, subdir, `${slug}.md`);
 }
 function projectName(projectRoot = process.cwd()) {
   return basename(realpathSync(projectRoot));
@@ -28650,8 +29520,8 @@ __export(workspaceSummary_exports, {
   buildWorkspaceSummary: () => buildWorkspaceSummary,
   buildZelariReadHint: () => buildZelariReadHint
 });
-import { existsSync as existsSync17, readFileSync as readFileSync16, readdirSync, statSync as statSync3 } from "node:fs";
-import { join as join16, relative } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync17, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
+import { join as join18, relative } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30, maxChars = 3500, maxDeps = 24, maxScripts = 16 } = options;
   const name = safeProjectName(projectRoot);
@@ -28684,11 +29554,11 @@ function formatTaskLine(t) {
 }
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  const planPath = join16(zelariRoot, "plan.json");
-  if (!existsSync17(planPath)) return null;
+  const planPath = join18(zelariRoot, "plan.json");
+  if (!existsSync19(planPath)) return null;
   let plan;
   try {
-    plan = JSON.parse(readFileSync16(planPath, "utf8"));
+    plan = JSON.parse(readFileSync17(planPath, "utf8"));
   } catch {
     return null;
   }
@@ -28824,8 +29694,8 @@ function pickNextTask(open) {
   )[0];
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
-  const planPath = join16(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync17(planPath)) return "";
+  const planPath = join18(resolveWorkspaceRoot(projectRoot), "plan.json");
+  if (!existsSync19(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/) \u2014 DRAFT vault",
     "`.zelari/plan.json` and `.zelari/docs/` hold **design hypotheses**, not verified product state.",
@@ -28840,10 +29710,10 @@ function safeProjectName(root) {
   }
 }
 function readPackageJson(projectRoot) {
-  const p3 = join16(projectRoot, "package.json");
-  if (!existsSync17(p3)) return null;
+  const p3 = join18(projectRoot, "package.json");
+  if (!existsSync19(p3)) return null;
   try {
-    return JSON.parse(readFileSync16(p3, "utf8"));
+    return JSON.parse(readFileSync17(p3, "utf8"));
   } catch {
     return null;
   }
@@ -28884,7 +29754,7 @@ function readBuildScripts(projectRoot, maxScripts = 16) {
 function listShallow(projectRoot, maxEntries) {
   const out = [];
   try {
-    const top = readdirSync(projectRoot, { withFileTypes: true }).filter(
+    const top = readdirSync2(projectRoot, { withFileTypes: true }).filter(
       (e) => !e.name.startsWith(".") && e.name !== "node_modules" && e.name !== "dist"
     ).sort((a, b) => a.name.localeCompare(b.name));
     let count = 0;
@@ -28893,11 +29763,11 @@ function listShallow(projectRoot, maxEntries) {
         out.push(`\u2026 (+${top.length - count} more)`);
         break;
       }
-      const rel2 = relative(projectRoot, join16(projectRoot, entry.name));
+      const rel2 = relative(projectRoot, join18(projectRoot, entry.name));
       if (entry.isDirectory()) {
         let inner = "";
         try {
-          const sub = readdirSync(join16(projectRoot, entry.name), {
+          const sub = readdirSync2(join18(projectRoot, entry.name), {
             withFileTypes: true
           }).filter((e) => !e.name.startsWith(".")).slice(0, 4).map((e) => e.name);
           if (sub.length > 0)
@@ -28945,12 +29815,12 @@ var init_workspaceSummary = __esm({
 });
 
 // src/cli/workspace/buildLessonsSummary.ts
-import { existsSync as existsSync18 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { join as join19 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync18(join17(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync20(join19(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -28971,8 +29841,8 @@ var composeContext_exports = {};
 __export(composeContext_exports, {
   composeProjectContext: () => composeProjectContext
 });
-import { existsSync as existsSync19, readdirSync as readdirSync2, readFileSync as readFileSync17 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync21, readdirSync as readdirSync3, readFileSync as readFileSync18 } from "node:fs";
+import { join as join20 } from "node:path";
 function cap(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
   return {
@@ -28984,19 +29854,19 @@ function cap(text, max, label) {
 }
 function buildDesignIndex(projectRoot, maxChars) {
   const root = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync19(root)) return "";
+  if (!existsSync21(root)) return "";
   const lines = [
     "# Design vault index (.zelari/) \u2014 HYPOTHESES only",
     "Full design docs are NOT product source of truth. Open with list_files / read_file / searchDocuments if needed."
   ];
-  const docsDir = join18(root, "docs");
-  if (existsSync19(docsDir)) {
+  const docsDir = join20(root, "docs");
+  if (existsSync21(docsDir)) {
     try {
-      const docs = readdirSync2(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
+      const docs = readdirSync3(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
       if (docs.length > 0) {
         lines.push("", "## docs/ (titles only)");
         for (const d of docs) lines.push(`- .zelari/docs/${d}`);
-        if (readdirSync2(docsDir).filter((n) => n.endsWith(".md")).length > 12) {
+        if (readdirSync3(docsDir).filter((n) => n.endsWith(".md")).length > 12) {
           lines.push("- \u2026 (more under .zelari/docs/)");
         }
       }
@@ -29004,14 +29874,14 @@ function buildDesignIndex(projectRoot, maxChars) {
     }
   }
   for (const name of ["risks.md", "plan.json", "nfr-spec.json"]) {
-    if (existsSync19(join18(root, name))) {
+    if (existsSync21(join20(root, name))) {
       lines.push(`- .zelari/${name} present`);
     }
   }
-  const decisionsDir = join18(root, "decisions");
-  if (existsSync19(decisionsDir)) {
+  const decisionsDir = join20(root, "decisions");
+  if (existsSync21(decisionsDir)) {
     try {
-      const n = readdirSync2(decisionsDir).filter((f) => f.endsWith(".md")).length;
+      const n = readdirSync3(decisionsDir).filter((f) => f.endsWith(".md")).length;
       if (n > 0) lines.push(`- .zelari/decisions/ (${n} ADR file(s) \u2014 treat proposed as non-binding)`);
     } catch {
     }
@@ -29110,17 +29980,17 @@ function composeProjectContext(input) {
 }
 function readDurableHeadSync(projectRoot) {
   try {
-    const headPath = join18(projectRoot, ".zelari", "state", "HEAD.json");
-    if (!existsSync19(headPath)) return "";
-    const head = JSON.parse(readFileSync17(headPath, "utf8"));
+    const headPath = join20(projectRoot, ".zelari", "state", "HEAD.json");
+    if (!existsSync21(headPath)) return "";
+    const head = JSON.parse(readFileSync18(headPath, "utf8"));
     if (!head?.id) return "";
-    const metaPath = join18(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
-    if (!existsSync19(metaPath)) return "";
-    const meta3 = JSON.parse(readFileSync17(metaPath, "utf8"));
-    const discPath = meta3.artifactDir ? join18(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join18(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
+    const metaPath = join20(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
+    if (!existsSync21(metaPath)) return "";
+    const meta3 = JSON.parse(readFileSync18(metaPath, "utf8"));
+    const discPath = meta3.artifactDir ? join20(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join20(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
     let discoveries = [];
-    if (existsSync19(discPath)) {
-      discoveries = JSON.parse(readFileSync17(discPath, "utf8"));
+    if (existsSync21(discPath)) {
+      discoveries = JSON.parse(readFileSync18(discPath, "utf8"));
     }
     const reusable = discoveries.filter((d) => d.reusable !== false);
     const lines = [
@@ -29153,13 +30023,13 @@ var planDetect_exports = {};
 __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
-import { existsSync as existsSync20, readFileSync as readFileSync18 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync19 } from "node:fs";
+import { join as join21 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
-  const planPath = join19(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync20(planPath)) return false;
+  const planPath = join21(resolveWorkspaceRoot(projectRoot), "plan.json");
+  if (!existsSync22(planPath)) return false;
   try {
-    const parsed = JSON.parse(readFileSync18(planPath, "utf8"));
+    const parsed = JSON.parse(readFileSync19(planPath, "utf8"));
     return Array.isArray(parsed.phases) && parsed.phases.length > 0;
   } catch {
     return false;
@@ -29219,14 +30089,14 @@ __export(storage_exports, {
   workspaceMutex: () => workspaceMutex
 });
 import {
-  readFileSync as readFileSync19,
-  writeFileSync as writeFileSync12,
-  existsSync as existsSync21,
-  mkdirSync as mkdirSync8,
-  readdirSync as readdirSync3,
+  readFileSync as readFileSync20,
+  writeFileSync as writeFileSync13,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync9,
+  readdirSync as readdirSync4,
   renameSync as renameSync2
 } from "node:fs";
-import { dirname as dirname4, join as join20 } from "node:path";
+import { dirname as dirname4, join as join22 } from "node:path";
 function parseFrontmatter(md) {
   const m = FRONTMATTER_RE.exec(md);
   if (!m) return { meta: {}, body: md };
@@ -29481,15 +30351,15 @@ var init_storage = __esm({
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
       read(path38) {
-        if (!existsSync21(path38)) {
+        if (!existsSync23(path38)) {
           throw new Error(`File not found: ${path38}`);
         }
-        const md = readFileSync19(path38, "utf8");
+        const md = readFileSync20(path38, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
       readIfExists(path38) {
-        if (!existsSync21(path38)) return null;
+        if (!existsSync23(path38)) return null;
         return this.read(path38);
       }
       /**
@@ -29497,16 +30367,16 @@ var init_storage = __esm({
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
       write(path38, meta3, body) {
-        mkdirSync8(dirname4(path38), { recursive: true });
+        mkdirSync9(dirname4(path38), { recursive: true });
         const tmp = path38 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
-        writeFileSync12(tmp, md, "utf8");
+        writeFileSync13(tmp, md, "utf8");
         renameSync2(tmp, path38);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
-        if (!existsSync21(dir)) return [];
-        return readdirSync3(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join20(dir, f));
+        if (!existsSync23(dir)) return [];
+        return readdirSync4(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join22(dir, f));
       }
     };
     KeyedMutex = class {
@@ -29545,14 +30415,14 @@ __export(stubs_exports, {
   resolveWorkspaceRoot: () => resolveWorkspaceRoot
 });
 import {
-  existsSync as existsSync22,
-  readdirSync as readdirSync4,
-  writeFileSync as writeFileSync13,
-  readFileSync as readFileSync20,
-  mkdirSync as mkdirSync9,
+  existsSync as existsSync24,
+  readdirSync as readdirSync5,
+  writeFileSync as writeFileSync14,
+  readFileSync as readFileSync21,
+  mkdirSync as mkdirSync10,
   renameSync as renameSync3
 } from "node:fs";
-import { join as join21, basename as basename2, dirname as dirname5, relative as relative2 } from "node:path";
+import { join as join23, basename as basename2, dirname as dirname5, relative as relative2 } from "node:path";
 function createWorkspaceContext(projectRoot = process.cwd()) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return {
@@ -29562,14 +30432,14 @@ function createWorkspaceContext(projectRoot = process.cwd()) {
   };
 }
 function planJsonPath(ctx) {
-  return join21(ctx.rootDir, "plan.json");
+  return join23(ctx.rootDir, "plan.json");
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
-  if (existsSync22(jsonPath)) {
+  if (existsSync24(jsonPath)) {
     try {
       const parsed = JSON.parse(
-        readFileSync20(jsonPath, "utf8")
+        readFileSync21(jsonPath, "utf8")
       );
       return {
         phases: Array.isArray(parsed.phases) ? parsed.phases : [],
@@ -29591,9 +30461,9 @@ function readPlan(ctx) {
 }
 function writePlan(ctx, summary) {
   const jsonPath = planJsonPath(ctx);
-  mkdirSync9(dirname5(jsonPath), { recursive: true });
+  mkdirSync10(dirname5(jsonPath), { recursive: true });
   const tmp = jsonPath + ".tmp-" + process.pid;
-  writeFileSync13(tmp, JSON.stringify(summary, null, 2), "utf8");
+  writeFileSync14(tmp, JSON.stringify(summary, null, 2), "utf8");
   renameSync3(tmp, jsonPath);
   const mdPath = workspaceFile(ctx.rootDir, "plan");
   const summaryMeta = {
@@ -29660,9 +30530,9 @@ function renderPlanBody(summary) {
   return lines.join("\n");
 }
 function nextAdrId(ctx) {
-  const decisionsDir = join21(ctx.rootDir, "decisions");
-  if (!existsSync22(decisionsDir)) return "001";
-  const existing = readdirSync4(decisionsDir).filter((f) => f.endsWith(".md")).map((f) => f.match(/^(\d+)-/)).filter((m) => !!m).map((m) => parseInt(m[1], 10));
+  const decisionsDir = join23(ctx.rootDir, "decisions");
+  if (!existsSync24(decisionsDir)) return "001";
+  const existing = readdirSync5(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");
 }
@@ -29703,7 +30573,7 @@ function addTaskRecord(ctx, summary, phaseId, t, options) {
     status: "pending",
     priority: t.priority
   });
-  const taskPath = join21(ctx.rootDir, "plan-tasks", `${id}.md`);
+  const taskPath = join23(ctx.rootDir, "plan-tasks", `${id}.md`);
   const meta3 = {
     kind: "task",
     id,
@@ -29745,7 +30615,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path38 = join21(ctx.rootDir, "milestones", `${id}.md`);
+  const path38 = join23(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -30043,8 +30913,8 @@ function createNfrSpecStub(ctx) {
           },
           planFeatureKeywords: Array.isArray(args["planFeatureKeywords"]) ? args["planFeatureKeywords"] : void 0
         };
-        const outPath = join21(ctx.rootDir, "nfr-spec.json");
-        writeFileSync13(outPath, JSON.stringify(spec, null, 2), "utf8");
+        const outPath = join23(ctx.rootDir, "nfr-spec.json");
+        writeFileSync14(outPath, JSON.stringify(spec, null, 2), "utf8");
         return `NFR spec written to nfr-spec.json (${targets.length} target(s)).`;
       });
     }
@@ -30107,18 +30977,18 @@ function searchDocumentsStub(ctx) {
         (w) => w.length >= 3 && w !== "or" && w !== "and" && w !== "the"
       );
       const files = [
-        ...ctx.storage.listMarkdown(join21(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join21(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join21(ctx.rootDir, "reviews")),
-        ...ctx.storage.listMarkdown(join21(ctx.rootDir, "plan-tasks")),
-        ...ctx.storage.listMarkdown(join21(ctx.rootDir, "milestones")),
+        ...ctx.storage.listMarkdown(join23(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join23(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join23(ctx.rootDir, "reviews")),
+        ...ctx.storage.listMarkdown(join23(ctx.rootDir, "plan-tasks")),
+        ...ctx.storage.listMarkdown(join23(ctx.rootDir, "milestones")),
         workspaceFile(ctx.rootDir, "plan"),
         workspaceFile(ctx.rootDir, "risks")
       ];
       const results = [];
       for (const file2 of files) {
-        if (!existsSync22(file2)) continue;
-        const raw = readFileSync20(file2, "utf8");
+        if (!existsSync24(file2)) continue;
+        const raw = readFileSync21(file2, "utf8");
         const content = raw.toLowerCase();
         let idx = -1;
         let matchLen = 0;
@@ -30169,9 +31039,9 @@ function linkDocumentsStub(ctx) {
         const toId = args["toId"] ?? args["targetId"] ?? args["targetPathOrTitle"];
         if (!fromId || !toId) return "linkDocuments requires fromId and toId.";
         const allFiles = [
-          ...ctx.storage.listMarkdown(join21(ctx.rootDir, "decisions")),
-          ...ctx.storage.listMarkdown(join21(ctx.rootDir, "docs")),
-          ...ctx.storage.listMarkdown(join21(ctx.rootDir, "reviews"))
+          ...ctx.storage.listMarkdown(join23(ctx.rootDir, "decisions")),
+          ...ctx.storage.listMarkdown(join23(ctx.rootDir, "docs")),
+          ...ctx.storage.listMarkdown(join23(ctx.rootDir, "reviews"))
         ];
         const source = allFiles.find((f) => {
           try {
@@ -30202,9 +31072,9 @@ function getDocumentBacklinksStub(ctx) {
       const targetId = args["targetId"] ?? args["id"];
       if (!targetId) return "getDocumentBacklinks requires targetId.";
       const allFiles = [
-        ...ctx.storage.listMarkdown(join21(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join21(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join21(ctx.rootDir, "reviews"))
+        ...ctx.storage.listMarkdown(join23(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join23(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join23(ctx.rootDir, "reviews"))
       ];
       const backlinks = [];
       for (const file2 of allFiles) {
@@ -30299,7 +31169,7 @@ __export(updater_exports, {
 });
 import { createRequire as createRequire2 } from "node:module";
 import { spawn as spawn6 } from "node:child_process";
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync25 } from "node:fs";
 import path25 from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveBundledNpmCli(execPath = process.execPath) {
@@ -30312,7 +31182,7 @@ function resolveBundledNpmCli(execPath = process.execPath) {
   ];
   for (const candidate of candidates) {
     try {
-      if (existsSync23(candidate)) return candidate;
+      if (existsSync25(candidate)) return candidate;
     } catch {
     }
   }
@@ -30612,23 +31482,23 @@ var init_mcpClient = __esm({
 
 // src/cli/mcp/mcpConfigIo.ts
 import {
-  existsSync as existsSync24,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync21,
-  writeFileSync as writeFileSync14
+  existsSync as existsSync26,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync22,
+  writeFileSync as writeFileSync15
 } from "node:fs";
-import { dirname as dirname6, join as join22 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { dirname as dirname6, join as join24 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 function getUserMcpPath() {
-  return join22(homedir6(), ".zelari-code", "mcp.json");
+  return join24(homedir8(), ".zelari-code", "mcp.json");
 }
 function getProjectMcpPath(projectRoot) {
-  return join22(projectRoot, ".zelari", "mcp.json");
+  return join24(projectRoot, ".zelari", "mcp.json");
 }
 function readFile2(path38) {
-  if (!existsSync24(path38)) return {};
+  if (!existsSync26(path38)) return {};
   try {
-    const parsed = JSON.parse(readFileSync21(path38, "utf8"));
+    const parsed = JSON.parse(readFileSync22(path38, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -30645,9 +31515,9 @@ function readFile2(path38) {
   }
 }
 function writeFile(path38, servers) {
-  mkdirSync10(dirname6(path38), { recursive: true });
+  mkdirSync11(dirname6(path38), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync14(path38, `${JSON.stringify(body, null, 2)}
+  writeFileSync15(path38, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -30801,20 +31671,20 @@ __export(mcpManager_exports, {
   readMcpConfig: () => readMcpConfig,
   registerMcpTools: () => registerMcpTools
 });
-import { existsSync as existsSync25, readFileSync as readFileSync22 } from "node:fs";
-import { join as join23 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync27, readFileSync as readFileSync23 } from "node:fs";
+import { join as join25 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 function readMcpConfig(projectRoot = process.cwd()) {
   const merged = {};
   const paths = [];
   if (process.env["ZELARI_MCP_USER"] !== "0") {
-    paths.push(join23(homedir7(), ".zelari-code", "mcp.json"));
+    paths.push(join25(homedir9(), ".zelari-code", "mcp.json"));
   }
-  paths.push(join23(projectRoot, ".zelari", "mcp.json"));
+  paths.push(join25(projectRoot, ".zelari", "mcp.json"));
   for (const p3 of paths) {
-    if (!existsSync25(p3)) continue;
+    if (!existsSync27(p3)) continue;
     try {
-      const parsed = JSON.parse(readFileSync22(p3, "utf8"));
+      const parsed = JSON.parse(readFileSync23(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;
@@ -31046,13 +31916,13 @@ __export(agentsMd_exports, {
   serializeAgentsMd: () => serializeAgentsMd,
   updateAgentsMd: () => updateAgentsMd
 });
-import { existsSync as existsSync26, readFileSync as readFileSync23, writeFileSync as writeFileSync15 } from "node:fs";
-import { createHash as createHash4 } from "node:crypto";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync24, writeFileSync as writeFileSync16 } from "node:fs";
+import { createHash as createHash5 } from "node:crypto";
+import { join as join26 } from "node:path";
 import { readFile as readFile3 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path38 = join24(projectRoot, "package.json");
-  if (!existsSync26(path38)) return null;
+  const path38 = join26(projectRoot, "package.json");
+  if (!existsSync28(path38)) return null;
   try {
     return JSON.parse(await readFile3(path38, "utf8"));
   } catch {
@@ -31076,8 +31946,8 @@ async function genTechStack(ctx) {
   ].join("\n");
 }
 async function genDecisions(ctx) {
-  const decisionsDir = join24(ctx.rootDir, "decisions");
-  if (!existsSync26(decisionsDir)) return "_No ADRs yet._";
+  const decisionsDir = join26(ctx.rootDir, "decisions");
+  if (!existsSync28(decisionsDir)) return "_No ADRs yet._";
   const files = ctx.storage.listMarkdown(decisionsDir).sort();
   const accepted = [];
   const proposed = [];
@@ -31102,9 +31972,9 @@ async function genDecisions(ctx) {
 }
 async function genConventions(ctx) {
   const lines = [];
-  const claudeMd = join24(ctx.projectRoot, "CLAUDE.MD");
-  if (existsSync26(claudeMd)) {
-    const content = readFileSync23(claudeMd, "utf8");
+  const claudeMd = join26(ctx.projectRoot, "CLAUDE.MD");
+  if (existsSync28(claudeMd)) {
+    const content = readFileSync24(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
     if (match) {
       lines.push('<!-- Extracted from CLAUDE.MD "Architecture rules" -->');
@@ -31136,9 +32006,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path38 = join24(ctx.rootDir, "risks.md");
-  if (!existsSync26(path38)) return "_No open questions._";
-  const content = readFileSync23(path38, "utf8");
+  const path38 = join26(ctx.rootDir, "risks.md");
+  if (!existsSync28(path38)) return "_No open questions._";
+  const content = readFileSync24(path38, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -31212,9 +32082,9 @@ function titleCase(id) {
   return id.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
 }
 async function updateAgentsMd(ctx, projectRoot) {
-  const agentsPath = join24(projectRoot, "AGENTS.MD");
-  if (existsSync26(agentsPath)) {
-    const content = readFileSync23(agentsPath, "utf8");
+  const agentsPath = join26(projectRoot, "AGENTS.MD");
+  if (existsSync28(agentsPath)) {
+    const content = readFileSync24(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id) => content.includes(MARKER_OPEN(id)));
     if (!hasAnyMarker) {
       return {
@@ -31229,8 +32099,8 @@ async function updateAgentsMd(ctx, projectRoot) {
     newSections.set(id, await GENERATORS[id](ctx));
   }
   let manualContent = "";
-  if (existsSync26(agentsPath)) {
-    const { manualBlocks } = parseAgentsMd(readFileSync23(agentsPath, "utf8"));
+  if (existsSync28(agentsPath)) {
+    const { manualBlocks } = parseAgentsMd(readFileSync24(agentsPath, "utf8"));
     manualContent = manualBlocks.after;
   } else {
     const projectName2 = projectName(projectRoot);
@@ -31246,7 +32116,7 @@ async function updateAgentsMd(ctx, projectRoot) {
       ""
     ].join("\n");
   }
-  const oldContent = existsSync26(agentsPath) ? readFileSync23(agentsPath, "utf8") : "";
+  const oldContent = existsSync28(agentsPath) ? readFileSync24(agentsPath, "utf8") : "";
   const { sections: oldSections } = parseAgentsMd(oldContent);
   const changedSections = [];
   for (const id of AUTO_SECTIONS) {
@@ -31258,11 +32128,11 @@ async function updateAgentsMd(ctx, projectRoot) {
     return { changed: false, sections: [] };
   }
   const newContent = serializeAgentsMd(manualContent, newSections);
-  writeFileSync15(agentsPath, newContent, "utf8");
+  writeFileSync16(agentsPath, newContent, "utf8");
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
-  return createHash4("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash5("sha256").update(s).digest("hex").slice(0, 16);
 }
 var AUTO_SECTIONS, MARKER_OPEN, MARKER_CLOSE, GENERATORS;
 var init_agentsMd = __esm({
@@ -31384,8 +32254,8 @@ var init_completeDesign = __esm({
 
 // src/cli/workspace/projectSmoke.ts
 import { spawn as spawn8 } from "node:child_process";
-import { existsSync as existsSync27, readFileSync as readFileSync24 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync25 } from "node:fs";
+import { join as join27 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
   for (const name of SMOKE_SCRIPT_PRIORITY) {
@@ -31397,13 +32267,13 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (process.env["ZELARI_SMOKE"] === "0") {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
-  const pkgPath = join25(projectRoot, "package.json");
-  if (!existsSync27(pkgPath)) {
+  const pkgPath = join27(projectRoot, "package.json");
+  if (!existsSync29(pkgPath)) {
     return { ran: false, reason: "no package.json (skipped)" };
   }
   let scripts = {};
   try {
-    const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync25(pkgPath, "utf8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return { ran: false, reason: "package.json unreadable (skipped)" };
@@ -31491,8 +32361,8 @@ __export(postCouncilHook_exports, {
   runPostCouncilHook: () => runPostCouncilHook
 });
 import { spawn as spawn9 } from "node:child_process";
-import { existsSync as existsSync28, readFileSync as readFileSync25 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync30, readFileSync as readFileSync26 } from "node:fs";
+import { join as join28 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
     return {
@@ -31503,9 +32373,9 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (process.env["ZELARI_COMPLETE_DESIGN"] === "0") {
     return { ran: false, reason: "ZELARI_COMPLETE_DESIGN=0 (disabled)" };
   }
-  const planJsonPath2 = join26(ctx.rootDir, "plan.json");
-  const scriptPath = join26(ctx.projectRoot, "complete-design.mjs");
-  if (!existsSync28(planJsonPath2)) {
+  const planJsonPath2 = join28(ctx.rootDir, "plan.json");
+  const scriptPath = join28(ctx.projectRoot, "complete-design.mjs");
+  if (!existsSync30(planJsonPath2)) {
     return {
       ran: false,
       reason: ".zelari/plan.json missing (not design-phase)"
@@ -31513,7 +32383,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   }
   let phaseCount = 0;
   try {
-    const parsed = JSON.parse(readFileSync25(planJsonPath2, "utf8"));
+    const parsed = JSON.parse(readFileSync26(planJsonPath2, "utf8"));
     phaseCount = Array.isArray(parsed.phases) ? parsed.phases.length : 0;
   } catch {
     return { ran: false, reason: ".zelari/plan.json corrupt" };
@@ -31521,7 +32391,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (phaseCount === 0) {
     return { ran: false, reason: ".zelari/plan.json has no phases" };
   }
-  if (!existsSync28(scriptPath)) {
+  if (!existsSync30(scriptPath)) {
     try {
       const builtin = await runBuiltinCompleteDesign(ctx);
       return {
@@ -31744,10 +32614,10 @@ __export(councilFeedback_exports, {
 });
 import {
   promises as fs15,
-  existsSync as existsSync29,
-  readFileSync as readFileSync26,
-  writeFileSync as writeFileSync16,
-  mkdirSync as mkdirSync11
+  existsSync as existsSync31,
+  readFileSync as readFileSync27,
+  writeFileSync as writeFileSync17,
+  mkdirSync as mkdirSync12
 } from "node:fs";
 import path26 from "node:path";
 import os8 from "node:os";
@@ -31853,9 +32723,9 @@ var init_councilFeedback = __esm({
       }
       // --- persistence ---------------------------------------------------------
       load() {
-        if (!existsSync29(this.file)) return;
+        if (!existsSync31(this.file)) return;
         try {
-          const raw = readFileSync26(this.file, "utf-8");
+          const raw = readFileSync27(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -31866,8 +32736,8 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync11(path26.dirname(this.file), { recursive: true });
-        writeFileSync16(
+        mkdirSync12(path26.dirname(this.file), { recursive: true });
+        writeFileSync17(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
           { encoding: "utf-8", mode: 384 }
@@ -31933,7 +32803,7 @@ var init_buildPolicy = __esm({
 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 { tmpdir as tmpdir2 } from "node:os";
 import path27 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 async function git(cwd, args, env) {
@@ -31954,7 +32824,7 @@ async function isGitRepo(cwd) {
   return await gitSafe(cwd, ["rev-parse", "--is-inside-work-tree"]) === "true";
 }
 async function withTempIndex(fn) {
-  const dir = mkdtempSync(path27.join(tmpdir(), "zelari-ckpt-"));
+  const dir = mkdtempSync(path27.join(tmpdir2(), "zelari-ckpt-"));
   const indexFile = path27.join(dir, "index");
   try {
     return await fn(indexFile);
@@ -32828,7 +33698,7 @@ __export(prereqChecks_exports, {
   runPrereqChecks: () => runPrereqChecks
 });
 import { execSync, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
 function isWslBashPath2(p3) {
   if (!p3 || typeof p3 !== "string") return false;
@@ -32952,7 +33822,7 @@ function agentProbeEnv() {
 }
 function existsSyncSafe2(p3) {
   try {
-    return existsSync30(p3);
+    return existsSync32(p3);
   } catch {
     return false;
   }
@@ -33199,7 +34069,7 @@ var init_prereqChecks = __esm({
 });
 
 // src/cli/plugins/prefs.ts
-import { existsSync as existsSync31, readFileSync as readFileSync27, writeFileSync as writeFileSync17, mkdirSync as mkdirSync12 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync28, writeFileSync as writeFileSync18, mkdirSync as mkdirSync13 } from "node:fs";
 import path31 from "node:path";
 import os9 from "node:os";
 function getPluginPrefsPath() {
@@ -33208,8 +34078,8 @@ function getPluginPrefsPath() {
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
   try {
-    if (!existsSync31(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
-    const raw = readFileSync27(file2, "utf-8");
+    if (!existsSync33(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
+    const raw = readFileSync28(file2, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && parsed.dontAskAgain && typeof parsed.dontAskAgain === "object") {
       const clean = {};
@@ -33224,8 +34094,8 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync12(path31.dirname(file2), { recursive: true });
-  writeFileSync17(file2, JSON.stringify(prefs, null, 2), {
+  mkdirSync13(path31.dirname(file2), { recursive: true });
+  writeFileSync18(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
@@ -33260,7 +34130,7 @@ __export(registry_exports, {
   findPlugin: () => findPlugin,
   isBinaryOnPath: () => isBinaryOnPath
 });
-import { existsSync as existsSync32 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import path32 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
@@ -33277,7 +34147,7 @@ function isBinaryOnPath(bin, opts = {}) {
     return false;
   }
   const platform = opts.platform ?? process.platform;
-  const exists = opts.exists ?? existsSync32;
+  const exists = opts.exists ?? existsSync34;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
   const pathMod = platform === "win32" ? path32.win32 : path32.posix;
   const sep = platform === "win32" ? ";" : ":";
@@ -33404,19 +34274,6 @@ var init_registry2 = __esm({
         detect: detectPathBin(binForLspLanguage("python")),
         featureGate: "ZELARI_LSP",
         description: "Powers go_to_definition / find_references / hover_type / rename_symbol for Python."
-      },
-      {
-        // fff — high-performance codebase search MCP (fffind / ffgrep).
-        // Installed as a global CLI; wire it in ~/.zelari-code/mcp.json (see
-        // postInstallHint). Kill-switch: ZELARI_FFF=0.
-        id: "fff",
-        label: "fff (fast codebase search MCP)",
-        npmPackage: "fff-mcp",
-        installScope: "global",
-        detect: detectPathBin("fff-mcp"),
-        postInstallHint: 'Add to ~/.zelari-code/mcp.json: {"mcpServers":{"fff":{"command":"fff-mcp","args":[]}}} then restart. Prefer mcp_fff_* tools for search.',
-        featureGate: "ZELARI_FFF",
-        description: "Accelerates codebase search via fff MCP (fffind, ffgrep, fff-multi-grep) \u2014 faster and more token-efficient than plain grep."
       }
     ];
   }
@@ -33428,7 +34285,7 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync37, readFileSync as readFileSync31, readlinkSync, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync38, readFileSync as readFileSync31, readlinkSync, statSync as statSync6 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import path37 from "node:path";
@@ -33436,7 +34293,7 @@ function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
     const candidate = path37.join(dir, "package.json");
-    if (existsSync37(candidate)) {
+    if (existsSync38(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync31(candidate, "utf8"));
         if (pkg.name === "zelari-code") return dir;
@@ -33478,7 +34335,7 @@ function checkShim(pkgName) {
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
   const shimPath = path37.join(prefix, shimName);
-  if (!existsSync37(shimPath)) {
+  if (!existsSync38(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
          fix:  npm install -g ${pkgName}@latest --force`
@@ -33546,7 +34403,7 @@ function checkNode(pkg) {
 }
 function checkBundle() {
   const bundle = path37.join(packageRoot, "dist", "cli", "main.bundled.js");
-  if (!existsSync37(bundle)) {
+  if (!existsSync38(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
          fix:  npm run build:cli   (then reinstall or run via tsx)`
@@ -34443,7 +35300,8 @@ function StatusBar({
   cachedTokens = 0,
   cacheHitRate = 0,
   contextUsed = 0,
-  contextLimit = 0
+  contextLimit = 0,
+  todoSummary = null
 }) {
   const ctxLabel = contextLimit > 0 ? `${formatTokens(contextUsed)}/${formatTokens(contextLimit)}` : contextUsed > 0 ? formatTokens(contextUsed) : null;
   return /* @__PURE__ */ React6.createElement(Box5, { paddingX: 1, width: "100%", justifyContent: "space-between", gap: 2 }, /* @__PURE__ */ React6.createElement(Box5, { flexShrink: 2 }, /* @__PURE__ */ React6.createElement(Text6, { wrap: "truncate" }, /* @__PURE__ */ React6.createElement(Text6, { color: sessionActive ? "green" : "gray" }, sessionActive ? "\u25CF" : "\u25CB"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " "), /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: phase2 === "plan" ? "yellow" : "green" }, phase2 === "plan" ? "\u25C7 plan" : "\u25C6 build"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React6.createElement(
@@ -34453,7 +35311,7 @@ function StatusBar({
       color: mode === "council" ? "magenta" : mode === "zelari" ? "green" : "cyan"
     },
     mode === "council" ? "council" : mode === "zelari" ? "zelari" : "agent"
-  ), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, provider), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React6.createElement(Text6, null, model), cwd ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React6.createElement(Text6, { color: "blue" }, cwd)) : null)), /* @__PURE__ */ React6.createElement(Box5, { flexShrink: 1 }, /* @__PURE__ */ React6.createElement(Text6, { wrap: "truncate" }, busy && elapsedMs !== null ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Spinner, { color: "yellow" }), /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, " ", formatDuration(elapsedMs)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : lastMs !== null ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "last ", formatDuration(lastMs)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, queueCount > 0 ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { color: "magenta" }, "queue ", queueCount), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, ctxLabel ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { color: "cyan" }, ctxLabel), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, costUsd > 0 ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, formatCost(costUsd)), cachedTokens > 0 ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (", formatTokens(cachedTokens), " cached)") : null, cacheHitRate > 0 ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " ", Math.round(cacheHitRate * 100), "% hit") : null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "session ", sessionId))));
+  ), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, provider), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React6.createElement(Text6, null, model), cwd ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React6.createElement(Text6, { color: "blue" }, cwd)) : null)), /* @__PURE__ */ React6.createElement(Box5, { flexShrink: 1 }, /* @__PURE__ */ React6.createElement(Text6, { wrap: "truncate" }, busy && elapsedMs !== null ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Spinner, { color: "yellow" }), /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, " ", formatDuration(elapsedMs)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : lastMs !== null ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "last ", formatDuration(lastMs)), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, queueCount > 0 ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { color: "magenta" }, "queue ", queueCount), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, todoSummary ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, todoSummary), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, ctxLabel ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { color: "cyan" }, ctxLabel), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, costUsd > 0 ? /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, formatCost(costUsd)), cachedTokens > 0 ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " (", formatTokens(cachedTokens), " cached)") : null, cacheHitRate > 0 ? /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " ", Math.round(cacheHitRate * 100), "% hit") : null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \xB7 ")) : null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "session ", sessionId))));
 }
 
 // src/cli/components/SelectList.tsx
@@ -34887,6 +35745,7 @@ function useExecutionTimer(busy, tickMs = 1e3) {
 
 // src/cli/app.tsx
 init_paths();
+init_sessionTodos();
 
 // packages/core/dist/agents/skills/builtin/debugging.js
 init_skills();
@@ -37598,6 +38457,84 @@ async function resolveFailoverStream(options) {
 init_shellResolver();
 init_keyStore();
 init_toolRegistry();
+
+// src/cli/hooks/permissionPicker.ts
+init_toolPermissions();
+function createPermissionAskHandler(opts) {
+  const { setPicker: setPicker2, appendSystem: appendSystem2 } = opts;
+  return (req) => new Promise((resolve) => {
+    const cats = req.categories;
+    const catLabel = cats.length === 1 ? cats[0] : cats.join("+") || "action";
+    const title = `Allow tool "${req.toolName}"?`;
+    const detail = req.reason + (cats.length ? ` [${cats.join(", ")}]` : "");
+    appendSystem2?.(
+      `[permission] ${title}
+${detail}
+\u2192 Allow once \xB7 Always (tool) \xB7 Always (${catLabel}) \xB7 Deny`,
+      Date.now()
+    );
+    let settled = false;
+    const finish = (ok, note) => {
+      if (settled) return;
+      settled = true;
+      setPicker2(null);
+      if (note) appendSystem2?.(note, Date.now());
+      resolve(ok);
+    };
+    const items = [
+      { value: "allow", label: "Allow once" },
+      {
+        value: "always-tool",
+        label: `Allow always this session \xB7 tool ${req.toolName}`
+      }
+    ];
+    if (cats.length > 0) {
+      items.push({
+        value: "always-cat",
+        label: `Allow always this session \xB7 ${catLabel}`
+      });
+    }
+    items.push({ value: "deny", label: "Deny" });
+    setPicker2({
+      kind: "clarification",
+      title,
+      items,
+      onAnswer: (value) => {
+        const v = value.trim().toLowerCase();
+        if (v === "deny" || v.startsWith("deny")) {
+          finish(false);
+          return;
+        }
+        if (v === "always-tool" || v.includes("always") && v.includes("tool")) {
+          grantSessionTool(req.toolName);
+          finish(
+            true,
+            `[permission] Granted "${req.toolName}" for this session (tool).`
+          );
+          return;
+        }
+        if (v === "always-cat" || v.includes("always") && !v.includes("tool")) {
+          for (const c of cats) grantSessionCategory(c);
+          grantSessionTool(req.toolName);
+          finish(
+            true,
+            `[permission] Granted ${catLabel} (+ ${req.toolName}) for this session.`
+          );
+          return;
+        }
+        if (v === "allow" || v.startsWith("allow") || v === "yes" || v === "y" || v === "1") {
+          finish(true);
+          return;
+        }
+        finish(false);
+      },
+      onCancel: () => finish(false)
+    });
+  });
+}
+
+// src/cli/hooks/useChatTurn.ts
+init_toolPermissions();
 init_skills2();
 init_fileStateStore();
 init_dist();
@@ -37806,39 +38743,69 @@ function resolveContextLimit() {
     max: 2e6
   });
 }
-function applyBudgetPolicy(history2, phase2, opts) {
+function phaseKnobs(phase2) {
+  return {
+    historyTurns: phase2 === "plan" ? envNumber(process.env.ZELARI_HISTORY_TURNS, { default: 8, min: 0 }) : envNumber(process.env.ZELARI_HISTORY_TURNS, { default: 6, min: 0 }),
+    maxToolLoopIterations: phase2 === "plan" ? envNumber(process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS, { default: 60, min: 1 }) : envNumber(process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS, {
+      default: 120,
+      min: 1
+    })
+  };
+}
+function occupancyOf(hist, sessionExtra, contextLimit) {
+  const estimated = estimateHistoryTokens(hist);
+  const occupancy = Math.min(1, (estimated + sessionExtra) / contextLimit);
+  return { estimated, occupancy };
+}
+async function applyBudgetPolicyAsync(history2, phase2, opts) {
   const contextLimit = resolveContextLimit();
+  const sessionExtra = opts?.sessionTokens ?? 0;
   const warnings = [];
-  let historyTurns = phase2 === "plan" ? envNumber(process.env.ZELARI_HISTORY_TURNS, { default: 8, min: 0 }) : envNumber(process.env.ZELARI_HISTORY_TURNS, { default: 6, min: 0 });
-  let maxToolLoopIterations = phase2 === "plan" ? envNumber(process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS, { default: 60, min: 1 }) : envNumber(process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS, { default: 120, min: 1 });
+  let { historyTurns, maxToolLoopIterations } = phaseKnobs(phase2);
   let hist = history2;
-  let estimated = estimateHistoryTokens(hist);
-  const sessionExtra = opts?.sessionTokens ?? 0;
-  let occupancy = Math.min(1, (estimated + sessionExtra) / contextLimit);
+  let { estimated, occupancy } = occupancyOf(hist, sessionExtra, contextLimit);
+  let compactSummary = "";
+  let messagesRemoved = 0;
   if (occupancy >= 0.7 && occupancy < 0.85) {
     warnings.push(
       `[budget] context ~${Math.round(occupancy * 100)}% full (${estimated + sessionExtra}/${contextLimit} tok est.) \u2014 consider /compact or shorter replies.`
     );
   }
+  const fold = (r, label, forcedTurns) => {
+    hist = r.messages;
+    if (r.compacted) {
+      messagesRemoved += r.messagesRemoved;
+      if (r.summary) compactSummary = r.summary;
+    }
+    ({ estimated, occupancy } = occupancyOf(hist, sessionExtra, contextLimit));
+    warnings.push(
+      `[budget] ${label} at ${forcedTurns === 2 ? "95%" : "85%"} \u2014 kept ~${forcedTurns} turns (${estimated} tok history est.` + (r.messagesRemoved ? `, removed ${r.messagesRemoved} msgs` : "") + `).`
+    );
+  };
   if (occupancy >= 0.85) {
     const forcedTurns = Math.max(1, Math.floor(historyTurns / 2));
     historyTurns = forcedTurns;
-    hist = compactHistory(hist, { maxMessages: forcedTurns * 4 });
-    estimated = estimateHistoryTokens(hist);
-    occupancy = Math.min(1, (estimated + sessionExtra) / contextLimit);
-    warnings.push(
-      `[budget] auto-compact at 85% \u2014 kept ~${forcedTurns} turns (${estimated} tok history est.).`
+    maxToolLoopIterations = Math.min(
+      maxToolLoopIterations,
+      phase2 === "plan" ? 24 : 40
     );
-    maxToolLoopIterations = Math.min(maxToolLoopIterations, phase2 === "plan" ? 24 : 40);
+    const r = await compactHistoryAsync(hist, {
+      maxMessages: forcedTurns * 4,
+      signal: opts?.signal
+    });
+    const label = r.summary.includes("\xB7 llm") ? "llm-compact" : "auto-compact";
+    fold(r, label, forcedTurns);
   }
   if (occupancy >= 0.95) {
-    hist = compactHistory(hist, { maxMessages: 8 });
-    estimated = estimateHistoryTokens(hist);
-    occupancy = Math.min(1, (estimated + sessionExtra) / contextLimit);
+    const hard = await compactHistoryAsync(hist, {
+      maxMessages: 8,
+      signal: opts?.signal
+    });
+    fold(hard, hard.summary.includes("\xB7 llm") ? "llm-compact" : "auto-compact", 2);
     historyTurns = 2;
     maxToolLoopIterations = Math.min(maxToolLoopIterations, 16);
     warnings.push(
-      `[budget] HARD context pressure (\u226595%) \u2014 history cut to last ~2 turns. Prefer /clear or a new session if quality drops.`
+      `[budget] HARD context pressure (\u226595%) \u2014 prefer /clear or a new session if quality drops.`
     );
   }
   return {
@@ -37848,7 +38815,9 @@ function applyBudgetPolicy(history2, phase2, opts) {
     historyTurns,
     estimatedHistoryTokens: estimated,
     contextLimit,
-    occupancy
+    occupancy,
+    compactSummary: compactSummary || void 0,
+    messagesRemoved: messagesRemoved || void 0
   };
 }
 
@@ -37865,7 +38834,7 @@ function useChatTurn(params) {
     setSessionStats,
     setLive,
     liveRef,
-    setPicker
+    setPicker: setPicker2
   } = params;
   const harnessRef = useRef4(null);
   const [queueCount, setQueueCount] = useState6(0);
@@ -37881,7 +38850,7 @@ function useChatTurn(params) {
       let turnSucceeded = false;
       try {
         compactInPlace();
-        const budget = applyBudgetPolicy(getHistory(), getPhase());
+        const budget = await applyBudgetPolicyAsync(getHistory(), getPhase());
         setHistory(budget.history);
         for (const w of budget.warnings) {
           appendSystem(setMessages, w, Date.now());
@@ -37901,7 +38870,7 @@ function useChatTurn(params) {
         }
         setBusy(true);
         const workPhase = getPhase();
-        const onAskUser = setPicker ? (req) => new Promise((resolve) => {
+        const onAskUser = setPicker2 ? (req) => new Promise((resolve) => {
           const choices = req.choices ?? [];
           if (choices.length < 2) {
             resolve(null);
@@ -37924,10 +38893,10 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           const finish = (value) => {
             if (settled) return;
             settled = true;
-            setPicker(null);
+            setPicker2(null);
             resolve(value);
           };
-          setPicker({
+          setPicker2({
             kind: "clarification",
             title: req.question,
             items: choices.map((c) => ({ value: c, label: c })),
@@ -37935,9 +38904,15 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
             onCancel: () => finish(null)
           });
         }) : void 0;
+        const onPermissionAsk = setPicker2 ? createPermissionAskHandler({
+          setPicker: setPicker2,
+          appendSystem: (msg, at) => appendSystem(setMessages, msg, at ?? Date.now())
+        }) : void 0;
         const { registry: toolRegistry } = createBuiltinToolRegistry({
           planMode: workPhase === "plan",
-          onAskUser
+          onAskUser,
+          onPermissionAsk,
+          permissionPolicy: defaultPermissionPolicy()
         });
         const baseProviderStream = openaiCompatibleProvider(envConfig);
         const failoverResolution = await resolveFailoverStream({
@@ -38334,8 +39309,8 @@ ${choiceLines}` + (clar.context ? `
 _(${clar.context})_` : "") + "\n\u2192 scegli dalla lista oppure digita la risposta e invia.",
                   Date.now()
                 );
-                if (setPicker) {
-                  setPicker({
+                if (setPicker2) {
+                  setPicker2({
                     kind: "clarification",
                     title: clar.question,
                     items: clar.choices.map((c) => ({ value: c, label: c })),
@@ -38406,7 +39381,7 @@ _(${clar.context})_` : "") + "\n\u2192 scegli dalla lista oppure digita la rispo
         setQueueCount,
         setLive,
         liveRef,
-        setPicker
+        setPicker: setPicker2
       });
     },
     [
@@ -38419,7 +39394,7 @@ _(${clar.context})_` : "") + "\n\u2192 scegli dalla lista oppure digita la rispo
       setQueueCount,
       setLive,
       liveRef,
-      setPicker
+      setPicker2
     ]
   );
   const pendingZelariRef = useRef4(null);
@@ -38473,7 +39448,7 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
     setBusy,
     setLive,
     liveRef,
-    setPicker
+    setPicker: setPicker2
   } = deps;
   const useLiveModel = !!(setLive && liveRef);
   const envConfig = await providerFromEnv();
@@ -38488,7 +39463,7 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
   }
   setBusy(true);
   compactInPlace();
-  const councilBudget = applyBudgetPolicy(getHistory(), getPhase());
+  const councilBudget = await applyBudgetPolicyAsync(getHistory(), getPhase());
   setHistory(councilBudget.history);
   for (const w of councilBudget.warnings) {
     appendSystem(setMessages, w, Date.now());
@@ -38508,7 +39483,7 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
   const { composeProjectContext: composeProjectContext2 } = await Promise.resolve().then(() => (init_composeContext(), composeContext_exports));
   const { FeedbackStore: FeedbackStore2 } = await Promise.resolve().then(() => (init_councilFeedback(), councilFeedback_exports));
   const workPhase = getPhase();
-  const onAskUserCouncil = setPicker ? (req) => new Promise((resolve) => {
+  const onAskUserCouncil = setPicker2 ? (req) => new Promise((resolve) => {
     const choices = req.choices ?? [];
     if (choices.length < 2) {
       resolve(null);
@@ -38531,10 +39506,10 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
     const finish = (value) => {
       if (settled) return;
       settled = true;
-      setPicker(null);
+      setPicker2(null);
       resolve(value);
     };
-    setPicker({
+    setPicker2({
       kind: "clarification",
       title: req.question,
       items: choices.map((c) => ({ value: c, label: c })),
@@ -38557,9 +39532,15 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
       );
     }
   }
+  const onPermissionAskCouncil = setPicker2 ? createPermissionAskHandler({
+    setPicker: setPicker2,
+    appendSystem: (msg, at) => appendSystem(setMessages, msg, at ?? Date.now())
+  }) : void 0;
   const { registry: councilToolRegistry } = createBuiltinToolRegistry({
     planMode: workPhase === "plan" || softGatedToDesign,
-    onAskUser: onAskUserCouncil
+    onAskUser: onAskUserCouncil,
+    onPermissionAsk: onPermissionAskCouncil,
+    permissionPolicy: defaultPermissionPolicy()
   });
   const workspaceCtx = createWorkspaceContext2();
   const workspaceReg = createWorkspaceToolRegistry2(workspaceCtx);
@@ -38655,7 +39636,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
         appendSystem(setMessages, message, Date.now());
       },
       // v1.8.0: pause council when a member asks a structured question.
-      onClarification: setPicker ? (req) => new Promise((resolve) => {
+      onClarification: setPicker2 ? (req) => new Promise((resolve) => {
         const choices = req.choices ?? [];
         if (choices.length < 2) {
           resolve(null);
@@ -38678,10 +39659,10 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
         const finish = (value) => {
           if (settled) return;
           settled = true;
-          setPicker(null);
+          setPicker2(null);
           resolve(value);
         };
-        setPicker({
+        setPicker2({
           kind: "clarification",
           title: req.question,
           items: choices.map((c) => ({ value: c, label: c })),
@@ -39127,8 +40108,14 @@ async function runZelariMissionInTui(userMessage, deps, emit) {
           );
           return { completionOk: false, ran: false };
         }
+        const onPermissionAskZelari = setPicker ? createPermissionAskHandler({
+          setPicker,
+          appendSystem: (msg, at) => appendSystem(setMessages2, msg, at ?? Date.now())
+        }) : void 0;
         const { registry: toolRegistry } = createBuiltinToolRegistry({
-          planMode: false
+          planMode: false,
+          onPermissionAsk: onPermissionAskZelari,
+          permissionPolicy: defaultPermissionPolicy()
         });
         try {
           const { registerMcpTools: registerMcpTools2 } = await Promise.resolve().then(() => (init_mcpManager(), mcpManager_exports));
@@ -40544,7 +41531,7 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs19, existsSync as existsSync33, readFileSync as readFileSync28, writeFileSync as writeFileSync18, mkdirSync as mkdirSync13, statSync as statSync4, rmSync as rmSync2 } from "node:fs";
+import { promises as fs19, existsSync as existsSync35, readFileSync as readFileSync29, writeFileSync as writeFileSync19, mkdirSync as mkdirSync14, statSync as statSync4, rmSync as rmSync2 } from "node:fs";
 import path34 from "node:path";
 import os11 from "node:os";
 var META_FILENAME = "meta.json";
@@ -40566,11 +41553,11 @@ function sessionsPathFor(name, baseDir) {
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
-  if (!existsSync33(metaPath)) {
+  if (!existsSync35(metaPath)) {
     throw new BranchNotFoundError(`Branch "${name}" not found`);
   }
   try {
-    const raw = readFileSync28(metaPath, "utf-8");
+    const raw = readFileSync29(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`);
@@ -40587,8 +41574,8 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync13(path34.dirname(metaPath), { recursive: true });
-  writeFileSync18(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
+  mkdirSync14(path34.dirname(metaPath), { recursive: true });
+  writeFileSync19(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
@@ -40626,7 +41613,7 @@ var SessionNotFoundError = class extends Error {
 };
 function branchExists(name, baseDir = getBranchesBaseDir()) {
   const bp = branchPathFor(name, baseDir);
-  return existsSync33(bp) && existsSync33(metaPathFor(name, baseDir));
+  return existsSync35(bp) && existsSync35(metaPathFor(name, baseDir));
 }
 async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(), sessionsBaseDir = getSessionsBaseDir()) {
   if (!name || name.trim().length === 0) {
@@ -40639,12 +41626,12 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
     throw new BranchAlreadyExistsError(name);
   }
   const sourcePath = path34.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
-  if (!existsSync33(sourcePath)) {
+  if (!existsSync35(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
-  mkdirSync13(branchSessionsPath, { recursive: true });
+  mkdirSync14(branchSessionsPath, { recursive: true });
   const destPath = path34.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs19.copyFile(sourcePath, destPath);
   const meta3 = {
@@ -40672,7 +41659,7 @@ async function listBranches(baseDir = getBranchesBaseDir()) {
   const results = [];
   for (const entry of entries) {
     const metaPath = metaPathFor(entry, baseDir);
-    if (!existsSync33(metaPath)) continue;
+    if (!existsSync35(metaPath)) continue;
     try {
       const meta3 = readBranchMeta(entry, baseDir);
       const sessionCount = await countSessions(entry, baseDir);
@@ -41208,7 +42195,7 @@ import path36 from "node:path";
 import os12 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs21, existsSync as existsSync34, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync14 } from "node:fs";
+import { promises as fs21, existsSync as existsSync36, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync15 } from "node:fs";
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
@@ -41960,7 +42947,7 @@ function App() {
   const [clearEpoch, setClearEpoch] = useState8(0);
   const [mode, setMode] = useState8("agent");
   const [phase2, setPhaseUi] = useState8("build");
-  const [picker, setPicker] = useState8(null);
+  const [picker, setPicker2] = useState8(null);
   const activeProviderSpec = getActiveProvider();
   const activeModel = providerConfig.modelByProvider[activeProviderSpec.id];
   const session = useSession();
@@ -42001,7 +42988,7 @@ function App() {
     // v1.6.0: lets dispatchPrompt open a SelectList when the agent poses a
     // ---QUESTION--- clarifying block, so the user picks from the offered
     // choices instead of typing (and the answer binds via rolling history).
-    setPicker
+    setPicker: setPicker2
   });
   const onNewSession = useCallback5((id) => {
     void session.writerRef.current?.close();
@@ -42035,7 +43022,7 @@ function App() {
     dispatchZelariPrompt: chatTurn.dispatchZelariPrompt,
     mode,
     setMode,
-    openPicker: setPicker,
+    openPicker: setPicker2,
     onNewSession,
     onExit,
     onClear,
@@ -42044,7 +43031,7 @@ function App() {
   });
   const onPickerSelect = useCallback5((value) => {
     if (!picker) return;
-    setPicker(null);
+    setPicker2(null);
     if (picker.kind === "clarification") {
       picker.onAnswer?.(value);
       return;
@@ -42056,7 +43043,7 @@ function App() {
     if (picker?.kind === "clarification") {
       picker.onCancel?.();
     }
-    setPicker(null);
+    setPicker2(null);
   }, [picker]);
   const banner = useMemo(() => {
     return {
@@ -42118,7 +43105,8 @@ function App() {
       cachedTokens: sessionStats.cachedTokens,
       cacheHitRate: sessionStats.cacheHitRate || 0,
       contextUsed: sessionStats.contextTokens || 0,
-      contextLimit: Number(process.env.ZELARI_CONTEXT_LIMIT) || 2e5
+      contextLimit: Number(process.env.ZELARI_CONTEXT_LIMIT) || 2e5,
+      todoSummary: formatTodoStatusSummary()
     }
   )), sidebarOpen && /* @__PURE__ */ React10.createElement(Sidebar, { version: VERSION, changes: gitChanges, rows: size.rows })));
 }
@@ -42434,9 +43422,9 @@ function ContinueKey({ onContinue }) {
 init_providerConfig();
 
 // src/cli/wizard/firstRun.ts
-import { existsSync as existsSync35 } from "node:fs";
+import { existsSync as existsSync37 } from "node:fs";
 function shouldRunWizard(input) {
-  const exists = input.exists ?? existsSync35;
+  const exists = input.exists ?? existsSync37;
   if (input.hasResetConfigFlag) {
     return { shouldRun: true, reason: "--reset-config flag forced wizard" };
   }
@@ -42721,7 +43709,7 @@ init_keyStore();
 init_providerConfig();
 init_openai_compatible();
 init_phase();
-import { readFileSync as readFileSync29 } from "node:fs";
+import { readFileSync as readFileSync30 } from "node:fs";
 function parseHeadlessFlags(argv) {
   if (!argv.includes("--headless")) {
     return { options: null };
@@ -42789,7 +43777,7 @@ function parseHeadlessFlags(argv) {
         let raw = null;
         if (arg === "--history-file") {
           try {
-            raw = readFileSync29(next, "utf-8");
+            raw = readFileSync30(next, "utf-8");
           } catch {
             raw = null;
           }
@@ -43019,7 +44007,15 @@ async function registerHeadlessMcp(toolRegistry, opts) {
 async function runHeadlessSingle(opts, provider, model, providerStream) {
   const sessionId = crypto.randomUUID();
   const { registry: toolRegistry } = createBuiltinToolRegistry({
-    planMode: planModeFromOpts(opts)
+    planMode: planModeFromOpts(opts),
+    permissionPolicy: {
+      read: "allow",
+      write: "allow",
+      execute: "allow",
+      network: "allow",
+      ui: "allow",
+      auto: true
+    }
   });
   await registerHeadlessMcp(toolRegistry, opts);
   const tools = toolRegistry.toOpenAITools().map((t) => ({
@@ -43324,7 +44320,17 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   return pass.exitCode;
 }
 async function buildCouncilToolRegistry(planMode, opts) {
-  const { registry: toolRegistry } = createBuiltinToolRegistry({ planMode });
+  const { registry: toolRegistry } = createBuiltinToolRegistry({
+    planMode,
+    permissionPolicy: {
+      read: "allow",
+      write: "allow",
+      execute: "allow",
+      network: "allow",
+      ui: "allow",
+      auto: true
+    }
+  });
   const { createWorkspaceContext: createWorkspaceContext2, createWorkspaceStubs: createWorkspaceStubs2 } = await Promise.resolve().then(() => (init_stubs(), stubs_exports));
   const { createWorkspaceToolRegistry: createWorkspaceToolRegistry2 } = await Promise.resolve().then(() => (init_toolRegistry2(), toolRegistry_exports2));
   const { setWorkspaceStubs: setWorkspaceStubs2 } = await Promise.resolve().then(() => (init_skills2(), skills_exports));
@@ -43646,7 +44652,15 @@ ${ragContext}` : slicePrompt;
         const { loadDurableContext: loadDurableContext2 } = await Promise.resolve().then(() => (init_loadDurableContext(), loadDurableContext_exports));
         const { detectDegradedRun: detectDegradedRun2 } = await Promise.resolve().then(() => (init_council(), council_exports));
         const { registry: agentRegistry } = createBuiltinToolRegistry2({
-          planMode: false
+          planMode: false,
+          permissionPolicy: {
+            read: "allow",
+            write: "allow",
+            execute: "allow",
+            network: "allow",
+            ui: "allow",
+            auto: true
+          }
         });
         await registerHeadlessMcp(agentRegistry, opts);
         const durableState = await loadDurableContext2(projectRoot);
@@ -44074,118 +45088,8 @@ async function runPluginsInstall(argv) {
   return 0;
 }
 
-// src/cli/skillsMd.ts
-init_skills2();
-import { existsSync as existsSync36, readdirSync as readdirSync5, readFileSync as readFileSync30 } from "node:fs";
-import { join as join29 } from "node:path";
-import { homedir as homedir8 } from "node:os";
-var CODING_CATEGORIES = /* @__PURE__ */ new Set([
-  "plan",
-  "refactor",
-  "debug",
-  "review",
-  "test",
-  "docs",
-  "ops",
-  "git",
-  "db",
-  "maint"
-]);
-function skillMdSearchDirs(projectRoot = process.cwd()) {
-  return [
-    join29(projectRoot, ".zelari", "skills"),
-    join29(projectRoot, ".claude", "skills"),
-    join29(projectRoot, ".opencode", "skills"),
-    join29(homedir8(), ".zelari-code", "skills")
-  ];
-}
-function parseSkillMd(content, sourcePath) {
-  const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(content);
-  if (!fmMatch) return null;
-  const [, fmRaw = "", body = ""] = fmMatch;
-  const fields = {};
-  for (const line of fmRaw.split(/\r?\n/)) {
-    const kv = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(line);
-    if (!kv) continue;
-    const key = (kv[1] ?? "").toLowerCase();
-    let value = (kv[2] ?? "").trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    fields[key] = value;
-  }
-  const name = (fields["name"] ?? "").trim().toLowerCase();
-  const description = (fields["description"] ?? "").trim();
-  if (!name || !description) return null;
-  if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) return null;
-  const rawTools = fields["tools"] ?? fields["requiredtools"] ?? fields["required_tools"] ?? "";
-  const requiredTools = rawTools.replace(/^\[|\]$/g, "").split(",").map((t) => t.trim().replace(/^["']|["']$/g, "")).filter((t) => t.length > 0);
-  const rawCategory = (fields["category"] ?? "").trim().toLowerCase();
-  const category = CODING_CATEGORIES.has(rawCategory) ? rawCategory : "maint";
-  const rawCost = (fields["cost"] ?? fields["estimatedcost"] ?? "").trim().toLowerCase();
-  const estimatedCost = rawCost === "low" || rawCost === "high" ? rawCost : "medium";
-  const trimmedBody = body.trim();
-  if (!trimmedBody) return null;
-  return { name, description, category, requiredTools, estimatedCost, body: trimmedBody, sourcePath };
-}
-function toCodingSkillDefinition(parsed) {
-  return {
-    id: parsed.name,
-    name: parsed.name,
-    description: parsed.description,
-    version: "1.0.0",
-    category: parsed.category,
-    systemPromptFragment: parsed.body,
-    requiredTools: parsed.requiredTools,
-    enabledByDefault: true,
-    builtin: false,
-    requires: [],
-    examples: [],
-    triggers: [],
-    antiPatterns: [],
-    requiredRoles: [],
-    estimatedCost: parsed.estimatedCost,
-    outputSchema: "string",
-    relatedSkills: [],
-    tags: ["user", "skill-md"]
-  };
-}
-function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
-  const summary = { loaded: [], skipped: [] };
-  const seen = new Set(options.existingIds ?? []);
-  for (const dir of skillMdSearchDirs(projectRoot)) {
-    if (!existsSync36(dir)) continue;
-    let entries;
-    try {
-      entries = readdirSync5(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const skillPath = join29(dir, entry, "SKILL.md");
-      if (!existsSync36(skillPath)) continue;
-      try {
-        const parsed = parseSkillMd(readFileSync30(skillPath, "utf8"), skillPath);
-        if (!parsed) {
-          summary.skipped.push({ path: skillPath, reason: "missing/invalid frontmatter (name, description) or empty body" });
-          continue;
-        }
-        if (seen.has(parsed.name)) {
-          summary.skipped.push({ path: skillPath, reason: `name "${parsed.name}" already registered (earlier dir or builtin wins)` });
-          continue;
-        }
-        registerCodingSkill(toCodingSkillDefinition(parsed));
-        seen.add(parsed.name);
-        summary.loaded.push(parsed.name);
-      } catch (err) {
-        summary.skipped.push({ path: skillPath, reason: err instanceof Error ? err.message : String(err) });
-      }
-    }
-  }
-  return summary;
-}
-
 // src/cli/main.ts
+init_skillsMd();
 init_skills2();
 init_updater();
 init_mcpConfigIo();
@@ -44204,8 +45108,8 @@ function runPreflight() {
     mode: "preflight"
   });
   for (const w of warnings) {
-    const oneLine = w.message.replace(/\s*\n\s*/g, " ").replace(/\s+/g, " ").trim();
-    const short = oneLine.length > 120 ? `${oneLine.slice(0, 117)}\u2026` : oneLine;
+    const oneLine2 = w.message.replace(/\s*\n\s*/g, " ").replace(/\s+/g, " ").trim();
+    const short = oneLine2.length > 120 ? `${oneLine2.slice(0, 117)}\u2026` : oneLine2;
     console.error(`\x1B[33m[zelari-code] \u26A0 ${w.tool}: ${short}\x1B[0m`);
   }
   if (hasCriticalFail) {