zelari-code 1.42.0 → 1.43.0

package/dist/cli/main.bundled.js

@@ -21063,6 +21063,12 @@ function isBrainMemberCostEvent(e) {
 function isBrainCouncilModeEvent(e) {
   return e.type === "council_mode";
 }
+function isBrainTaskUpdateEvent(e) {
+  return e.type === "task_update";
+}
+function isBrainTaskSnapshotEvent(e) {
+  return e.type === "task_snapshot";
+}
 function createBrainEvent(type, sessionId, data) {
   return {
     type,
@@ -28073,6 +28079,8 @@ __export(dist_exports, {
   isBrainMessageStartEvent: () => isBrainMessageStartEvent,
   isBrainQueueUpdateEvent: () => isBrainQueueUpdateEvent,
   isBrainSessionCompactedEvent: () => isBrainSessionCompactedEvent,
+  isBrainTaskSnapshotEvent: () => isBrainTaskSnapshotEvent,
+  isBrainTaskUpdateEvent: () => isBrainTaskUpdateEvent,
   isBrainThinkingDeltaEvent: () => isBrainThinkingDeltaEvent,
   isBrainToolExecutionEndEvent: () => isBrainToolExecutionEndEvent,
   isBrainToolExecutionStartEvent: () => isBrainToolExecutionStartEvent,
@@ -31026,6 +31034,771 @@ var init_todoTools = __esm({
   }
 });
 
+// src/cli/workspace/paths.ts
+import {
+  mkdirSync as mkdirSync10,
+  writeFileSync as writeFileSync12,
+  existsSync as existsSync17,
+  accessSync,
+  constants,
+  realpathSync
+} from "node:fs";
+import { join as join13, basename } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { createHash as createHash4 } from "node:crypto";
+function resolveWorkspaceRoot(projectRoot = process.cwd()) {
+  const candidates = [
+    join13(projectRoot, ".zelari"),
+    join13(homedir5(), ".zelari-code", "workspace", hashProject(projectRoot))
+  ];
+  for (const candidate of candidates) {
+    if (isWritableDir(projectRoot) || candidate !== candidates[0]) {
+      ensureWorkspaceDir(candidate);
+      return candidate;
+    }
+  }
+  ensureWorkspaceDir(candidates[0]);
+  return candidates[0];
+}
+function hashProject(projectPath) {
+  return createHash4("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+}
+function isWritableDir(dir) {
+  try {
+    if (!existsSync17(dir)) return false;
+    accessSync(dir, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureWorkspaceDir(workspaceDir) {
+  mkdirSync10(workspaceDir, { recursive: true });
+  if (workspaceDir.endsWith("/.zelari") && existsSync17(join13(workspaceDir, "..", ".git"))) {
+    const gitignorePath = join13(workspaceDir, ".gitignore");
+    if (!existsSync17(gitignorePath)) {
+      writeFileSync12(gitignorePath, "*\n!.gitignore\n");
+    }
+  }
+}
+function workspaceFile(rootDir, kind) {
+  switch (kind) {
+    case "plan":
+      return join13(rootDir, "plan.md");
+    case "risks":
+      return join13(rootDir, "risks.md");
+    case "index":
+      return join13(rootDir, "workspace.json");
+  }
+}
+function workspaceArtifact(rootDir, subdir, slug) {
+  return join13(rootDir, subdir, `${slug}.md`);
+}
+function projectName(projectRoot = process.cwd()) {
+  return basename(realpathSync(projectRoot));
+}
+var init_paths2 = __esm({
+  "src/cli/workspace/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/workspace/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  Storage: () => Storage,
+  parseFrontmatter: () => parseFrontmatter,
+  parseYaml: () => parseYaml,
+  serializeFrontmatter: () => serializeFrontmatter,
+  serializeYaml: () => serializeYaml,
+  workspaceMutex: () => workspaceMutex
+});
+import {
+  readFileSync as readFileSync16,
+  writeFileSync as writeFileSync13,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync11,
+  readdirSync as readdirSync4,
+  renameSync as renameSync2
+} from "node:fs";
+import { dirname as dirname2, join as join14 } from "node:path";
+function parseFrontmatter(md) {
+  const m = FRONTMATTER_RE.exec(md);
+  if (!m) return { meta: {}, body: md };
+  const meta3 = parseYaml(m[1]);
+  const body = m[2];
+  return { meta: meta3, body };
+}
+function serializeFrontmatter(meta3, body) {
+  const yamlStr = serializeYaml(meta3);
+  return `---
+${yamlStr}
+---
+${body}`;
+}
+function parseYaml(input) {
+  const lines = input.split(/\r?\n/);
+  const ctx = { lines, i: 0 };
+  return parseNode(ctx, 0);
+}
+function parseNode(ctx, indent) {
+  while (ctx.i < ctx.lines.length) {
+    const line2 = ctx.lines[ctx.i];
+    if (line2.trim() === "" || line2.trim().startsWith("#")) {
+      ctx.i++;
+      continue;
+    }
+    break;
+  }
+  if (ctx.i >= ctx.lines.length) return null;
+  const line = ctx.lines[ctx.i];
+  const lineIndent = countIndent(line);
+  if (/^\s*-\s+/.test(line)) {
+    return parseBlockSequence(ctx, indent);
+  }
+  if (/^\s*\[.*\]\s*$/.test(line)) {
+    const flow = line.trim().replace(/^\[/, "").replace(/\]$/, "");
+    return parseFlowSequence(flow);
+  }
+  if (/^\s*\{.*\}\s*$/.test(line)) {
+    const flow = line.trim().replace(/^\{/, "").replace(/\}$/, "");
+    return parseFlowMap(flow);
+  }
+  return parseBlockMap(ctx, indent);
+}
+function parseBlockMap(ctx, indent) {
+  const out = {};
+  while (ctx.i < ctx.lines.length) {
+    const line = ctx.lines[ctx.i];
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      ctx.i++;
+      continue;
+    }
+    const lineIndent = countIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) {
+      ctx.i++;
+      continue;
+    }
+    const m = /^([^:]+):\s*(.*)$/.exec(line);
+    if (!m) {
+      ctx.i++;
+      continue;
+    }
+    const key = m[1].trim();
+    const valuePart = m[2].trim();
+    if (valuePart === "" || valuePart === "|" || valuePart === ">") {
+      ctx.i++;
+      const nested = parseNode(ctx, indent + 2);
+      out[key] = nested;
+    } else {
+      if (valuePart.startsWith("[")) {
+        out[key] = parseFlowSequence(stripFlow(valuePart, "[", "]"));
+      } else if (valuePart.startsWith("{")) {
+        out[key] = parseFlowMap(stripFlow(valuePart, "{", "}"));
+      } else {
+        out[key] = parseScalar(valuePart);
+      }
+      ctx.i++;
+    }
+  }
+  return out;
+}
+function parseBlockSequence(ctx, indent) {
+  const out = [];
+  while (ctx.i < ctx.lines.length) {
+    const line = ctx.lines[ctx.i];
+    if (line.trim() === "") {
+      ctx.i++;
+      continue;
+    }
+    const lineIndent = countIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) break;
+    const m = /^-\s*(.*)$/.exec(line);
+    if (!m) break;
+    const rest = m[1];
+    if (rest === "") {
+      ctx.i++;
+      out.push(parseNode(ctx, indent + 2));
+    } else if (rest.startsWith("[") || rest.startsWith("{")) {
+      let buffer = rest;
+      let depthSq = (buffer.match(/\[/g) || []).length - (buffer.match(/\]/g) || []).length;
+      let depthCu = (buffer.match(/\{/g) || []).length - (buffer.match(/\}/g) || []).length;
+      while ((depthSq > 0 || depthCu > 0) && ctx.i + 1 < ctx.lines.length) {
+        ctx.i++;
+        const next = ctx.lines[ctx.i].trim();
+        buffer += " " + next;
+        depthSq = (buffer.match(/\[/g) || []).length - (buffer.match(/\]/g) || []).length;
+        depthCu = (buffer.match(/\{/g) || []).length - (buffer.match(/\}/g) || []).length;
+      }
+      if (buffer.startsWith("[")) {
+        out.push(parseFlowSequence(buffer.slice(1).replace(/\]$/, "")));
+      } else {
+        out.push(parseFlowMap(buffer.slice(1).replace(/\}$/, "")));
+      }
+      ctx.i++;
+    } else if (rest.includes(":")) {
+      ctx.i++;
+      const mapCtx = { lines: [" ".repeat(indent + 2) + rest, ...ctx.lines.slice(ctx.i)], i: 0 };
+      const val = parseBlockMap(mapCtx, indent + 2);
+      ctx.i += mapCtx.i - 1;
+      out.push(val);
+    } else {
+      out.push(parseScalar(rest));
+      ctx.i++;
+    }
+  }
+  return out;
+}
+function parseFlowSequence(input) {
+  const parts = splitFlow(input);
+  return parts.map((p3) => {
+    const trimmed = p3.trim();
+    if (trimmed.startsWith("{")) {
+      return parseFlowMap(stripFlow(trimmed, "{", "}"));
+    }
+    return parseScalar(trimmed);
+  });
+}
+function stripFlow(s, open, close) {
+  let out = s.trim();
+  if (out.startsWith(open)) out = out.slice(1);
+  if (out.endsWith(close)) out = out.slice(0, -1);
+  return out;
+}
+function parseFlowMap(input) {
+  const parts = splitFlow(input);
+  const out = {};
+  for (const p3 of parts) {
+    const colonIdx = p3.indexOf(":");
+    if (colonIdx < 0) continue;
+    const key = p3.slice(0, colonIdx).trim();
+    const value = p3.slice(colonIdx + 1).trim();
+    out[key] = parseScalar(value);
+  }
+  return out;
+}
+function splitFlow(input) {
+  const out = [];
+  let depthSq = 0, depthCu = 0, depthQu = 0;
+  let buffer = "";
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (c === '"' || c === "'") {
+      depthQu = depthQu === 0 ? depthQu + 1 : 0;
+      buffer += c;
+    } else if (depthQu === 0) {
+      if (c === "[") depthSq++;
+      else if (c === "]") depthSq--;
+      else if (c === "{") depthCu++;
+      else if (c === "}") depthCu--;
+      else if (c === "," && depthSq === 0 && depthCu === 0) {
+        out.push(buffer);
+        buffer = "";
+        continue;
+      }
+      buffer += c;
+    } else {
+      buffer += c;
+    }
+  }
+  if (buffer.trim()) out.push(buffer);
+  return out;
+}
+function parseScalar(s) {
+  if (s === "" || s === "null" || s === "~") return null;
+  if (VALID_SCALARS.test(s)) return s.toLowerCase() === "true";
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function serializeYaml(value, indent = 0) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") {
+    if (/[:#\n\[\]\{\},&*!|>'"%@`]/.test(value)) {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (value.every((v) => v === null || typeof v !== "object")) {
+      return `[${value.map(serializeScalarInline).join(", ")}]`;
+    }
+    return `[${value.map((v) => "{" + serializeInlineObject(v) + "}").join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+    return entries.map(([k, v]) => {
+      if (v === null || v === void 0) return `${k}:`;
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+        return `${k}: ${serializeScalarInline(v)}`;
+      }
+      if (Array.isArray(v)) {
+        if (v.length === 0) return `${k}: []`;
+        if (v.every((x) => x === null || typeof x !== "object")) {
+          return `${k}: [${v.map(serializeScalarInline).join(", ")}]`;
+        }
+        return `${k}: [${v.map((x) => "{" + serializeInlineObject(x) + "}").join(", ")}]`;
+      }
+      return `${k}:
+${serializeYaml(v, indent + 2)}`;
+    }).map((line) => `${" ".repeat(indent)}${line}`).join("\n");
+  }
+  return String(value);
+}
+function serializeScalarInline(v) {
+  if (typeof v === "string" && /[:#\n\[\]\{\},&*!|>'"%@`]/.test(v)) return JSON.stringify(v);
+  return String(v);
+}
+function serializeInlineObject(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) {
+    return serializeScalarInline(v);
+  }
+  const entries = Object.entries(v).filter(([, val]) => val !== void 0);
+  return entries.map(([k, val]) => `${k}: ${serializeYaml(val)}`).join(", ");
+}
+function countIndent(line) {
+  let i = 0;
+  while (i < line.length && line[i] === " ") i++;
+  return i;
+}
+var FRONTMATTER_RE, VALID_SCALARS, Storage, KeyedMutex, workspaceMutex;
+var init_storage = __esm({
+  "src/cli/workspace/storage.ts"() {
+    "use strict";
+    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+    VALID_SCALARS = /^(true|false|null|~)$/i;
+    Storage = class {
+      /** Read a Markdown file with frontmatter. Throws if not found. */
+      read(path53) {
+        if (!existsSync18(path53)) {
+          throw new Error(`File not found: ${path53}`);
+        }
+        const md = readFileSync16(path53, "utf8");
+        return parseFrontmatter(md);
+      }
+      /** Read a Markdown file; returns null if not found. */
+      readIfExists(path53) {
+        if (!existsSync18(path53)) return null;
+        return this.read(path53);
+      }
+      /**
+       * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
+       * The meta object is serialized as YAML frontmatter; body as Markdown.
+       */
+      write(path53, meta3, body) {
+        mkdirSync11(dirname2(path53), { recursive: true });
+        const tmp = path53 + ".tmp-" + process.pid;
+        const md = serializeFrontmatter(meta3, body);
+        writeFileSync13(tmp, md, "utf8");
+        renameSync2(tmp, path53);
+      }
+      /** List all .md files in a directory (non-recursive). */
+      listMarkdown(dir) {
+        if (!existsSync18(dir)) return [];
+        return readdirSync4(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join14(dir, f));
+      }
+    };
+    KeyedMutex = class {
+      chains = /* @__PURE__ */ new Map();
+      async run(key, fn) {
+        const prev2 = this.chains.get(key) ?? Promise.resolve();
+        let release = () => {
+        };
+        const next = new Promise((resolve3) => {
+          release = resolve3;
+        });
+        const chained = prev2.then(() => next);
+        this.chains.set(key, chained);
+        await prev2;
+        try {
+          return await fn();
+        } finally {
+          release();
+          if (this.chains.get(key) === chained) {
+            this.chains.delete(key);
+          }
+        }
+      }
+    };
+    workspaceMutex = new KeyedMutex();
+  }
+});
+
+// src/cli/workspace/planStore.ts
+import {
+  copyFileSync,
+  existsSync as existsSync19,
+  mkdirSync as mkdirSync12,
+  readFileSync as readFileSync17,
+  renameSync as renameSync3,
+  writeFileSync as writeFileSync14
+} from "node:fs";
+import { dirname as dirname3, join as join15 } from "node:path";
+async function withPlanStore(projectRoot, fn) {
+  const rootDir = resolveWorkspaceRoot(projectRoot);
+  return workspaceMutex.run(`${rootDir}:plan`, () => {
+    const handle = loadHandle(rootDir);
+    const out = fn(handle);
+    saveHandle(rootDir, handle);
+    return out;
+  });
+}
+function nextPlanTaskId(store4) {
+  const maxExisting = store4.tasks.reduce((max, t) => {
+    const m = /^t(\d+)$/.exec(t.id);
+    return m ? Math.max(max, parseInt(m[1], 10)) : max;
+  }, 0);
+  store4.counter = Math.max(store4.counter, maxExisting) + 1;
+  return `t${store4.counter}`;
+}
+function writePlanTaskArtifact(rootDir, task) {
+  const path53 = join15(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync12(dirname3(path53), { recursive: true });
+  const meta3 = {
+    kind: "task",
+    id: task.id,
+    name: task.title,
+    phaseId: task.phaseId,
+    status: task.status,
+    priority: task.priority ?? "medium",
+    updatedAt: task.updatedAt
+  };
+  const body = [
+    `# Task ${task.id}: ${task.title}`,
+    "",
+    `- Status: **${task.status}**`,
+    `- Priority: ${task.priority ?? "medium"}`,
+    task.phaseId ? `- Phase: ${task.phaseId}` : null,
+    task.agent ? `- Agent: ${task.agent}` : null,
+    "",
+    task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
+    ""
+  ].filter((l) => l !== null).join("\n");
+  new Storage().write(path53, meta3, body);
+}
+function loadHandle(rootDir) {
+  const jsonPath = join15(rootDir, "plan.json");
+  if (!existsSync19(jsonPath)) {
+    return { rootDir, tasks: [], counter: 0, rootFields: {} };
+  }
+  let parsed;
+  try {
+    const raw = JSON.parse(readFileSync17(jsonPath, "utf8"));
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      throw new Error("root is not a JSON object");
+    }
+    parsed = raw;
+  } catch {
+    throw new PlanStoreError(
+      `PLAN_CORRUPT: ${jsonPath} is not valid JSON \u2014 refusing to overwrite a possibly hand-edited or crashed write. Fix or remove the file (a .bak may exist), then retry.`,
+      "PLAN_CORRUPT"
+    );
+  }
+  const {
+    tasks: rawTasks,
+    counter,
+    schemaVersion: _schemaVersion,
+    ...rootFields
+  } = parsed;
+  const tasks = (Array.isArray(rawTasks) ? rawTasks : []).map(normalizeTask).filter((t) => typeof t.id === "string" && t.id.length > 0);
+  const numericCounter = typeof counter === "number" && Number.isFinite(counter) && counter >= 0 ? Math.floor(counter) : 0;
+  return { rootDir, tasks, counter: numericCounter, rootFields };
+}
+function saveHandle(rootDir, handle) {
+  if (handle.tasks.length > PLAN_MAX_TASKS) {
+    throw new PlanStoreError(
+      `PLAN_TOO_MANY_TASKS: plan.json would exceed ${PLAN_MAX_TASKS} tasks (${handle.tasks.length}) \u2014 cancel or complete tasks first.`,
+      "PLAN_TOO_MANY_TASKS"
+    );
+  }
+  const jsonPath = join15(rootDir, "plan.json");
+  mkdirSync12(rootDir, { recursive: true });
+  if (existsSync19(jsonPath)) {
+    copyFileSync(jsonPath, `${jsonPath}.bak`);
+  }
+  const file2 = {
+    ...handle.rootFields,
+    schemaVersion: PLAN_SCHEMA_VERSION,
+    counter: handle.counter,
+    tasks: handle.tasks
+  };
+  const tmp = `${jsonPath}.tmp-${process.pid}`;
+  writeFileSync14(tmp, JSON.stringify(file2, null, 2) + "\n", "utf8");
+  renameSync3(tmp, jsonPath);
+}
+function normalizeTask(raw) {
+  const t = raw !== null && typeof raw === "object" ? { ...raw } : {};
+  if (typeof t.id === "string") {
+    t.id = t.id.trim().slice(0, 64);
+  }
+  const titleSource = firstString(t.title) ?? firstString(t.name) ?? firstString(t.description) ?? "";
+  t.title = titleSource.slice(0, PLAN_TITLE_MAX);
+  if (t.title && !firstString(t.name)) {
+    t.name = t.title;
+  }
+  t.status = normalizeStatus(t.status);
+  if (typeof t.notes === "string") {
+    t.notes = t.notes.slice(0, PLAN_NOTES_MAX);
+  }
+  if (typeof t.phaseId === "string") {
+    t.phaseId = t.phaseId.slice(0, PLAN_TAG_MAX);
+  }
+  if (typeof t.agent === "string") {
+    t.agent = t.agent.slice(0, PLAN_TAG_MAX);
+  }
+  return t;
+}
+function normalizeStatus(raw) {
+  const s = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+  switch (s) {
+    case "in_progress":
+    case "in-progress":
+    case "doing":
+    case "started":
+    case "active":
+      return "in_progress";
+    case "completed":
+    case "complete":
+    case "done":
+    case "finished":
+      return "completed";
+    case "cancelled":
+    case "canceled":
+    case "closed":
+      return "cancelled";
+    case "blocked":
+    case "on-hold":
+    case "on hold":
+      return "blocked";
+    default:
+      return "pending";
+  }
+}
+function firstString(v) {
+  return typeof v === "string" && v.trim().length > 0 ? v : null;
+}
+var PLAN_SCHEMA_VERSION, PLAN_MAX_TASKS, PLAN_TITLE_MAX, PLAN_NOTES_MAX, PLAN_TAG_MAX, PlanStoreError;
+var init_planStore = __esm({
+  "src/cli/workspace/planStore.ts"() {
+    "use strict";
+    init_paths2();
+    init_storage();
+    PLAN_SCHEMA_VERSION = 1;
+    PLAN_MAX_TASKS = 100;
+    PLAN_TITLE_MAX = 200;
+    PLAN_NOTES_MAX = 2e3;
+    PLAN_TAG_MAX = 64;
+    PlanStoreError = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "PlanStoreError";
+      }
+    };
+  }
+});
+
+// src/cli/tools/planTaskTools.ts
+function taskSummaryLine(t) {
+  return `- ${t.id}: ${t.title} (${t.status}${t.priority ? `, ${t.priority}` : ""})`;
+}
+function toTaskPayload(t) {
+  return {
+    id: t.id,
+    title: t.title,
+    status: t.status,
+    phaseId: t.phaseId,
+    priority: t.priority
+  };
+}
+function safeEmit(sink, event) {
+  if (!sink) return;
+  try {
+    sink(event);
+  } catch {
+  }
+}
+function createPlanTaskTools(opts) {
+  const projectRoot = opts.projectRoot;
+  const onTaskEvent = opts.onTaskEvent;
+  const taskCreate = {
+    name: "task_create",
+    description: "Create a durable workspace task in .zelari/plan.json (multi-session, shared with the Desktop Live Tasks panel). Use for project work that must survive this session. For volatile per-session tracking use todo_write instead. Returns the assigned id (t<N>).",
+    permissions: ["write"],
+    timeoutMs: 5e3,
+    inputSchema: CreateSchema,
+    execute: async (input) => {
+      try {
+        const res = await withPlanStore(projectRoot, (store4) => {
+          if (store4.tasks.length >= PLAN_MAX_TASKS) {
+            return typedErr(
+              `PLAN_TOO_MANY_TASKS: plan.json already holds ${store4.tasks.length} tasks (max ${PLAN_MAX_TASKS}).`
+            );
+          }
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const id = nextPlanTaskId(store4);
+          const task = {
+            id,
+            title: input.title.trim().slice(0, PLAN_TITLE_MAX),
+            // council readers (buildPlanSummary) render `name` — keep the
+            // alias in sync from creation, not just on reload.
+            name: input.title.trim().slice(0, PLAN_TITLE_MAX),
+            status: "pending",
+            priority: input.priority,
+            phaseId: input.phaseId?.trim().slice(0, 64),
+            notes: input.notes?.trim().slice(0, PLAN_NOTES_MAX),
+            createdAt: now,
+            updatedAt: now
+          };
+          store4.tasks.push(task);
+          writePlanTaskArtifact(store4.rootDir, task);
+          return typedOk({ id, task });
+        });
+        if (res.ok) {
+          safeEmit(onTaskEvent, {
+            type: "task_update",
+            source: "workspace_plan",
+            task: toTaskPayload(res.value.task)
+          });
+        }
+        return res;
+      } catch (err) {
+        return typedErr(planStoreErrorMessage(err, "task_create"));
+      }
+    }
+  };
+  const taskUpdate = {
+    name: "task_update",
+    description: "Update a durable workspace task in .zelari/plan.json (status, title, priority, phaseId, notes, or appendNote). Accepts council-created ids too (task_list shows them). Errors with PLAN_TASK_NOT_FOUND on unknown ids.",
+    permissions: ["write"],
+    timeoutMs: 5e3,
+    inputSchema: UpdateSchema,
+    execute: async (input) => {
+      try {
+        const res = await withPlanStore(projectRoot, (store4) => {
+          const task = store4.tasks.find((t) => t.id === input.id);
+          if (!task) {
+            return typedErr(
+              `PLAN_TASK_NOT_FOUND: no task with id "${input.id}" in .zelari/plan.json (call task_list for current ids).`
+            );
+          }
+          if (input.title !== void 0) {
+            task.title = input.title.trim().slice(0, PLAN_TITLE_MAX);
+            task.name = task.title;
+          }
+          if (input.status !== void 0) task.status = input.status;
+          if (input.priority !== void 0) task.priority = input.priority;
+          if (input.phaseId !== void 0) task.phaseId = input.phaseId.slice(0, 64);
+          if (input.notes !== void 0) {
+            task.notes = input.notes.slice(0, PLAN_NOTES_MAX);
+          }
+          if (input.appendNote !== void 0) {
+            const prev2 = typeof task.notes === "string" ? task.notes : "";
+            const merged = prev2 ? `${prev2}
+${input.appendNote}` : input.appendNote;
+            task.notes = merged.slice(-PLAN_NOTES_MAX);
+          }
+          task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          writePlanTaskArtifact(store4.rootDir, task);
+          return typedOk({ task });
+        });
+        if (res.ok) {
+          safeEmit(onTaskEvent, {
+            type: "task_update",
+            source: "workspace_plan",
+            task: toTaskPayload(res.value.task)
+          });
+        }
+        return res;
+      } catch (err) {
+        return typedErr(planStoreErrorMessage(err, "task_update"));
+      }
+    }
+  };
+  const taskList = {
+    name: "task_list",
+    description: "List durable workspace tasks from .zelari/plan.json (both t<N> agent tasks and council-created plan tasks). Optional status/phaseId filters. Use before task_update to discover ids.",
+    permissions: ["read"],
+    timeoutMs: 5e3,
+    inputSchema: ListSchema,
+    execute: async (input) => {
+      try {
+        let allPayloads = [];
+        const res = await withPlanStore(projectRoot, (store4) => {
+          allPayloads = store4.tasks.map(toTaskPayload);
+          const filtered = store4.tasks.filter(
+            (t) => (input.status === void 0 || t.status === input.status) && (input.phaseId === void 0 || t.phaseId === input.phaseId)
+          );
+          const done = store4.tasks.filter(
+            (t) => t.status === "completed" || t.status === "cancelled"
+          ).length;
+          const formatted = filtered.length === 0 ? "(no matching workspace tasks)" : filtered.map(taskSummaryLine).join("\n");
+          return typedOk({
+            tasks: filtered,
+            total: store4.tasks.length,
+            done,
+            formatted: `${formatted}
+(done/total: ${done}/${store4.tasks.length})`
+          });
+        });
+        if (res.ok) {
+          safeEmit(onTaskEvent, {
+            type: "task_snapshot",
+            source: "workspace_plan",
+            tasks: allPayloads
+          });
+        }
+        return res;
+      } catch (err) {
+        return typedErr(planStoreErrorMessage(err, "task_list"));
+      }
+    }
+  };
+  return [taskCreate, taskUpdate, taskList];
+}
+function planStoreErrorMessage(err, tool) {
+  if (err instanceof PlanStoreError) return err.message;
+  return `[${tool}] ${err instanceof Error ? err.message : String(err)}`;
+}
+var StatusSchema2, PrioritySchema, CreateSchema, UpdateSchema, ListSchema;
+var init_planTaskTools = __esm({
+  "src/cli/tools/planTaskTools.ts"() {
+    "use strict";
+    init_zod();
+    init_toolTypes();
+    init_planStore();
+    StatusSchema2 = external_exports.enum(["pending", "in_progress", "completed", "cancelled", "blocked"]).describe(
+      "blocked exists only here (session todos have no blocked); no rigid FSM \u2014 corrections like completed \u2192 in_progress are allowed"
+    );
+    PrioritySchema = external_exports.enum(["low", "medium", "high", "critical"]);
+    CreateSchema = external_exports.object({
+      title: external_exports.string().min(1).max(PLAN_TITLE_MAX).describe("Short task description"),
+      priority: PrioritySchema.optional().describe("Default medium"),
+      phaseId: external_exports.string().min(1).max(64).optional().describe("Existing plan phase id (see .zelari/plan.json phases)"),
+      notes: external_exports.string().max(PLAN_NOTES_MAX).optional().describe("Optional context/acceptance notes")
+    });
+    UpdateSchema = external_exports.object({
+      id: external_exports.string().min(1).max(64).describe("Task id from task_create/task_list"),
+      status: StatusSchema2.optional(),
+      title: external_exports.string().min(1).max(PLAN_TITLE_MAX).optional(),
+      priority: PrioritySchema.optional(),
+      phaseId: external_exports.string().min(1).max(64).optional(),
+      notes: external_exports.string().max(PLAN_NOTES_MAX).optional(),
+      appendNote: external_exports.string().max(PLAN_NOTES_MAX).optional().describe("Append to existing notes (kept within the size cap)")
+    }).describe("At least one field besides id must be present");
+    ListSchema = external_exports.object({
+      status: StatusSchema2.optional().describe("Filter by status"),
+      phaseId: external_exports.string().min(1).max(64).optional().describe("Filter by phase")
+    });
+  }
+});
+
 // src/cli/lsp/protocol.ts
 function encodeMessage(message) {
   const json2 = JSON.stringify(message);
@@ -31329,7 +32102,7 @@ var init_servers = __esm({
 
 // src/cli/lsp/manager.ts
 import { spawn as spawn4 } from "node:child_process";
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 function processTransport(child) {
   return {
     send: (data) => {
@@ -31532,7 +32305,7 @@ var init_manager = __esm({
         const uri = pathToUri(file2);
         let text;
         try {
-          text = readFileSync16(file2, "utf8");
+          text = readFileSync18(file2, "utf8");
         } catch {
           text = "";
         }
@@ -31854,13 +32627,13 @@ var init_store = __esm({
 });
 
 // src/cli/semantic/index.ts
-import { promises as fs12, existsSync as existsSync17, readFileSync as readFileSync17 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { promises as fs12, existsSync as existsSync20, readFileSync as readFileSync19 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
 import path23 from "node:path";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function getIndexPath(root) {
-  const hash3 = createHash4("sha1").update(path23.resolve(root)).digest("hex").slice(0, 16);
-  return process.env.ZELARI_SEMANTIC_FILE ?? path23.join(homedir5(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
+  const hash3 = createHash5("sha1").update(path23.resolve(root)).digest("hex").slice(0, 16);
+  return process.env.ZELARI_SEMANTIC_FILE ?? path23.join(homedir6(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
   const out = [];
@@ -31938,9 +32711,9 @@ async function saveIndex(root, data) {
 }
 function loadIndex(root) {
   const file2 = getIndexPath(root);
-  if (!existsSync17(file2)) return null;
+  if (!existsSync20(file2)) return null;
   try {
-    const parsed = JSON.parse(readFileSync17(file2, "utf8"));
+    const parsed = JSON.parse(readFileSync19(file2, "utf8"));
     if (parsed && Array.isArray(parsed.chunks)) return parsed;
   } catch {
   }
@@ -32470,19 +33243,19 @@ __export(targets_exports, {
 });
 import {
   chmodSync,
-  existsSync as existsSync18,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync18,
-  writeFileSync as writeFileSync12
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync20,
+  writeFileSync as writeFileSync15
 } from "node:fs";
-import { dirname as dirname2, join as join13 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { dirname as dirname4, join as join16 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 import { spawn as spawn5 } from "node:child_process";
 function getSshTargetsPath() {
-  return join13(homedir6(), ".zelari-code", "ssh-targets.json");
+  return join16(homedir7(), ".zelari-code", "ssh-targets.json");
 }
 function getSshSecretsPath() {
-  return join13(homedir6(), ".zelari-code", "ssh-secrets.json");
+  return join16(homedir7(), ".zelari-code", "ssh-secrets.json");
 }
 function normalizeAuth(auth) {
   if (auth === "keyPath") return "keyPath";
@@ -32491,17 +33264,17 @@ function normalizeAuth(auth) {
 }
 function readSecrets() {
   const path53 = getSshSecretsPath();
-  if (!existsSync18(path53)) return {};
+  if (!existsSync21(path53)) return {};
   try {
-    return JSON.parse(readFileSync18(path53, "utf8"));
+    return JSON.parse(readFileSync20(path53, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
   const path53 = getSshSecretsPath();
-  mkdirSync10(dirname2(path53), { recursive: true });
-  writeFileSync12(path53, `${JSON.stringify(data, null, 2)}
+  mkdirSync13(dirname4(path53), { recursive: true });
+  writeFileSync15(path53, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
     chmodSync(path53, 384);
@@ -32534,9 +33307,9 @@ function deleteSshPassword(id) {
 }
 function readStore2() {
   const path53 = getSshTargetsPath();
-  if (!existsSync18(path53)) return [];
+  if (!existsSync21(path53)) return [];
   try {
-    const parsed = JSON.parse(readFileSync18(path53, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path53, "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"
@@ -32552,9 +33325,9 @@ function readStore2() {
 }
 function writeStore2(targets) {
   const path53 = getSshTargetsPath();
-  mkdirSync10(dirname2(path53), { recursive: true });
+  mkdirSync13(dirname4(path53), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
-  writeFileSync12(
+  writeFileSync15(
     path53,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
@@ -32655,17 +33428,17 @@ function buildSshBaseArgs(target) {
   return args;
 }
 function ensureAskpassHelper() {
-  const dir = join13(homedir6(), ".zelari-code", "ssh-helpers");
-  mkdirSync10(dir, { recursive: true });
-  const cjs = join13(dir, "askpass.cjs");
-  writeFileSync12(
+  const dir = join16(homedir7(), ".zelari-code", "ssh-helpers");
+  mkdirSync13(dir, { recursive: true });
+  const cjs = join16(dir, "askpass.cjs");
+  writeFileSync15(
     cjs,
     "process.stdout.write(process.env.ZELARI_SSH_ASKPASS_PASS || '');\n",
     "utf8"
   );
   if (process.platform === "win32") {
-    const cmd = join13(dir, "askpass.cmd");
-    writeFileSync12(
+    const cmd = join16(dir, "askpass.cmd");
+    writeFileSync15(
       cmd,
       `@echo off\r
 node "%~dp0askpass.cjs"\r
@@ -32674,8 +33447,8 @@ node "%~dp0askpass.cjs"\r
     );
     return cmd;
   }
-  const sh = join13(dir, "askpass.sh");
-  writeFileSync12(
+  const sh = join16(dir, "askpass.sh");
+  writeFileSync15(
     sh,
     `#!/bin/sh
 exec node "$(dirname "$0")/askpass.cjs"
@@ -32748,9 +33521,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 (!existsSync18(p3)) continue;
+    if (!existsSync21(p3)) continue;
     try {
-      const content = readFileSync18(p3, "utf8").trim();
+      const content = readFileSync20(p3, "utf8").trim();
       if (!content) continue;
       if (/BEGIN .*PRIVATE KEY/i.test(content)) {
         return {
@@ -33320,11 +34093,11 @@ __export(folderTrust_exports, {
   trustFolder: () => trustFolder,
   untrustFolder: () => untrustFolder
 });
-import { homedir as homedir7 } from "node:os";
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync21, writeFileSync as writeFileSync16 } from "node:fs";
 import path28 from "node:path";
 function trustStorePath() {
-  return _overrideStorePath ?? path28.join(homedir7(), ".zelari-code", "trust.json");
+  return _overrideStorePath ?? path28.join(homedir8(), ".zelari-code", "trust.json");
 }
 function normalize(p3) {
   const resolved = path28.resolve(p3);
@@ -33332,7 +34105,7 @@ function normalize(p3) {
 }
 function readStore3() {
   try {
-    const raw = readFileSync19(trustStorePath(), "utf8");
+    const raw = readFileSync21(trustStorePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && Array.isArray(parsed.folders)) return parsed;
     return DEFAULT_STORE;
@@ -33343,8 +34116,8 @@ function readStore3() {
 function writeStore3(store4) {
   const p3 = trustStorePath();
   try {
-    mkdirSync11(path28.dirname(p3), { recursive: true });
-    writeFileSync13(p3, JSON.stringify(store4, null, 2), "utf8");
+    mkdirSync14(path28.dirname(p3), { recursive: true });
+    writeFileSync16(p3, JSON.stringify(store4, null, 2), "utf8");
   } catch (err) {
     throw new Error(
       `failed to persist trust store ${p3}: ${err instanceof Error ? err.message : String(err)}`
@@ -33399,7 +34172,7 @@ function getTrustStorePath() {
   return trustStorePath();
 }
 function hasTrustStore() {
-  return existsSync19(trustStorePath());
+  return existsSync22(trustStorePath());
 }
 function _setTrustStorePathForTests(p3) {
   _overrideStorePath = p3;
@@ -33414,21 +34187,21 @@ var init_folderTrust = __esm({
 });
 
 // src/cli/safety/lifecycleHooks.ts
-import { homedir as homedir8 } from "node:os";
-import { join as join14 } from "node:path";
-import { readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join17 } from "node:path";
+import { readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
 function globalHooksDir() {
-  return join14(homedir8(), ".zelari-code", "hooks");
+  return join17(homedir9(), ".zelari-code", "hooks");
 }
 function projectHooksDir(projectRoot) {
-  return join14(projectRoot, ".zelari", "hooks");
+  return join17(projectRoot, ".zelari", "hooks");
 }
 function fingerprintHookDirs(dirs) {
   const parts = [];
   for (const dir of dirs) {
     let names;
     try {
-      names = readdirSync4(dir).filter((f) => f.endsWith(".json")).sort();
+      names = readdirSync5(dir).filter((f) => f.endsWith(".json")).sort();
     } catch {
       parts.push(`${dir}:missing`);
       continue;
@@ -33442,7 +34215,7 @@ function fingerprintHookDirs(dirs) {
       continue;
     }
     for (const name of names) {
-      const full = join14(dir, name);
+      const full = join17(dir, name);
       try {
         const st = statSync3(full);
         parts.push(`${full}:${st.mtimeMs}:${st.size}`);
@@ -33483,7 +34256,7 @@ var init_lifecycleHooks = __esm({
 });
 
 // src/cli/toolResultCache.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { promises as fs14 } from "node:fs";
 import path29 from "node:path";
 function isToolCacheEnabled() {
@@ -33496,7 +34269,7 @@ function resolveToolCacheTtlMs() {
   return Number.isFinite(n) && n >= 0 ? n : TOOL_CACHE_DEFAULT_TTL_MS;
 }
 function hashKey(parts) {
-  return createHash5("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
+  return createHash6("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
 }
 function resultBytes(result) {
   try {
@@ -33786,6 +34559,11 @@ function createBuiltinToolRegistry(options = {}) {
   const todoRead = enableTodos ? withPerm(createTodoReadTool()) : null;
   if (todoWrite) registry4.register(todoWrite);
   if (todoRead) registry4.register(todoRead);
+  const enablePlanTasks = options.enablePlanTasks !== false && options.readOnly !== true && (profile === "full" || options.planMode === true) && profile !== "explore" && profile !== "verify" && profile !== "general";
+  const planTaskToolsWrapped = (enablePlanTasks ? createPlanTaskTools({ projectRoot: root, onTaskEvent: options.onTaskEvent }) : []).map((t) => withPerm(t));
+  for (const t of planTaskToolsWrapped) {
+    registry4.register(t);
+  }
   const summary = [
     safeReadFile,
     safeGrepContent,
@@ -33798,7 +34576,8 @@ function createBuiltinToolRegistry(options = {}) {
     ...askUserTool ? [askUserTool] : [],
     ...skillTool ? [skillTool] : [],
     ...todoWrite ? [todoWrite] : [],
-    ...todoRead ? [todoRead] : []
+    ...todoRead ? [todoRead] : [],
+    ...planTaskToolsWrapped.length > 0 ? planTaskToolsWrapped : []
   ];
   const tools = summary.map((t) => ({
     name: t.name,
@@ -34147,6 +34926,7 @@ var init_toolRegistry = __esm({
     init_askUser();
     init_skillTool();
     init_todoTools();
+    init_planTaskTools();
     init_tools2();
     init_manager();
     init_tools3();
@@ -34177,7 +34957,7 @@ var init_toolRegistry = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID2 } from "node:crypto";
 import { promises as fs15 } from "node:fs";
 import * as path30 from "node:path";
 function shortId() {
@@ -34229,7 +35009,7 @@ async function getStateStore(projectRoot, env = process.env) {
   }
 }
 function hashStablePrompt(stable) {
-  return createHash6("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
+  return createHash7("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
 }
 var DEFAULT_MATERIALIZE_CHARS, FileDurableStateStore, NoopDurableStateStore;
 var init_fileStateStore = __esm({
@@ -34942,8 +35722,8 @@ __export(conversationContext_exports, {
   setHistory: () => setHistory,
   setLastClarification: () => setLastClarification
 });
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join19 } from "node:path";
 function getHistory() {
   return history;
 }
@@ -34951,7 +35731,7 @@ function setHistory(messages) {
   history = [...messages];
 }
 function compactInPlace(cwd = process.cwd()) {
-  const durableStatePresent = existsSync20(join16(cwd, ".zelari", "state", "HEAD.json"));
+  const durableStatePresent = existsSync23(join19(cwd, ".zelari", "state", "HEAD.json"));
   history = compactHistory(history, { durableStatePresent });
 }
 function appendMessages(msgs) {
@@ -35466,14 +36246,14 @@ var init_claudeProvider = __esm({
 });
 
 // src/cli/workspace/projectInstructions.ts
-import { existsSync as existsSync21, readFileSync as readFileSync20 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync22 } from "node:fs";
+import { join as join20 } from "node:path";
 function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
   for (const name of CANDIDATES) {
-    const full = join17(projectRoot, name);
-    if (!existsSync21(full)) continue;
+    const full = join20(projectRoot, name);
+    if (!existsSync24(full)) continue;
     try {
-      let raw = readFileSync20(full, "utf8");
+      let raw = readFileSync22(full, "utf8");
       raw = raw.replace(/\r\n/g, "\n").trim();
       if (!raw) continue;
       if (raw.length <= maxChars) {
@@ -35508,75 +36288,6 @@ var init_projectInstructions = __esm({
   }
 });
 
-// src/cli/workspace/paths.ts
-import {
-  mkdirSync as mkdirSync12,
-  writeFileSync as writeFileSync14,
-  existsSync as existsSync22,
-  accessSync,
-  constants,
-  realpathSync
-} from "node:fs";
-import { join as join18, basename } from "node:path";
-import { homedir as homedir9 } from "node:os";
-import { createHash as createHash7 } from "node:crypto";
-function resolveWorkspaceRoot(projectRoot = process.cwd()) {
-  const candidates = [
-    join18(projectRoot, ".zelari"),
-    join18(homedir9(), ".zelari-code", "workspace", hashProject(projectRoot))
-  ];
-  for (const candidate of candidates) {
-    if (isWritableDir(projectRoot) || candidate !== candidates[0]) {
-      ensureWorkspaceDir(candidate);
-      return candidate;
-    }
-  }
-  ensureWorkspaceDir(candidates[0]);
-  return candidates[0];
-}
-function hashProject(projectPath) {
-  return createHash7("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
-}
-function isWritableDir(dir) {
-  try {
-    if (!existsSync22(dir)) return false;
-    accessSync(dir, constants.W_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function ensureWorkspaceDir(workspaceDir) {
-  mkdirSync12(workspaceDir, { recursive: true });
-  if (workspaceDir.endsWith("/.zelari") && existsSync22(join18(workspaceDir, "..", ".git"))) {
-    const gitignorePath = join18(workspaceDir, ".gitignore");
-    if (!existsSync22(gitignorePath)) {
-      writeFileSync14(gitignorePath, "*\n!.gitignore\n");
-    }
-  }
-}
-function workspaceFile(rootDir, kind) {
-  switch (kind) {
-    case "plan":
-      return join18(rootDir, "plan.md");
-    case "risks":
-      return join18(rootDir, "risks.md");
-    case "index":
-      return join18(rootDir, "workspace.json");
-  }
-}
-function workspaceArtifact(rootDir, subdir, slug) {
-  return join18(rootDir, subdir, `${slug}.md`);
-}
-function projectName(projectRoot = process.cwd()) {
-  return basename(realpathSync(projectRoot));
-}
-var init_paths2 = __esm({
-  "src/cli/workspace/paths.ts"() {
-    "use strict";
-  }
-});
-
 // src/cli/workspace/workspaceSummary.ts
 var workspaceSummary_exports = {};
 __export(workspaceSummary_exports, {
@@ -35586,8 +36297,8 @@ __export(workspaceSummary_exports, {
   buildWorkspaceSummary: () => buildWorkspaceSummary,
   buildZelariReadHint: () => buildZelariReadHint
 });
-import { existsSync as existsSync23, readFileSync as readFileSync21, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
-import { join as join19, relative } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync23, readdirSync as readdirSync6, statSync as statSync4 } from "node:fs";
+import { join as join21, relative } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30, maxChars = 3500, maxDeps = 24, maxScripts = 16 } = options;
   const name = safeProjectName(projectRoot);
@@ -35620,11 +36331,11 @@ function formatTaskLine(t) {
 }
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  const planPath = join19(zelariRoot, "plan.json");
-  if (!existsSync23(planPath)) return null;
+  const planPath = join21(zelariRoot, "plan.json");
+  if (!existsSync25(planPath)) return null;
   let plan;
   try {
-    plan = JSON.parse(readFileSync21(planPath, "utf8"));
+    plan = JSON.parse(readFileSync23(planPath, "utf8"));
   } catch {
     return null;
   }
@@ -35638,7 +36349,10 @@ function buildPlanSummary(projectRoot = process.cwd(), options) {
     "# Plan ops (DRAFT \u2014 .zelari/plan.json)",
     "_This is operational task list from design, not product law. Ground every change in the real source tree._"
   ];
-  const open = tasks.filter((t) => t.status !== "done");
+  const open = tasks.filter((t) => {
+    const s = t.status;
+    return s !== "done" && s !== "completed" && s !== "cancelled";
+  });
   const done = tasks.length - open.length;
   const userMessage = options?.userMessage?.trim();
   let scopedOpen = open;
@@ -35760,8 +36474,8 @@ function pickNextTask(open) {
   )[0];
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
-  const planPath = join19(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync23(planPath)) return "";
+  const planPath = join21(resolveWorkspaceRoot(projectRoot), "plan.json");
+  if (!existsSync25(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/) \u2014 DRAFT vault",
     "`.zelari/plan.json` and `.zelari/docs/` hold **design hypotheses**, not verified product state.",
@@ -35776,10 +36490,10 @@ function safeProjectName(root) {
   }
 }
 function readPackageJson(projectRoot) {
-  const p3 = join19(projectRoot, "package.json");
-  if (!existsSync23(p3)) return null;
+  const p3 = join21(projectRoot, "package.json");
+  if (!existsSync25(p3)) return null;
   try {
-    return JSON.parse(readFileSync21(p3, "utf8"));
+    return JSON.parse(readFileSync23(p3, "utf8"));
   } catch {
     return null;
   }
@@ -35820,7 +36534,7 @@ function readBuildScripts(projectRoot, maxScripts = 16) {
 function listShallow(projectRoot, maxEntries) {
   const out = [];
   try {
-    const top = readdirSync5(projectRoot, { withFileTypes: true }).filter(
+    const top = readdirSync6(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;
@@ -35829,11 +36543,11 @@ function listShallow(projectRoot, maxEntries) {
         out.push(`\u2026 (+${top.length - count} more)`);
         break;
       }
-      const rel2 = relative(projectRoot, join19(projectRoot, entry.name));
+      const rel2 = relative(projectRoot, join21(projectRoot, entry.name));
       if (entry.isDirectory()) {
         let inner = "";
         try {
-          const sub = readdirSync5(join19(projectRoot, entry.name), {
+          const sub = readdirSync6(join21(projectRoot, entry.name), {
             withFileTypes: true
           }).filter((e) => !e.name.startsWith(".")).slice(0, 4).map((e) => e.name);
           if (sub.length > 0)
@@ -35881,12 +36595,12 @@ var init_workspaceSummary = __esm({
 });
 
 // src/cli/workspace/buildLessonsSummary.ts
-import { existsSync as existsSync24 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+import { join as join22 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync24(join20(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync26(join22(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -35907,8 +36621,8 @@ var composeContext_exports = {};
 __export(composeContext_exports, {
   composeProjectContext: () => composeProjectContext
 });
-import { existsSync as existsSync25, readdirSync as readdirSync6, readFileSync as readFileSync22 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync27, readdirSync as readdirSync7, readFileSync as readFileSync24 } from "node:fs";
+import { join as join23 } from "node:path";
 function cap2(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
   return {
@@ -35920,19 +36634,19 @@ function cap2(text, max, label) {
 }
 function buildDesignIndex(projectRoot, maxChars) {
   const root = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync25(root)) return "";
+  if (!existsSync27(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 = join21(root, "docs");
-  if (existsSync25(docsDir)) {
+  const docsDir = join23(root, "docs");
+  if (existsSync27(docsDir)) {
     try {
-      const docs = readdirSync6(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
+      const docs = readdirSync7(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 (readdirSync6(docsDir).filter((n) => n.endsWith(".md")).length > 12) {
+        if (readdirSync7(docsDir).filter((n) => n.endsWith(".md")).length > 12) {
           lines.push("- \u2026 (more under .zelari/docs/)");
         }
       }
@@ -35940,14 +36654,14 @@ function buildDesignIndex(projectRoot, maxChars) {
     }
   }
   for (const name of ["risks.md", "plan.json", "nfr-spec.json"]) {
-    if (existsSync25(join21(root, name))) {
+    if (existsSync27(join23(root, name))) {
       lines.push(`- .zelari/${name} present`);
     }
   }
-  const decisionsDir = join21(root, "decisions");
-  if (existsSync25(decisionsDir)) {
+  const decisionsDir = join23(root, "decisions");
+  if (existsSync27(decisionsDir)) {
     try {
-      const n = readdirSync6(decisionsDir).filter((f) => f.endsWith(".md")).length;
+      const n = readdirSync7(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 {
     }
@@ -36046,17 +36760,17 @@ function composeProjectContext(input) {
 }
 function readDurableHeadSync(projectRoot) {
   try {
-    const headPath = join21(projectRoot, ".zelari", "state", "HEAD.json");
-    if (!existsSync25(headPath)) return "";
-    const head = JSON.parse(readFileSync22(headPath, "utf8"));
+    const headPath = join23(projectRoot, ".zelari", "state", "HEAD.json");
+    if (!existsSync27(headPath)) return "";
+    const head = JSON.parse(readFileSync24(headPath, "utf8"));
     if (!head?.id) return "";
-    const metaPath = join21(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
-    if (!existsSync25(metaPath)) return "";
-    const meta3 = JSON.parse(readFileSync22(metaPath, "utf8"));
-    const discPath = meta3.artifactDir ? join21(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join21(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
+    const metaPath = join23(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
+    if (!existsSync27(metaPath)) return "";
+    const meta3 = JSON.parse(readFileSync24(metaPath, "utf8"));
+    const discPath = meta3.artifactDir ? join23(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join23(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
     let discoveries = [];
-    if (existsSync25(discPath)) {
-      discoveries = JSON.parse(readFileSync22(discPath, "utf8"));
+    if (existsSync27(discPath)) {
+      discoveries = JSON.parse(readFileSync24(discPath, "utf8"));
     }
     const reusable = discoveries.filter((d) => d.reusable !== false);
     const lines = [
@@ -36089,13 +36803,13 @@ var planDetect_exports = {};
 __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
-import { existsSync as existsSync26, readFileSync as readFileSync23 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync25 } from "node:fs";
+import { join as join24 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
-  const planPath = join22(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync26(planPath)) return false;
+  const planPath = join24(resolveWorkspaceRoot(projectRoot), "plan.json");
+  if (!existsSync28(planPath)) return false;
   try {
-    const parsed = JSON.parse(readFileSync23(planPath, "utf8"));
+    const parsed = JSON.parse(readFileSync25(planPath, "utf8"));
     return Array.isArray(parsed.phases) && parsed.phases.length > 0;
   } catch {
     return false;
@@ -36144,333 +36858,6 @@ var init_loadDurableContext = __esm({
   }
 });
 
-// src/cli/workspace/storage.ts
-var storage_exports = {};
-__export(storage_exports, {
-  Storage: () => Storage,
-  parseFrontmatter: () => parseFrontmatter,
-  parseYaml: () => parseYaml,
-  serializeFrontmatter: () => serializeFrontmatter,
-  serializeYaml: () => serializeYaml,
-  workspaceMutex: () => workspaceMutex
-});
-import {
-  readFileSync as readFileSync24,
-  writeFileSync as writeFileSync15,
-  existsSync as existsSync27,
-  mkdirSync as mkdirSync13,
-  readdirSync as readdirSync7,
-  renameSync as renameSync2
-} from "node:fs";
-import { dirname as dirname4, join as join23 } from "node:path";
-function parseFrontmatter(md) {
-  const m = FRONTMATTER_RE.exec(md);
-  if (!m) return { meta: {}, body: md };
-  const meta3 = parseYaml(m[1]);
-  const body = m[2];
-  return { meta: meta3, body };
-}
-function serializeFrontmatter(meta3, body) {
-  const yamlStr = serializeYaml(meta3);
-  return `---
-${yamlStr}
----
-${body}`;
-}
-function parseYaml(input) {
-  const lines = input.split(/\r?\n/);
-  const ctx = { lines, i: 0 };
-  return parseNode(ctx, 0);
-}
-function parseNode(ctx, indent) {
-  while (ctx.i < ctx.lines.length) {
-    const line2 = ctx.lines[ctx.i];
-    if (line2.trim() === "" || line2.trim().startsWith("#")) {
-      ctx.i++;
-      continue;
-    }
-    break;
-  }
-  if (ctx.i >= ctx.lines.length) return null;
-  const line = ctx.lines[ctx.i];
-  const lineIndent = countIndent(line);
-  if (/^\s*-\s+/.test(line)) {
-    return parseBlockSequence(ctx, indent);
-  }
-  if (/^\s*\[.*\]\s*$/.test(line)) {
-    const flow = line.trim().replace(/^\[/, "").replace(/\]$/, "");
-    return parseFlowSequence(flow);
-  }
-  if (/^\s*\{.*\}\s*$/.test(line)) {
-    const flow = line.trim().replace(/^\{/, "").replace(/\}$/, "");
-    return parseFlowMap(flow);
-  }
-  return parseBlockMap(ctx, indent);
-}
-function parseBlockMap(ctx, indent) {
-  const out = {};
-  while (ctx.i < ctx.lines.length) {
-    const line = ctx.lines[ctx.i];
-    if (line.trim() === "" || line.trim().startsWith("#")) {
-      ctx.i++;
-      continue;
-    }
-    const lineIndent = countIndent(line);
-    if (lineIndent < indent) break;
-    if (lineIndent > indent) {
-      ctx.i++;
-      continue;
-    }
-    const m = /^([^:]+):\s*(.*)$/.exec(line);
-    if (!m) {
-      ctx.i++;
-      continue;
-    }
-    const key = m[1].trim();
-    const valuePart = m[2].trim();
-    if (valuePart === "" || valuePart === "|" || valuePart === ">") {
-      ctx.i++;
-      const nested = parseNode(ctx, indent + 2);
-      out[key] = nested;
-    } else {
-      if (valuePart.startsWith("[")) {
-        out[key] = parseFlowSequence(stripFlow(valuePart, "[", "]"));
-      } else if (valuePart.startsWith("{")) {
-        out[key] = parseFlowMap(stripFlow(valuePart, "{", "}"));
-      } else {
-        out[key] = parseScalar(valuePart);
-      }
-      ctx.i++;
-    }
-  }
-  return out;
-}
-function parseBlockSequence(ctx, indent) {
-  const out = [];
-  while (ctx.i < ctx.lines.length) {
-    const line = ctx.lines[ctx.i];
-    if (line.trim() === "") {
-      ctx.i++;
-      continue;
-    }
-    const lineIndent = countIndent(line);
-    if (lineIndent < indent) break;
-    if (lineIndent > indent) break;
-    const m = /^-\s*(.*)$/.exec(line);
-    if (!m) break;
-    const rest = m[1];
-    if (rest === "") {
-      ctx.i++;
-      out.push(parseNode(ctx, indent + 2));
-    } else if (rest.startsWith("[") || rest.startsWith("{")) {
-      let buffer = rest;
-      let depthSq = (buffer.match(/\[/g) || []).length - (buffer.match(/\]/g) || []).length;
-      let depthCu = (buffer.match(/\{/g) || []).length - (buffer.match(/\}/g) || []).length;
-      while ((depthSq > 0 || depthCu > 0) && ctx.i + 1 < ctx.lines.length) {
-        ctx.i++;
-        const next = ctx.lines[ctx.i].trim();
-        buffer += " " + next;
-        depthSq = (buffer.match(/\[/g) || []).length - (buffer.match(/\]/g) || []).length;
-        depthCu = (buffer.match(/\{/g) || []).length - (buffer.match(/\}/g) || []).length;
-      }
-      if (buffer.startsWith("[")) {
-        out.push(parseFlowSequence(buffer.slice(1).replace(/\]$/, "")));
-      } else {
-        out.push(parseFlowMap(buffer.slice(1).replace(/\}$/, "")));
-      }
-      ctx.i++;
-    } else if (rest.includes(":")) {
-      ctx.i++;
-      const mapCtx = { lines: [" ".repeat(indent + 2) + rest, ...ctx.lines.slice(ctx.i)], i: 0 };
-      const val = parseBlockMap(mapCtx, indent + 2);
-      ctx.i += mapCtx.i - 1;
-      out.push(val);
-    } else {
-      out.push(parseScalar(rest));
-      ctx.i++;
-    }
-  }
-  return out;
-}
-function parseFlowSequence(input) {
-  const parts = splitFlow(input);
-  return parts.map((p3) => {
-    const trimmed = p3.trim();
-    if (trimmed.startsWith("{")) {
-      return parseFlowMap(stripFlow(trimmed, "{", "}"));
-    }
-    return parseScalar(trimmed);
-  });
-}
-function stripFlow(s, open, close) {
-  let out = s.trim();
-  if (out.startsWith(open)) out = out.slice(1);
-  if (out.endsWith(close)) out = out.slice(0, -1);
-  return out;
-}
-function parseFlowMap(input) {
-  const parts = splitFlow(input);
-  const out = {};
-  for (const p3 of parts) {
-    const colonIdx = p3.indexOf(":");
-    if (colonIdx < 0) continue;
-    const key = p3.slice(0, colonIdx).trim();
-    const value = p3.slice(colonIdx + 1).trim();
-    out[key] = parseScalar(value);
-  }
-  return out;
-}
-function splitFlow(input) {
-  const out = [];
-  let depthSq = 0, depthCu = 0, depthQu = 0;
-  let buffer = "";
-  for (let i = 0; i < input.length; i++) {
-    const c = input[i];
-    if (c === '"' || c === "'") {
-      depthQu = depthQu === 0 ? depthQu + 1 : 0;
-      buffer += c;
-    } else if (depthQu === 0) {
-      if (c === "[") depthSq++;
-      else if (c === "]") depthSq--;
-      else if (c === "{") depthCu++;
-      else if (c === "}") depthCu--;
-      else if (c === "," && depthSq === 0 && depthCu === 0) {
-        out.push(buffer);
-        buffer = "";
-        continue;
-      }
-      buffer += c;
-    } else {
-      buffer += c;
-    }
-  }
-  if (buffer.trim()) out.push(buffer);
-  return out;
-}
-function parseScalar(s) {
-  if (s === "" || s === "null" || s === "~") return null;
-  if (VALID_SCALARS.test(s)) return s.toLowerCase() === "true";
-  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
-  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
-function serializeYaml(value, indent = 0) {
-  if (value === null || value === void 0) return "";
-  if (typeof value === "string") {
-    if (/[:#\n\[\]\{\},&*!|>'"%@`]/.test(value)) {
-      return JSON.stringify(value);
-    }
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "[]";
-    if (value.every((v) => v === null || typeof v !== "object")) {
-      return `[${value.map(serializeScalarInline).join(", ")}]`;
-    }
-    return `[${value.map((v) => "{" + serializeInlineObject(v) + "}").join(", ")}]`;
-  }
-  if (typeof value === "object") {
-    const entries = Object.entries(value).filter(([, v]) => v !== void 0);
-    return entries.map(([k, v]) => {
-      if (v === null || v === void 0) return `${k}:`;
-      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-        return `${k}: ${serializeScalarInline(v)}`;
-      }
-      if (Array.isArray(v)) {
-        if (v.length === 0) return `${k}: []`;
-        if (v.every((x) => x === null || typeof x !== "object")) {
-          return `${k}: [${v.map(serializeScalarInline).join(", ")}]`;
-        }
-        return `${k}: [${v.map((x) => "{" + serializeInlineObject(x) + "}").join(", ")}]`;
-      }
-      return `${k}:
-${serializeYaml(v, indent + 2)}`;
-    }).map((line) => `${" ".repeat(indent)}${line}`).join("\n");
-  }
-  return String(value);
-}
-function serializeScalarInline(v) {
-  if (typeof v === "string" && /[:#\n\[\]\{\},&*!|>'"%@`]/.test(v)) return JSON.stringify(v);
-  return String(v);
-}
-function serializeInlineObject(v) {
-  if (v === null || typeof v !== "object" || Array.isArray(v)) {
-    return serializeScalarInline(v);
-  }
-  const entries = Object.entries(v).filter(([, val]) => val !== void 0);
-  return entries.map(([k, val]) => `${k}: ${serializeYaml(val)}`).join(", ");
-}
-function countIndent(line) {
-  let i = 0;
-  while (i < line.length && line[i] === " ") i++;
-  return i;
-}
-var FRONTMATTER_RE, VALID_SCALARS, Storage, KeyedMutex, workspaceMutex;
-var init_storage = __esm({
-  "src/cli/workspace/storage.ts"() {
-    "use strict";
-    FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-    VALID_SCALARS = /^(true|false|null|~)$/i;
-    Storage = class {
-      /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path53) {
-        if (!existsSync27(path53)) {
-          throw new Error(`File not found: ${path53}`);
-        }
-        const md = readFileSync24(path53, "utf8");
-        return parseFrontmatter(md);
-      }
-      /** Read a Markdown file; returns null if not found. */
-      readIfExists(path53) {
-        if (!existsSync27(path53)) return null;
-        return this.read(path53);
-      }
-      /**
-       * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
-       * The meta object is serialized as YAML frontmatter; body as Markdown.
-       */
-      write(path53, meta3, body) {
-        mkdirSync13(dirname4(path53), { recursive: true });
-        const tmp = path53 + ".tmp-" + process.pid;
-        const md = serializeFrontmatter(meta3, body);
-        writeFileSync15(tmp, md, "utf8");
-        renameSync2(tmp, path53);
-      }
-      /** List all .md files in a directory (non-recursive). */
-      listMarkdown(dir) {
-        if (!existsSync27(dir)) return [];
-        return readdirSync7(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join23(dir, f));
-      }
-    };
-    KeyedMutex = class {
-      chains = /* @__PURE__ */ new Map();
-      async run(key, fn) {
-        const prev2 = this.chains.get(key) ?? Promise.resolve();
-        let release = () => {
-        };
-        const next = new Promise((resolve3) => {
-          release = resolve3;
-        });
-        const chained = prev2.then(() => next);
-        this.chains.set(key, chained);
-        await prev2;
-        try {
-          return await fn();
-        } finally {
-          release();
-          if (this.chains.get(key) === chained) {
-            this.chains.delete(key);
-          }
-        }
-      }
-    };
-    workspaceMutex = new KeyedMutex();
-  }
-});
-
 // src/cli/workspace/stubs.ts
 var stubs_exports = {};
 __export(stubs_exports, {
@@ -36481,14 +36868,14 @@ __export(stubs_exports, {
   resolveWorkspaceRoot: () => resolveWorkspaceRoot
 });
 import {
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   readdirSync as readdirSync8,
-  writeFileSync as writeFileSync16,
-  readFileSync as readFileSync25,
-  mkdirSync as mkdirSync14,
-  renameSync as renameSync3
+  writeFileSync as writeFileSync17,
+  readFileSync as readFileSync26,
+  mkdirSync as mkdirSync15,
+  renameSync as renameSync4
 } from "node:fs";
-import { join as join24, basename as basename2, dirname as dirname5, relative as relative2 } from "node:path";
+import { join as join25, basename as basename2, dirname as dirname6, relative as relative2 } from "node:path";
 function createWorkspaceContext(projectRoot = process.cwd()) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return {
@@ -36498,19 +36885,21 @@ function createWorkspaceContext(projectRoot = process.cwd()) {
   };
 }
 function planJsonPath(ctx) {
-  return join24(ctx.rootDir, "plan.json");
+  return join25(ctx.rootDir, "plan.json");
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
-  if (existsSync28(jsonPath)) {
+  if (existsSync29(jsonPath)) {
     try {
       const parsed = JSON.parse(
-        readFileSync25(jsonPath, "utf8")
+        readFileSync26(jsonPath, "utf8")
       );
+      const { phases, tasks, milestones, ...root } = parsed;
       return {
-        phases: Array.isArray(parsed.phases) ? parsed.phases : [],
-        tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
-        milestones: Array.isArray(parsed.milestones) ? parsed.milestones : []
+        phases: Array.isArray(phases) ? phases : [],
+        tasks: Array.isArray(tasks) ? tasks : [],
+        milestones: Array.isArray(milestones) ? milestones : [],
+        root
       };
     } catch {
     }
@@ -36527,10 +36916,23 @@ function readPlan(ctx) {
 }
 function writePlan(ctx, summary) {
   const jsonPath = planJsonPath(ctx);
-  mkdirSync14(dirname5(jsonPath), { recursive: true });
+  mkdirSync15(dirname6(jsonPath), { recursive: true });
   const tmp = jsonPath + ".tmp-" + process.pid;
-  writeFileSync16(tmp, JSON.stringify(summary, null, 2), "utf8");
-  renameSync3(tmp, jsonPath);
+  writeFileSync17(
+    tmp,
+    JSON.stringify(
+      {
+        ...summary.root ?? {},
+        phases: summary.phases,
+        tasks: summary.tasks,
+        milestones: summary.milestones
+      },
+      null,
+      2
+    ),
+    "utf8"
+  );
+  renameSync4(tmp, jsonPath);
   const mdPath = workspaceFile(ctx.rootDir, "plan");
   const summaryMeta = {
     kind: "plan-summary",
@@ -36596,8 +36998,8 @@ function renderPlanBody(summary) {
   return lines.join("\n");
 }
 function nextAdrId(ctx) {
-  const decisionsDir = join24(ctx.rootDir, "decisions");
-  if (!existsSync28(decisionsDir)) return "001";
+  const decisionsDir = join25(ctx.rootDir, "decisions");
+  if (!existsSync29(decisionsDir)) return "001";
   const existing = readdirSync8(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");
@@ -36639,7 +37041,7 @@ function addTaskRecord(ctx, summary, phaseId, t, options) {
     status: "pending",
     priority: t.priority
   });
-  const taskPath = join24(ctx.rootDir, "plan-tasks", `${id}.md`);
+  const taskPath = join25(ctx.rootDir, "plan-tasks", `${id}.md`);
   const meta3 = {
     kind: "task",
     id,
@@ -36681,7 +37083,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path53 = join24(ctx.rootDir, "milestones", `${id}.md`);
+  const path53 = join25(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -36979,8 +37381,8 @@ function createNfrSpecStub(ctx) {
           },
           planFeatureKeywords: Array.isArray(args["planFeatureKeywords"]) ? args["planFeatureKeywords"] : void 0
         };
-        const outPath = join24(ctx.rootDir, "nfr-spec.json");
-        writeFileSync16(outPath, JSON.stringify(spec, null, 2), "utf8");
+        const outPath = join25(ctx.rootDir, "nfr-spec.json");
+        writeFileSync17(outPath, JSON.stringify(spec, null, 2), "utf8");
         return `NFR spec written to nfr-spec.json (${targets.length} target(s)).`;
       });
     }
@@ -37043,18 +37445,18 @@ function searchDocumentsStub(ctx) {
         (w) => w.length >= 3 && w !== "or" && w !== "and" && w !== "the"
       );
       const files = [
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "reviews")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "plan-tasks")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "milestones")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "reviews")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "plan-tasks")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "milestones")),
         workspaceFile(ctx.rootDir, "plan"),
         workspaceFile(ctx.rootDir, "risks")
       ];
       const results = [];
       for (const file2 of files) {
-        if (!existsSync28(file2)) continue;
-        const raw = readFileSync25(file2, "utf8");
+        if (!existsSync29(file2)) continue;
+        const raw = readFileSync26(file2, "utf8");
         const content = raw.toLowerCase();
         let idx = -1;
         let matchLen = 0;
@@ -37105,9 +37507,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(join24(ctx.rootDir, "decisions")),
-          ...ctx.storage.listMarkdown(join24(ctx.rootDir, "docs")),
-          ...ctx.storage.listMarkdown(join24(ctx.rootDir, "reviews"))
+          ...ctx.storage.listMarkdown(join25(ctx.rootDir, "decisions")),
+          ...ctx.storage.listMarkdown(join25(ctx.rootDir, "docs")),
+          ...ctx.storage.listMarkdown(join25(ctx.rootDir, "reviews"))
         ];
         const source = allFiles.find((f) => {
           try {
@@ -37138,9 +37540,9 @@ function getDocumentBacklinksStub(ctx) {
       const targetId = args["targetId"] ?? args["id"];
       if (!targetId) return "getDocumentBacklinks requires targetId.";
       const allFiles = [
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join24(ctx.rootDir, "reviews"))
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join25(ctx.rootDir, "reviews"))
       ];
       const backlinks = [];
       for (const file2 of allFiles) {
@@ -37235,7 +37637,7 @@ __export(updater_exports, {
 });
 import { createRequire as createRequire2 } from "node:module";
 import { spawn as spawn8 } from "node:child_process";
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 import path31 from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveBundledNpmCli(execPath = process.execPath) {
@@ -37248,7 +37650,7 @@ function resolveBundledNpmCli(execPath = process.execPath) {
   ];
   for (const candidate of candidates) {
     try {
-      if (existsSync29(candidate)) return candidate;
+      if (existsSync30(candidate)) return candidate;
     } catch {
     }
   }
@@ -37548,23 +37950,23 @@ var init_mcpClient = __esm({
 
 // src/cli/mcp/mcpConfigIo.ts
 import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync15,
-  readFileSync as readFileSync26,
-  writeFileSync as writeFileSync17
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync16,
+  readFileSync as readFileSync27,
+  writeFileSync as writeFileSync18
 } from "node:fs";
-import { dirname as dirname6, join as join25 } from "node:path";
+import { dirname as dirname7, join as join26 } from "node:path";
 import { homedir as homedir10 } from "node:os";
 function getUserMcpPath() {
-  return join25(homedir10(), ".zelari-code", "mcp.json");
+  return join26(homedir10(), ".zelari-code", "mcp.json");
 }
 function getProjectMcpPath(projectRoot) {
-  return join25(projectRoot, ".zelari", "mcp.json");
+  return join26(projectRoot, ".zelari", "mcp.json");
 }
 function readFile2(path53) {
-  if (!existsSync30(path53)) return {};
+  if (!existsSync31(path53)) return {};
   try {
-    const parsed = JSON.parse(readFileSync26(path53, "utf8"));
+    const parsed = JSON.parse(readFileSync27(path53, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -37581,9 +37983,9 @@ function readFile2(path53) {
   }
 }
 function writeFile(path53, servers) {
-  mkdirSync15(dirname6(path53), { recursive: true });
+  mkdirSync16(dirname7(path53), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync17(path53, `${JSON.stringify(body, null, 2)}
+  writeFileSync18(path53, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -37792,22 +38194,22 @@ __export(mcpManager_exports, {
   readMcpConfig: () => readMcpConfig,
   registerMcpTools: () => registerMcpTools
 });
-import { existsSync as existsSync31, readFileSync as readFileSync27 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync28 } from "node:fs";
+import { join as join27 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 function readMcpConfig(projectRoot = process.cwd(), opts) {
   const merged = {};
   const paths = [];
   if (process.env["ZELARI_MCP_USER"] !== "0") {
-    paths.push(join26(homedir11(), ".zelari-code", "mcp.json"));
+    paths.push(join27(homedir11(), ".zelari-code", "mcp.json"));
   }
   if (!opts?.skipProjectMcp) {
-    paths.push(join26(projectRoot, ".zelari", "mcp.json"));
+    paths.push(join27(projectRoot, ".zelari", "mcp.json"));
   }
   for (const p3 of paths) {
-    if (!existsSync31(p3)) continue;
+    if (!existsSync32(p3)) continue;
     try {
-      const parsed = JSON.parse(readFileSync27(p3, "utf8"));
+      const parsed = JSON.parse(readFileSync28(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;
@@ -37821,7 +38223,7 @@ async function ensureLoaded(projectRoot) {
   if (state2.loaded) return;
   state2.loaded = true;
   const trusted = isFolderTrusted(projectRoot);
-  if (!trusted && existsSync31(join26(projectRoot, ".zelari", "mcp.json"))) {
+  if (!trusted && existsSync32(join27(projectRoot, ".zelari", "mcp.json"))) {
     state2.warnings.push(
       "[mcp] project .zelari/mcp.json ignored \u2014 folder not trusted (run /trust or `zelari-code --trust` to enable project MCP)"
     );
@@ -38046,13 +38448,13 @@ __export(agentsMd_exports, {
   serializeAgentsMd: () => serializeAgentsMd,
   updateAgentsMd: () => updateAgentsMd
 });
-import { existsSync as existsSync32, readFileSync as readFileSync28, writeFileSync as writeFileSync18 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync29, writeFileSync as writeFileSync19 } from "node:fs";
 import { createHash as createHash8 } from "node:crypto";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 import { readFile as readFile3 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path53 = join27(projectRoot, "package.json");
-  if (!existsSync32(path53)) return null;
+  const path53 = join28(projectRoot, "package.json");
+  if (!existsSync33(path53)) return null;
   try {
     return JSON.parse(await readFile3(path53, "utf8"));
   } catch {
@@ -38076,8 +38478,8 @@ async function genTechStack(ctx) {
   ].join("\n");
 }
 async function genDecisions(ctx) {
-  const decisionsDir = join27(ctx.rootDir, "decisions");
-  if (!existsSync32(decisionsDir)) return "_No ADRs yet._";
+  const decisionsDir = join28(ctx.rootDir, "decisions");
+  if (!existsSync33(decisionsDir)) return "_No ADRs yet._";
   const files = ctx.storage.listMarkdown(decisionsDir).sort();
   const accepted = [];
   const proposed = [];
@@ -38102,9 +38504,9 @@ async function genDecisions(ctx) {
 }
 async function genConventions(ctx) {
   const lines = [];
-  const claudeMd = join27(ctx.projectRoot, "CLAUDE.MD");
-  if (existsSync32(claudeMd)) {
-    const content = readFileSync28(claudeMd, "utf8");
+  const claudeMd = join28(ctx.projectRoot, "CLAUDE.MD");
+  if (existsSync33(claudeMd)) {
+    const content = readFileSync29(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
     if (match) {
       lines.push('<!-- Extracted from CLAUDE.MD "Architecture rules" -->');
@@ -38136,9 +38538,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path53 = join27(ctx.rootDir, "risks.md");
-  if (!existsSync32(path53)) return "_No open questions._";
-  const content = readFileSync28(path53, "utf8");
+  const path53 = join28(ctx.rootDir, "risks.md");
+  if (!existsSync33(path53)) return "_No open questions._";
+  const content = readFileSync29(path53, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -38212,9 +38614,9 @@ function titleCase(id) {
   return id.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
 }
 async function updateAgentsMd(ctx, projectRoot) {
-  const agentsPath = join27(projectRoot, "AGENTS.MD");
-  if (existsSync32(agentsPath)) {
-    const content = readFileSync28(agentsPath, "utf8");
+  const agentsPath = join28(projectRoot, "AGENTS.MD");
+  if (existsSync33(agentsPath)) {
+    const content = readFileSync29(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id) => content.includes(MARKER_OPEN(id)));
     if (!hasAnyMarker) {
       return {
@@ -38229,8 +38631,8 @@ async function updateAgentsMd(ctx, projectRoot) {
     newSections.set(id, await GENERATORS[id](ctx));
   }
   let manualContent = "";
-  if (existsSync32(agentsPath)) {
-    const { manualBlocks } = parseAgentsMd(readFileSync28(agentsPath, "utf8"));
+  if (existsSync33(agentsPath)) {
+    const { manualBlocks } = parseAgentsMd(readFileSync29(agentsPath, "utf8"));
     manualContent = manualBlocks.after;
   } else {
     const projectName2 = projectName(projectRoot);
@@ -38246,7 +38648,7 @@ async function updateAgentsMd(ctx, projectRoot) {
       ""
     ].join("\n");
   }
-  const oldContent = existsSync32(agentsPath) ? readFileSync28(agentsPath, "utf8") : "";
+  const oldContent = existsSync33(agentsPath) ? readFileSync29(agentsPath, "utf8") : "";
   const { sections: oldSections } = parseAgentsMd(oldContent);
   const changedSections = [];
   for (const id of AUTO_SECTIONS) {
@@ -38258,7 +38660,7 @@ async function updateAgentsMd(ctx, projectRoot) {
     return { changed: false, sections: [] };
   }
   const newContent = serializeAgentsMd(manualContent, newSections);
-  writeFileSync18(agentsPath, newContent, "utf8");
+  writeFileSync19(agentsPath, newContent, "utf8");
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
@@ -38384,8 +38786,8 @@ var init_completeDesign = __esm({
 
 // src/cli/workspace/projectSmoke.ts
 import { spawn as spawn10 } from "node:child_process";
-import { existsSync as existsSync33, readFileSync as readFileSync29 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync34, readFileSync as readFileSync30 } from "node:fs";
+import { join as join29 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
   for (const name of SMOKE_SCRIPT_PRIORITY) {
@@ -38397,13 +38799,13 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS2) {
   if (process.env["ZELARI_SMOKE"] === "0") {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
-  const pkgPath = join28(projectRoot, "package.json");
-  if (!existsSync33(pkgPath)) {
+  const pkgPath = join29(projectRoot, "package.json");
+  if (!existsSync34(pkgPath)) {
     return { ran: false, reason: "no package.json (skipped)" };
   }
   let scripts = {};
   try {
-    const pkg = JSON.parse(readFileSync29(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync30(pkgPath, "utf8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return { ran: false, reason: "package.json unreadable (skipped)" };
@@ -38491,8 +38893,8 @@ __export(postCouncilHook_exports, {
   runPostCouncilHook: () => runPostCouncilHook
 });
 import { spawn as spawn11 } from "node:child_process";
-import { existsSync as existsSync34, readFileSync as readFileSync30 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync35, readFileSync as readFileSync31 } from "node:fs";
+import { join as join30 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
     return {
@@ -38503,9 +38905,9 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (process.env["ZELARI_COMPLETE_DESIGN"] === "0") {
     return { ran: false, reason: "ZELARI_COMPLETE_DESIGN=0 (disabled)" };
   }
-  const planJsonPath2 = join29(ctx.rootDir, "plan.json");
-  const scriptPath = join29(ctx.projectRoot, "complete-design.mjs");
-  if (!existsSync34(planJsonPath2)) {
+  const planJsonPath2 = join30(ctx.rootDir, "plan.json");
+  const scriptPath = join30(ctx.projectRoot, "complete-design.mjs");
+  if (!existsSync35(planJsonPath2)) {
     return {
       ran: false,
       reason: ".zelari/plan.json missing (not design-phase)"
@@ -38513,7 +38915,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   }
   let phaseCount = 0;
   try {
-    const parsed = JSON.parse(readFileSync30(planJsonPath2, "utf8"));
+    const parsed = JSON.parse(readFileSync31(planJsonPath2, "utf8"));
     phaseCount = Array.isArray(parsed.phases) ? parsed.phases.length : 0;
   } catch {
     return { ran: false, reason: ".zelari/plan.json corrupt" };
@@ -38521,7 +38923,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (phaseCount === 0) {
     return { ran: false, reason: ".zelari/plan.json has no phases" };
   }
-  if (!existsSync34(scriptPath)) {
+  if (!existsSync35(scriptPath)) {
     try {
       const builtin = await runBuiltinCompleteDesign(ctx);
       return {
@@ -38744,10 +39146,10 @@ __export(councilFeedback_exports, {
 });
 import {
   promises as fs16,
-  existsSync as existsSync35,
-  readFileSync as readFileSync31,
-  writeFileSync as writeFileSync19,
-  mkdirSync as mkdirSync16
+  existsSync as existsSync36,
+  readFileSync as readFileSync32,
+  writeFileSync as writeFileSync20,
+  mkdirSync as mkdirSync17
 } from "node:fs";
 import path32 from "node:path";
 import os9 from "node:os";
@@ -38853,9 +39255,9 @@ var init_councilFeedback = __esm({
       }
       // --- persistence ---------------------------------------------------------
       load() {
-        if (!existsSync35(this.file)) return;
+        if (!existsSync36(this.file)) return;
         try {
-          const raw = readFileSync31(this.file, "utf-8");
+          const raw = readFileSync32(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -38866,8 +39268,8 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync16(path32.dirname(this.file), { recursive: true });
-        writeFileSync19(
+        mkdirSync17(path32.dirname(this.file), { recursive: true });
+        writeFileSync20(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
           { encoding: "utf-8", mode: 384 }
@@ -41293,7 +41695,7 @@ __export(executor_exports, {
   resolveNodeTimeoutMs: () => resolveNodeTimeoutMs,
   thoroughnessForKind: () => thoroughnessForKind
 });
-import { existsSync as existsSync36 } from "node:fs";
+import { existsSync as existsSync37 } from "node:fs";
 import path40 from "node:path";
 function resolveMaxParallel(env = process.env) {
   const raw = env.ZELARI_KRAKEN_MAX_PARALLEL;
@@ -41352,7 +41754,7 @@ function isWorldModelGateEnabled(cwd, env = process.env, checksExists = defaultC
 }
 function defaultChecksExists(cwd) {
   try {
-    return existsSync36(path40.join(cwd, ".zelari", "world", "checks.json"));
+    return existsSync37(path40.join(cwd, ".zelari", "world", "checks.json"));
   } catch {
     return false;
   }
@@ -42319,8 +42721,8 @@ __export(prereqChecks_exports, {
   runPrereqChecks: () => runPrereqChecks
 });
 import { execSync, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync37 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { existsSync as existsSync38 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
 function isWslBashPath2(p3) {
   if (!p3 || typeof p3 !== "string") return false;
   const n = p3.replace(/\//g, "\\").toLowerCase();
@@ -42426,7 +42828,7 @@ function resolveAgentShellSync() {
 function agentProbeEnv() {
   const env = { ...process.env };
   try {
-    const nodeDir = dirname7(process.execPath);
+    const nodeDir = dirname8(process.execPath);
     if (!nodeDir) return env;
     const sep2 = process.platform === "win32" ? ";" : ":";
     const current = env.PATH ?? env.Path ?? "";
@@ -42443,7 +42845,7 @@ function agentProbeEnv() {
 }
 function existsSyncSafe2(p3) {
   try {
-    return existsSync37(p3);
+    return existsSync38(p3);
   } catch {
     return false;
   }
@@ -42690,7 +43092,7 @@ var init_prereqChecks = __esm({
 });
 
 // src/cli/plugins/prefs.ts
-import { existsSync as existsSync38, readFileSync as readFileSync32, writeFileSync as writeFileSync20, mkdirSync as mkdirSync17 } from "node:fs";
+import { existsSync as existsSync39, readFileSync as readFileSync33, writeFileSync as writeFileSync21, mkdirSync as mkdirSync18 } from "node:fs";
 import path43 from "node:path";
 import os10 from "node:os";
 function getPluginPrefsPath() {
@@ -42699,8 +43101,8 @@ function getPluginPrefsPath() {
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
   try {
-    if (!existsSync38(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
-    const raw = readFileSync32(file2, "utf-8");
+    if (!existsSync39(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
+    const raw = readFileSync33(file2, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && parsed.dontAskAgain && typeof parsed.dontAskAgain === "object") {
       const clean = {};
@@ -42715,8 +43117,8 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync17(path43.dirname(file2), { recursive: true });
-  writeFileSync20(file2, JSON.stringify(prefs, null, 2), {
+  mkdirSync18(path43.dirname(file2), { recursive: true });
+  writeFileSync21(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
@@ -42751,7 +43153,7 @@ __export(registry_exports, {
   findPlugin: () => findPlugin,
   isBinaryOnPath: () => isBinaryOnPath
 });
-import { existsSync as existsSync39 } from "node:fs";
+import { existsSync as existsSync40 } from "node:fs";
 import path44 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
@@ -42768,7 +43170,7 @@ function isBinaryOnPath(bin, opts = {}) {
     return false;
   }
   const platform = opts.platform ?? process.platform;
-  const exists = opts.exists ?? existsSync39;
+  const exists = opts.exists ?? existsSync40;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
   const pathMod = platform === "win32" ? path44.win32 : path44.posix;
   const sep2 = platform === "win32" ? ";" : ":";
@@ -43502,7 +43904,7 @@ __export(atMentions_exports, {
   extractAtMentions: () => extractAtMentions,
   hasAtMentions: () => hasAtMentions
 });
-import { existsSync as existsSync42, readFileSync as readFileSync34, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync43, readFileSync as readFileSync35, statSync as statSync7 } from "node:fs";
 import { basename as basename3, isAbsolute as isAbsolute2, relative as relative3, resolve, sep } from "node:path";
 function isImagePath(abs) {
   const ext = abs.split(".").pop()?.toLowerCase() ?? "";
@@ -43556,7 +43958,7 @@ function resolveMention(token, cwd) {
       note: "outside project root \u2014 skipped"
     };
   }
-  if (!existsSync42(abs)) {
+  if (!existsSync43(abs)) {
     return {
       raw: token,
       path: token,
@@ -43608,7 +44010,7 @@ function resolveMention(token, cwd) {
         note: `image too large (${Math.round(st.size / 1024)} KB) \u2014 path only`
       };
     }
-    const dataBase64 = readFileSync34(abs).toString("base64");
+    const dataBase64 = readFileSync35(abs).toString("base64");
     return {
       raw: token,
       path: rel2,
@@ -43619,7 +44021,7 @@ function resolveMention(token, cwd) {
     };
   }
   try {
-    const buf = readFileSync34(abs);
+    const buf = readFileSync35(abs);
     const head = buf.subarray(0, 800).toString("utf8");
     if (!isProbablyText(abs, head)) {
       return {
@@ -44116,14 +44518,14 @@ var init_skillCategories = __esm({
 
 // src/cli/skillConfigIo.ts
 import {
-  existsSync as existsSync44,
-  mkdirSync as mkdirSync20,
+  existsSync as existsSync45,
+  mkdirSync as mkdirSync21,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync36,
+  readFileSync as readFileSync37,
   rmSync as rmSync4,
-  writeFileSync as writeFileSync22
+  writeFileSync as writeFileSync23
 } from "node:fs";
-import { dirname as dirname9, join as join35 } from "node:path";
+import { dirname as dirname10, join as join36 } from "node:path";
 import { homedir as homedir12 } from "node:os";
 function ensureBuiltinSkillsLoadedSync() {
   if (builtinsLoaded) return;
@@ -44135,13 +44537,13 @@ function ensureBuiltinSkillsLoadedSync() {
   }
 }
 function getUserSkillsDir() {
-  return join35(homedir12(), ".zelari-code", "skills");
+  return join36(homedir12(), ".zelari-code", "skills");
 }
 function getProjectSkillsDir(projectRoot) {
-  return join35(projectRoot, ".zelari", "skills");
+  return join36(projectRoot, ".zelari", "skills");
 }
 function skillFilePath(dir, name) {
-  return join35(dir, name, "SKILL.md");
+  return join36(dir, name, "SKILL.md");
 }
 function classifyScope(skillPath, projectRoot) {
   const userDir = getUserSkillsDir().replace(/\\/g, "/");
@@ -44190,7 +44592,7 @@ function entryFromBuiltin(skill) {
   };
 }
 function scanSkillsDir(dir, projectRoot, seen, out) {
-  if (!existsSync44(dir)) return;
+  if (!existsSync45(dir)) return;
   let entries;
   try {
     entries = readdirSync9(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -44199,9 +44601,9 @@ function scanSkillsDir(dir, projectRoot, seen, out) {
   }
   for (const entry of entries) {
     const skillPath = skillFilePath(dir, entry);
-    if (!existsSync44(skillPath)) continue;
+    if (!existsSync45(skillPath)) continue;
     try {
-      const parsed = parseSkillMd(readFileSync36(skillPath, "utf8"), skillPath);
+      const parsed = parseSkillMd(readFileSync37(skillPath, "utf8"), skillPath);
       if (!parsed) continue;
       if (seen.has(parsed.name)) continue;
       seen.add(parsed.name);
@@ -44217,9 +44619,9 @@ function listSkillsSnapshot(projectRoot) {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
   if (root) {
-    scanSkillsDir(join35(root, ".zelari", "skills"), root, seen, skills);
-    scanSkillsDir(join35(root, ".claude", "skills"), root, seen, skills);
-    scanSkillsDir(join35(root, ".opencode", "skills"), root, seen, skills);
+    scanSkillsDir(join36(root, ".zelari", "skills"), root, seen, skills);
+    scanSkillsDir(join36(root, ".claude", "skills"), root, seen, skills);
+    scanSkillsDir(join36(root, ".opencode", "skills"), root, seen, skills);
   }
   scanSkillsDir(userSkillsDir, root, seen, skills);
   for (const s of listCodingSkills()) {
@@ -44298,8 +44700,8 @@ function upsertSkill(opts) {
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync20(dirname9(path53), { recursive: true });
-  writeFileSync22(path53, content, "utf8");
+  mkdirSync21(dirname10(path53), { recursive: true });
+  writeFileSync23(path53, content, "utf8");
   return { ok: true, path: path53 };
 }
 function removeSkill(opts) {
@@ -44317,9 +44719,9 @@ function removeSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const skillDir = join35(dir, name);
+  const skillDir = join36(dir, name);
   const path53 = skillFilePath(dir, name);
-  if (!existsSync44(path53) && !existsSync44(skillDir)) {
+  if (!existsSync45(path53) && !existsSync45(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -44624,36 +45026,36 @@ var init_permissionCli = __esm({
 
 // src/cli/companion/config.ts
 import {
-  existsSync as existsSync45,
-  mkdirSync as mkdirSync21,
-  readFileSync as readFileSync37,
-  writeFileSync as writeFileSync23
+  existsSync as existsSync46,
+  mkdirSync as mkdirSync22,
+  readFileSync as readFileSync38,
+  writeFileSync as writeFileSync24
 } from "node:fs";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 import { createHash as createHash9, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
-  return join36(homedir13(), ".zelari-code");
+  return join37(homedir13(), ".zelari-code");
 }
 function getCompanionConfigPath() {
-  return join36(getZelariHome(), "companion.json");
+  return join37(getZelariHome(), "companion.json");
 }
 function getCompanionTokenPath() {
-  return join36(getZelariHome(), "companion.token");
+  return join37(getZelariHome(), "companion.token");
 }
 function ensureHome() {
   const home = getZelariHome();
-  if (!existsSync45(home)) {
-    mkdirSync21(home, { recursive: true });
+  if (!existsSync46(home)) {
+    mkdirSync22(home, { recursive: true });
   }
 }
 function loadCompanionConfig() {
   const path53 = getCompanionConfigPath();
-  if (!existsSync45(path53)) {
+  if (!existsSync46(path53)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync37(path53, "utf8"));
+    const raw = JSON.parse(readFileSync38(path53, "utf8"));
     const projects = Array.isArray(raw.projects) ? raw.projects.filter(
       (p3) => p3 && typeof p3.path === "string" && p3.path.trim() && typeof (p3.id ?? p3.name) === "string"
     ).map((p3) => ({
@@ -44672,7 +45074,7 @@ function loadCompanionConfig() {
 }
 function saveCompanionConfig(cfg) {
   ensureHome();
-  writeFileSync23(
+  writeFileSync24(
     getCompanionConfigPath(),
     JSON.stringify(
       {
@@ -44692,12 +45094,12 @@ function loadOrCreateToken(explicit) {
   }
   ensureHome();
   const path53 = getCompanionTokenPath();
-  if (existsSync45(path53)) {
-    const t = readFileSync37(path53, "utf8").trim();
+  if (existsSync46(path53)) {
+    const t = readFileSync38(path53, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes5(24).toString("base64url");
-  writeFileSync23(path53, token + "\n", "utf8");
+  writeFileSync24(path53, token + "\n", "utf8");
   try {
     const fs31 = __require("node:fs");
     fs31.chmodSync?.(path53, 384);
@@ -44786,8 +45188,8 @@ var init_config = __esm({
 import { spawn as spawn13 } from "node:child_process";
 import { createInterface as createInterface2 } from "node:readline";
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { writeFileSync as writeFileSync24, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join37 } from "node:path";
+import { writeFileSync as writeFileSync25, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join38 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 var RunManager;
 var init_runManager = __esm({
@@ -44891,9 +45293,9 @@ var init_runManager = __esm({
         }
         let historyFile;
         if (args.history && Array.isArray(args.history) && args.history.length > 0) {
-          historyFile = join37(tmpdir3(), `zelari-companion-hist-${id}.json`);
+          historyFile = join38(tmpdir3(), `zelari-companion-hist-${id}.json`);
           try {
-            writeFileSync24(historyFile, JSON.stringify(args.history), "utf8");
+            writeFileSync25(historyFile, JSON.stringify(args.history), "utf8");
             argv.push("--history-file", historyFile);
           } catch {
             historyFile = void 0;
@@ -45018,7 +45420,7 @@ __export(serve_exports, {
   runCompanionServe: () => runCompanionServe
 });
 import { createServer as createServer3 } from "node:http";
-import { existsSync as existsSync46 } from "node:fs";
+import { existsSync as existsSync47 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
 function readBody(req, max = 2e6) {
   return new Promise((resolveBody, reject) => {
@@ -45066,7 +45468,7 @@ async function runCompanionServe(opts = {}) {
   let projects = mergeProjects(fileCfg, opts.projects ?? []);
   projects = projects.filter((p3) => {
     const abs = resolve2(p3.path);
-    if (!existsSync46(abs)) {
+    if (!existsSync47(abs)) {
       process.stderr.write(
         `[zelari-code serve] skip missing project path: ${p3.path}
 `
@@ -45388,7 +45790,7 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync47, readFileSync as readFileSync38, readlinkSync, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync48, readFileSync as readFileSync39, readlinkSync, statSync as statSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import path51 from "node:path";
@@ -45396,9 +45798,9 @@ function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
     const candidate = path51.join(dir, "package.json");
-    if (existsSync47(candidate)) {
+    if (existsSync48(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync38(candidate, "utf8"));
+        const pkg = JSON.parse(readFileSync39(candidate, "utf8"));
         if (pkg.name === "zelari-code") return dir;
       } catch {
       }
@@ -45422,7 +45824,7 @@ function tryExec(cmd) {
 function readPackageJson3() {
   try {
     const pkgPath = path51.join(packageRoot, "package.json");
-    return JSON.parse(readFileSync38(pkgPath, "utf8"));
+    return JSON.parse(readFileSync39(pkgPath, "utf8"));
   } catch {
     return null;
   }
@@ -45438,7 +45840,7 @@ function checkShim(pkgName) {
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
   const shimPath = path51.join(prefix, shimName);
-  if (!existsSync47(shimPath)) {
+  if (!existsSync48(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
          fix:  npm install -g ${pkgName}@latest --force`
@@ -45447,7 +45849,7 @@ function checkShim(pkgName) {
   try {
     const st = statSync8(shimPath);
     if (isWin) {
-      const content = readFileSync38(shimPath, "utf8");
+      const content = readFileSync39(shimPath, "utf8");
       if (content.includes(`${pkgName}\\bin\\`) || content.includes(`${pkgName}/bin/`)) {
         return OK(`shim OK at ${shimPath} (${st.size} bytes)`);
       }
@@ -45506,7 +45908,7 @@ function checkNode(pkg) {
 }
 function checkBundle() {
   const bundle = path51.join(packageRoot, "dist", "cli", "main.bundled.js");
-  if (!existsSync47(bundle)) {
+  if (!existsSync48(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
          fix:  npm run build:cli   (then reinstall or run via tsx)`
@@ -45887,7 +46289,7 @@ __export(inspect_exports, {
   runInspect: () => runInspect
 });
 import path52 from "node:path";
-import { existsSync as existsSync48, readFileSync as readFileSync39, readdirSync as readdirSync10 } from "node:fs";
+import { existsSync as existsSync49, readFileSync as readFileSync40, readdirSync as readdirSync10 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
@@ -45920,11 +46322,11 @@ async function collectInspectReport(cwd = process.cwd()) {
       folders: listTrustedFolders()
     },
     configSources: [
-      { path: userMcpPath, exists: existsSync48(userMcpPath) },
-      { path: projectMcpPath, exists: existsSync48(projectMcpPath) },
-      { path: path52.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync48(path52.join(homedir14(), ".zelari-code", "provider.json")) },
-      { path: path52.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync48(path52.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path52.join(cwd, "AGENTS.md"), exists: existsSync48(path52.join(cwd, "AGENTS.md")) }
+      { path: userMcpPath, exists: existsSync49(userMcpPath) },
+      { path: projectMcpPath, exists: existsSync49(projectMcpPath) },
+      { path: path52.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync49(path52.join(homedir14(), ".zelari-code", "provider.json")) },
+      { path: path52.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync49(path52.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path52.join(cwd, "AGENTS.md"), exists: existsSync49(path52.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -45937,7 +46339,7 @@ async function collectInspectReport(cwd = process.cwd()) {
       user: mcp.servers.filter((s) => s.scope === "user").map((s) => ({ name: s.name, enabled: s.enabled !== false })),
       project: mcp.servers.filter((s) => s.scope === "project").map((s) => ({ name: s.name, enabled: s.enabled !== false })),
       projectTrusted,
-      projectConfigExists: existsSync48(projectMcpPath)
+      projectConfigExists: existsSync49(projectMcpPath)
     },
     hooks: {
       global: {
@@ -45969,9 +46371,9 @@ function findAgentsMd(cwd) {
   ];
   const found = [];
   for (const c of candidates) {
-    if (existsSync48(c)) {
+    if (existsSync49(c)) {
       try {
-        const text = readFileSync39(c, "utf8");
+        const text = readFileSync40(c, "utf8");
         found.push(`${c} (${text.length} bytes)`);
       } catch {
         found.push(`${c} (unreadable)`);
@@ -53165,7 +53567,7 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs26, existsSync as existsSync40, readFileSync as readFileSync33, writeFileSync as writeFileSync21, mkdirSync as mkdirSync18, statSync as statSync5, rmSync as rmSync3 } from "node:fs";
+import { promises as fs26, existsSync as existsSync41, readFileSync as readFileSync34, writeFileSync as writeFileSync22, mkdirSync as mkdirSync19, statSync as statSync5, rmSync as rmSync3 } from "node:fs";
 import path46 from "node:path";
 import os12 from "node:os";
 var META_FILENAME = "meta.json";
@@ -53187,11 +53589,11 @@ function sessionsPathFor(name, baseDir) {
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
-  if (!existsSync40(metaPath)) {
+  if (!existsSync41(metaPath)) {
     throw new BranchNotFoundError(`Branch "${name}" not found`);
   }
   try {
-    const raw = readFileSync33(metaPath, "utf-8");
+    const raw = readFileSync34(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`);
@@ -53208,8 +53610,8 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync18(path46.dirname(metaPath), { recursive: true });
-  writeFileSync21(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
+  mkdirSync19(path46.dirname(metaPath), { recursive: true });
+  writeFileSync22(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
@@ -53247,7 +53649,7 @@ var SessionNotFoundError = class extends Error {
 };
 function branchExists(name, baseDir = getBranchesBaseDir()) {
   const bp = branchPathFor(name, baseDir);
-  return existsSync40(bp) && existsSync40(metaPathFor(name, baseDir));
+  return existsSync41(bp) && existsSync41(metaPathFor(name, baseDir));
 }
 async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(), sessionsBaseDir = getSessionsBaseDir()) {
   if (!name || name.trim().length === 0) {
@@ -53260,12 +53662,12 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
     throw new BranchAlreadyExistsError(name);
   }
   const sourcePath = path46.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
-  if (!existsSync40(sourcePath)) {
+  if (!existsSync41(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
-  mkdirSync18(branchSessionsPath, { recursive: true });
+  mkdirSync19(branchSessionsPath, { recursive: true });
   const destPath = path46.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs26.copyFile(sourcePath, destPath);
   const meta3 = {
@@ -53293,7 +53695,7 @@ async function listBranches(baseDir = getBranchesBaseDir()) {
   const results = [];
   for (const entry of entries) {
     const metaPath = metaPathFor(entry, baseDir);
-    if (!existsSync40(metaPath)) continue;
+    if (!existsSync41(metaPath)) continue;
     try {
       const meta3 = readBranchMeta(entry, baseDir);
       const sessionCount = await countSessions(entry, baseDir);
@@ -53484,7 +53886,7 @@ import path48 from "node:path";
 import os13 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs28, existsSync as existsSync41, statSync as statSync6, renameSync as renameSync4, appendFileSync as appendFileSync4, mkdirSync as mkdirSync19 } from "node:fs";
+import { promises as fs28, existsSync as existsSync42, statSync as statSync6, renameSync as renameSync5, appendFileSync as appendFileSync4, mkdirSync as mkdirSync20 } from "node:fs";
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
@@ -54812,9 +55214,9 @@ function ContinueKey({ onContinue }) {
 init_providerConfig();
 
 // src/cli/wizard/firstRun.ts
-import { existsSync as existsSync43 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 function shouldRunWizard(input) {
-  const exists = input.exists ?? existsSync43;
+  const exists = input.exists ?? existsSync44;
   if (input.hasResetConfigFlag) {
     return { shouldRun: true, reason: "--reset-config flag forced wizard" };
   }
@@ -55099,7 +55501,7 @@ init_keyStore();
 init_providerConfig();
 init_openai_compatible();
 init_phase();
-import { readFileSync as readFileSync35 } from "node:fs";
+import { readFileSync as readFileSync36 } from "node:fs";
 function parseHeadlessFlags(argv) {
   if (!argv.includes("--headless")) {
     return { options: null };
@@ -55172,7 +55574,7 @@ function parseHeadlessFlags(argv) {
         let raw = null;
         if (arg === "--history-file") {
           try {
-            raw = readFileSync35(next, "utf-8");
+            raw = readFileSync36(next, "utf-8");
           } catch {
             raw = null;
           }
@@ -55659,6 +56061,20 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   const sessionId = crypto.randomUUID();
   const { registry: toolRegistry } = createBuiltinToolRegistry({
     planMode: planModeFromOpts(opts),
+    // ADR-0018 3b: upgrade plan-task domain events to first-class NDJSON
+    // BrainEvents. Rust envelopes every stdout line with runId/conversationId,
+    // so task events ride the same multiplexed channel as the rest.
+    onTaskEvent: (ev) => {
+      if (opts.output !== "json") return;
+      emitEvent({
+        type: ev.type,
+        id: crypto.randomUUID(),
+        ts: Date.now(),
+        sessionId,
+        source: ev.source,
+        ...ev.type === "task_update" ? { task: ev.task } : { tasks: ev.tasks }
+      });
+    },
     permissionPolicy: {
       read: "allow",
       write: "allow",