zelari-code 1.27.1 → 1.28.0

package/dist/cli/main.bundled.js

@@ -1829,10 +1829,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path43) {
-  if (!path43)
+function getElementAtPath(obj, path44) {
+  if (!path44)
     return obj;
-  return path43.reduce((acc, key) => acc?.[key], obj);
+  return path44.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2160,11 +2160,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path43, issues) {
+function prefixIssues(path44, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path43);
+    iss.path.unshift(path44);
     return iss;
   });
 }
@@ -2382,16 +2382,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path43 = []) => {
+  const processError = (error52, path44 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path43, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path44, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path43, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path44, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path43, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path44, ...issue2.path]);
       } else {
-        const fullpath = [...path43, ...issue2.path];
+        const fullpath = [...path44, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -2418,17 +2418,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path43 = []) => {
+  const processError = (error52, path44 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path43, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path44, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path43, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path44, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path43, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path44, ...issue2.path]);
       } else {
-        const fullpath = [...path43, ...issue2.path];
+        const fullpath = [...path44, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2460,8 +2460,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path43 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path43) {
+  const path44 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path44) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -15964,13 +15964,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path43 = ref.slice(1).split("/").filter(Boolean);
-  if (path43.length === 0) {
+  const path44 = ref.slice(1).split("/").filter(Boolean);
+  if (path44.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path43[0] === defsKey) {
-    const key = path43[1];
+  if (path44[0] === defsKey) {
+    const key = path44[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18134,11 +18134,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path43 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path44 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path43,
+            path: path44,
             title,
             content,
             format: "markdown",
@@ -18147,7 +18147,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path43}".`;
+          return `Document "${title}" created at "${path44}".`;
         }
       }
     ];
@@ -21839,11 +21839,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join2 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path43 = join2(zelariRoot, "nfr-spec.json");
-  if (!existsSync6(path43))
+  const path44 = join2(zelariRoot, "nfr-spec.json");
+  if (!existsSync6(path44))
     return null;
   try {
-    const raw = JSON.parse(readFileSync5(path43, "utf8"));
+    const raw = JSON.parse(readFileSync5(path44, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -24149,9 +24149,9 @@ var init_types3 = __esm({
 import { readFileSync as readFileSync10 } from "node:fs";
 import { join as join8 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path43 = join8(zelariRoot, LESSONS_FILE);
+  const path44 = join8(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync10(path43, "utf8");
+    const raw = readFileSync10(path44, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -24252,8 +24252,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path43 = join9(zelariRoot, LESSONS_FILE);
-  appendFileSync(path43, `${JSON.stringify(lesson)}
+  const path44 = join9(zelariRoot, LESSONS_FILE);
+  appendFileSync(path44, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -24866,9 +24866,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path43 = [];
+    const path44 = [];
     color.set(start, GRAY);
-    path43.push(start);
+    path44.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id, idx] = top;
@@ -24881,17 +24881,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path43.indexOf(dep);
-          return [...path43.slice(at), dep];
+          const at = path44.indexOf(dep);
+          return [...path44.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path43.push(dep);
+          path44.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id, BLACK);
-        path43.pop();
+        path44.pop();
         stack.pop();
       }
     }
@@ -25700,9 +25700,9 @@ function spillToolOutput(fullText, meta3) {
     const rnd = randomBytes(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
     const file2 = `${stamp}-${safeTool}-${hash3}-${rnd}.txt`;
-    const path43 = join11(dir, file2);
-    writeFileSync10(path43, fullText, "utf8");
-    return path43;
+    const path44 = join11(dir, file2);
+    writeFileSync10(path44, fullText, "utf8");
+    return path44;
   } catch {
     return null;
   }
@@ -25748,10 +25748,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail}`;
   }
   if (doSpill) {
-    const path43 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path43) {
+    const path44 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path44) {
       const spillNote = `
-\u2026 [full output spilled to: ${path43} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path44} \u2014 re-read with read_file if you need the complete text] \u2026`;
       if (preview.includes("] \u2026\n")) {
         preview = preview.replace("] \u2026\n", `] \u2026${spillNote}
 `);
@@ -26581,11 +26581,20 @@ function maxToolCallsForThoroughness(thoroughness, agent) {
   if (thoroughness === "deep") return 12;
   return 6;
 }
-async function runSubAgent(harness) {
+async function runSubAgent(harness, opts = {}) {
+  const { signal } = opts;
   let current = "";
   let lastCompleted = "";
   let error51;
+  if (signal?.aborted) return { result: "", aborted: true };
   for await (const ev of harness.run()) {
+    if (signal?.aborted) {
+      return {
+        result: (lastCompleted || current).trim(),
+        ...error51 ? { error: error51 } : {},
+        aborted: true
+      };
+    }
     switch (ev.type) {
       case "message_start":
         current = "";
@@ -26715,8 +26724,31 @@ async function runTentacle(opts) {
       error: `task: failed to start sub-agent \u2014 ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const { result, error: error51 } = await runSubAgent(harness);
+  const { result, error: error51, aborted: aborted2 } = await runSubAgent(harness, {
+    ...opts.signal ? { signal: opts.signal } : {}
+  });
   const durationMs = Date.now() - started;
+  if (aborted2) {
+    if (worktree && !shouldKeepWorktree()) await cleanupKrakenWorktree(worktree);
+    appendKrakenRadio(parentCwd, sessionId, {
+      kind: "error",
+      agent,
+      thoroughness,
+      description: args.description,
+      detail: "cancelled: node timeout",
+      model: sub.model,
+      worktree: worktree?.path ?? null,
+      durationMs,
+      ok: false
+    });
+    krakenTentacleEnd(liveId, {
+      ok: false,
+      model: sub.model,
+      detail: "cancelled",
+      durationMs
+    });
+    return { ok: false, agent, error: "task: sub-agent cancelled (node timeout)", cancelled: true };
+  }
   if (!result) {
     if (worktree) await cleanupKrakenWorktree(worktree);
     appendKrakenRadio(parentCwd, sessionId, {
@@ -28660,21 +28692,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path43 = getSshSecretsPath();
-  if (!existsSync17(path43)) return {};
+  const path44 = getSshSecretsPath();
+  if (!existsSync17(path44)) return {};
   try {
-    return JSON.parse(readFileSync16(path43, "utf8"));
+    return JSON.parse(readFileSync16(path44, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path43 = getSshSecretsPath();
-  mkdirSync9(dirname2(path43), { recursive: true });
-  writeFileSync11(path43, `${JSON.stringify(data, null, 2)}
+  const path44 = getSshSecretsPath();
+  mkdirSync9(dirname2(path44), { recursive: true });
+  writeFileSync11(path44, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path43, 384);
+    chmodSync(path44, 384);
   } catch {
   }
 }
@@ -28703,10 +28735,10 @@ function deleteSshPassword(id) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path43 = getSshTargetsPath();
-  if (!existsSync17(path43)) return [];
+  const path44 = getSshTargetsPath();
+  if (!existsSync17(path44)) return [];
   try {
-    const parsed = JSON.parse(readFileSync16(path43, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path44, "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"
@@ -28721,11 +28753,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path43 = getSshTargetsPath();
-  mkdirSync9(dirname2(path43), { recursive: true });
+  const path44 = getSshTargetsPath();
+  mkdirSync9(dirname2(path44), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync11(
-    path43,
+    path44,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -28971,11 +29003,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path43 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path44 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
     const allow = t.allowedCommands?.length ? ` allowed=${t.allowedCommands.join("|")}` : " allowed=status-only";
     const auth = t.auth === "password" ? " auth=password" : t.auth === "keyPath" ? " auth=key" : " auth=agent";
     lines.push(
-      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path43}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path44}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -31827,28 +31859,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path43) {
-        if (!existsSync25(path43)) {
-          throw new Error(`File not found: ${path43}`);
+      read(path44) {
+        if (!existsSync25(path44)) {
+          throw new Error(`File not found: ${path44}`);
         }
-        const md = readFileSync21(path43, "utf8");
+        const md = readFileSync21(path44, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path43) {
-        if (!existsSync25(path43)) return null;
-        return this.read(path43);
+      readIfExists(path44) {
+        if (!existsSync25(path44)) return null;
+        return this.read(path44);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path43, meta3, body) {
-        mkdirSync11(dirname4(path43), { recursive: true });
-        const tmp = path43 + ".tmp-" + process.pid;
+      write(path44, meta3, body) {
+        mkdirSync11(dirname4(path44), { recursive: true });
+        const tmp = path44 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync13(tmp, md, "utf8");
-        renameSync2(tmp, path43);
+        renameSync2(tmp, path44);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -31926,8 +31958,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path43 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path43);
+  const path44 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path44);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -32092,7 +32124,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path43 = join23(ctx.rootDir, "milestones", `${id}.md`);
+  const path44 = join23(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -32109,7 +32141,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path43, meta3, body);
+  ctx.storage.write(path44, meta3, body);
   return { id, created: true };
 }
 function readPlanSummary(ctx) {
@@ -32313,7 +32345,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path43 = workspaceArtifact(ctx.rootDir, "decisions", id);
+        const path44 = workspaceArtifact(ctx.rootDir, "decisions", id);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -32339,7 +32371,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path43, meta3, body);
+        ctx.storage.write(path44, meta3, body);
         return `ADR ${id} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -32421,14 +32453,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path43 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path44 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path43, meta3, content);
+        ctx.storage.write(path44, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -32972,10 +33004,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join24(projectRoot, ".zelari", "mcp.json");
 }
-function readFile2(path43) {
-  if (!existsSync28(path43)) return {};
+function readFile2(path44) {
+  if (!existsSync28(path44)) return {};
   try {
-    const parsed = JSON.parse(readFileSync23(path43, "utf8"));
+    const parsed = JSON.parse(readFileSync23(path44, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -32991,10 +33023,10 @@ function readFile2(path43) {
     return {};
   }
 }
-function writeFile(path43, servers) {
-  mkdirSync13(dirname6(path43), { recursive: true });
+function writeFile(path44, servers) {
+  mkdirSync13(dirname6(path44), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync15(path43, `${JSON.stringify(body, null, 2)}
+  writeFileSync15(path44, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -33027,9 +33059,9 @@ function upsertMcpServer(opts) {
   if (!opts.config.command?.trim()) {
     return { ok: false, error: "command is required" };
   }
-  let path43;
+  let path44;
   if (opts.scope === "user") {
-    path43 = getUserMcpPath();
+    path44 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -33038,30 +33070,30 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path43 = getProjectMcpPath(root);
+    path44 = getProjectMcpPath(root);
   }
-  const current = readFile2(path43);
+  const current = readFile2(path44);
   current[name] = {
     command: opts.config.command.trim(),
     args: opts.config.args,
     env: opts.config.env,
     enabled: opts.config.enabled !== false
   };
-  writeFile(path43, current);
-  return { ok: true, path: path43 };
+  writeFile(path44, current);
+  return { ok: true, path: path44 };
 }
 function removeMcpServer(opts) {
-  const path43 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path43) {
+  const path44 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path44) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile2(path43);
+  const current = readFile2(path44);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path43}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path44}` };
   }
   delete current[opts.name];
-  writeFile(path43, current);
-  return { ok: true, path: path43 };
+  writeFile(path44, current);
+  return { ok: true, path: path44 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -33398,10 +33430,10 @@ import { createHash as createHash5 } from "node:crypto";
 import { join as join26 } from "node:path";
 import { readFile as readFile3 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path43 = join26(projectRoot, "package.json");
-  if (!existsSync30(path43)) return null;
+  const path44 = join26(projectRoot, "package.json");
+  if (!existsSync30(path44)) return null;
   try {
-    return JSON.parse(await readFile3(path43, "utf8"));
+    return JSON.parse(await readFile3(path44, "utf8"));
   } catch {
     return null;
   }
@@ -33483,9 +33515,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path43 = join26(ctx.rootDir, "risks.md");
-  if (!existsSync30(path43)) return "_No open questions._";
-  const content = readFileSync25(path43, "utf8");
+  const path44 = join26(ctx.rootDir, "risks.md");
+  if (!existsSync30(path44)) return "_No open questions._";
+  const content = readFileSync25(path44, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -34052,8 +34084,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path43 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path43, completion };
+      const path44 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path44, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -35272,7 +35304,8 @@ __export(planner_exports, {
   PlannerTransportError: () => PlannerTransportError,
   buildGraphFromPlan: () => buildGraphFromPlan,
   extractJsonObject: () => extractJsonObject,
-  planTaskGraph: () => planTaskGraph
+  planTaskGraph: () => planTaskGraph,
+  stripReasoningBlocks: () => stripReasoningBlocks
 });
 function resolvePlannerTimeoutMs(env = process.env) {
   const raw = env.ZELARI_KRAKEN_PLANNER_TIMEOUT_MS;
@@ -35286,22 +35319,77 @@ function resolvePlannerMaxTokens(env = process.env) {
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_LLM_MAX_TOKENS;
 }
-function extractJsonObject(text) {
-  const trimmed = text.trim();
-  const fenced = /^```(?:json)?\s*([\s\S]*?)```$/i.exec(trimmed);
-  const body = fenced ? fenced[1].trim() : trimmed;
-  const balanced = extractBalancedJsonObject2(body);
-  const candidate = balanced ?? body;
+function extractJsonObject(text, opts = {}) {
+  const stripped = stripReasoningBlocks(text);
+  const usable = findJsonIn(stripped, opts);
+  if (usable) return usable.value;
+  const raw = findJsonIn(text, opts);
+  if (raw) return raw.value;
+  const body = bodyOf(stripped) || bodyOf(text);
   try {
-    return JSON.parse(candidate);
+    return JSON.parse(body);
   } catch (err) {
     try {
-      return JSON.parse(repairLooseJson(candidate));
+      return JSON.parse(repairLooseJson(body));
     } catch {
       throw err instanceof Error ? err : new Error(String(err));
     }
   }
 }
+function bodyOf(text) {
+  const trimmed = text.trim();
+  const fenced = /^```(?:json)?\s*([\s\S]*?)```$/i.exec(trimmed);
+  return fenced ? fenced[1].trim() : trimmed;
+}
+function findJsonIn(text, opts) {
+  let firstParsed = null;
+  for (const candidate of balancedJsonObjects(bodyOf(text))) {
+    let value;
+    try {
+      value = JSON.parse(candidate);
+    } catch {
+      try {
+        value = JSON.parse(repairLooseJson(candidate));
+      } catch {
+        continue;
+      }
+    }
+    if (!opts.requireKey) return { value };
+    if (value && typeof value === "object" && opts.requireKey in value) {
+      return { value };
+    }
+    const unwrapped = unwrapKey(value, opts.requireKey);
+    if (unwrapped) return { value: unwrapped };
+    if (!firstParsed) firstParsed = { value };
+  }
+  return firstParsed;
+}
+function unwrapKey(value, key) {
+  if (!value || typeof value !== "object") return null;
+  for (const child of Object.values(value)) {
+    if (child && typeof child === "object" && key in child) {
+      return child;
+    }
+  }
+  return null;
+}
+function stripReasoningBlocks(text) {
+  let out = text.replace(/<(think|thinking|reasoning)>[\s\S]*?<\/\1>/gi, "");
+  const openIdx = out.search(/<(think|thinking|reasoning)>/i);
+  if (openIdx >= 0) out = out.slice(0, openIdx);
+  return out;
+}
+function* balancedJsonObjects(s) {
+  let from = 0;
+  while (from < s.length) {
+    const next = extractBalancedJsonObject2(s.slice(from));
+    if (!next) return;
+    yield next;
+    const idx = s.indexOf(next, from);
+    if (idx < 0) return;
+    from = idx + next.length;
+  }
+}
 function extractBalancedJsonObject2(s) {
   const start = s.indexOf("{");
   if (start < 0) return null;
@@ -35328,6 +35416,23 @@ function extractBalancedJsonObject2(s) {
   }
   return null;
 }
+function escapeJsonControlChar(c) {
+  if (c >= " ") return c;
+  switch (c) {
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "	":
+      return "\\t";
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    default:
+      return `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`;
+  }
+}
 function repairLooseJson(s) {
   let out = "";
   let i = 0;
@@ -35339,15 +35444,16 @@ function repairLooseJson(s) {
       i += 1;
       while (i < n) {
         const c = s[i];
-        out += c;
         i += 1;
         if (c === "\\") {
+          out += c;
           if (i < n) {
             out += s[i];
             i += 1;
           }
           continue;
         }
+        out += escapeJsonControlChar(c);
         if (c === '"') break;
       }
       continue;
@@ -35366,7 +35472,7 @@ function repairLooseJson(s) {
           i += 1;
           break;
         }
-        value += c;
+        value += escapeJsonControlChar(c);
         i += 1;
       }
       out += `"${value.replace(/"/g, '\\"')}"`;
@@ -35509,10 +35615,13 @@ async function createDefaultLlmClient(opts) {
     }
   };
 }
-function buildPlannerUserPrompt(prompt) {
+function buildPlannerUserPrompt(prompt, previousAttempt) {
+  const prev2 = previousAttempt?.trim() ? `
+${previousAttempt.trim()}
+` : "";
   return `Goal:
 ${prompt.trim()}
-
+${prev2}
 Return ONLY the JSON object described in the system prompt.`;
 }
 function uniqueId(base, existing) {
@@ -35579,14 +35688,19 @@ async function planTaskGraph(opts) {
   const client = opts.llmClient ?? await createDefaultLlmClient({ provider: opts.provider, model: opts.model });
   const maxNodes = opts.maxNodes ?? DEFAULT_MAX_NODES;
   const graphId = opts.graphId ?? `kraken-${Date.now().toString(36)}`;
-  const userBase = buildPlannerUserPrompt(opts.prompt);
+  const userBase = buildPlannerUserPrompt(opts.prompt, opts.previousAttempt);
   let lastError;
   let userMessage = userBase;
   for (let attempt = 1; attempt <= MAX_PLAN_ATTEMPTS; attempt++) {
     try {
       const text = await client.complete({ system: KRAKEN_PLANNER_SYSTEM_PROMPT, user: userMessage });
-      const parsedJson = extractJsonObject(text);
+      const parsedJson = extractJsonObject(text, { requireKey: "nodes" });
       const validated = PlannedGraphSchema.parse(parsedJson);
+      if (!validated.nodes.some((n) => n.kind === "general")) {
+        throw new Error(
+          'the plan contains no "general" node, so it cannot change anything \u2014 every node is read-only "explore". Include at least one "general" node that performs the actual work.'
+        );
+      }
       const graph = buildGraphFromPlan(graphId, validated.nodes);
       const check2 = validateGraph(graph, { maxNodes });
       if (!check2.ok) {
@@ -35664,6 +35778,93 @@ var init_planner = __esm({
   }
 });
 
+// src/cli/kraken/graphMemory.ts
+var graphMemory_exports = {};
+__export(graphMemory_exports, {
+  formatSnapshotForPlanner: () => formatSnapshotForPlanner,
+  loadGraphSnapshot: () => loadGraphSnapshot,
+  saveGraphSnapshot: () => saveGraphSnapshot,
+  toGraphSnapshot: () => toGraphSnapshot
+});
+import { promises as fs19 } from "node:fs";
+import path34 from "node:path";
+function snapshotPath(cwd) {
+  return path34.join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
+}
+function toGraphSnapshot(graph, opts) {
+  return {
+    graphId: graph.id,
+    goal: opts.goal,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    converged: opts.converged,
+    nodes: [...graph.nodes.values()].map((n) => ({
+      id: n.id,
+      kind: n.kind,
+      label: n.label,
+      status: n.status,
+      ...n.scope && n.scope.length > 0 ? { scope: n.scope } : {},
+      ...n.error ? { error: n.error.slice(0, 300) } : {}
+    }))
+  };
+}
+async function saveGraphSnapshot(cwd, snapshot) {
+  try {
+    await fs19.access(cwd);
+    const file2 = snapshotPath(cwd);
+    await fs19.mkdir(path34.dirname(file2), { recursive: true });
+    await fs19.writeFile(file2, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+async function loadGraphSnapshot(cwd) {
+  try {
+    const raw = await fs19.readFile(snapshotPath(cwd), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.nodes)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function formatSnapshotForPlanner(snapshot) {
+  if (!snapshot) return "";
+  const done = snapshot.nodes.filter((n) => n.status === "done");
+  const failed = snapshot.nodes.filter((n) => n.status === "error");
+  const skipped = snapshot.nodes.filter((n) => n.status === "skipped");
+  if (failed.length === 0 && skipped.length === 0) return "";
+  const line = (n) => `- ${n.label}${n.scope ? ` [${n.scope.join(", ")}]` : ""}${n.error ? ` \u2014 ${n.error}` : ""}`;
+  const parts = [
+    "",
+    "## Previous unfinished task graph in this project",
+    `Goal it was working on: "${snapshot.goal}"`,
+    `It did NOT finish (${done.length} done, ${failed.length} failed, ${skipped.length} never ran).`,
+    "",
+    "If that goal is unrelated to the one above, ignore this section entirely.",
+    ""
+  ];
+  if (done.length > 0) {
+    parts.push("Already completed \u2014 do NOT redo this work:", ...done.map(line), "");
+  }
+  if (failed.length > 0) {
+    parts.push("Failed \u2014 needs to be finished or repaired:", ...failed.map(line), "");
+  }
+  if (skipped.length > 0) {
+    parts.push("Never ran (blocked by the failures above):", ...skipped.map(line), "");
+  }
+  parts.push(
+    "Plan only the remaining work. Inspect what is already on disk before rewriting it, and prefer wiring/finishing existing modules over recreating them."
+  );
+  return parts.join("\n");
+}
+var SNAPSHOT_DIR, SNAPSHOT_FILE;
+var init_graphMemory = __esm({
+  "src/cli/kraken/graphMemory.ts"() {
+    "use strict";
+    SNAPSHOT_DIR = path34.join(".zelari", "kraken");
+    SNAPSHOT_FILE = "last-graph.json";
+  }
+});
+
 // src/cli/kraken/tentacle.ts
 var init_tentacle = __esm({
   "src/cli/kraken/tentacle.ts"() {
@@ -35675,18 +35876,21 @@ var init_tentacle = __esm({
 // src/cli/kraken/executor.ts
 var executor_exports = {};
 __export(executor_exports, {
+  DEFAULT_CANCEL_GRACE_MS: () => DEFAULT_CANCEL_GRACE_MS,
   DEFAULT_FIX_BUDGET: () => DEFAULT_FIX_BUDGET,
   DEFAULT_MAX_PARALLEL: () => DEFAULT_MAX_PARALLEL,
   DEFAULT_NODE_TIMEOUT_MS: () => DEFAULT_NODE_TIMEOUT_MS,
+  DEFAULT_WRITER_NODE_TIMEOUT_MS: () => DEFAULT_WRITER_NODE_TIMEOUT_MS,
   KrakenGraphExecutor: () => KrakenGraphExecutor,
   isKrakenGraphEnabled: () => isKrakenGraphEnabled,
   isWorldModelGateEnabled: () => isWorldModelGateEnabled,
+  resolveCancelGraceMs: () => resolveCancelGraceMs,
   resolveFixBudget: () => resolveFixBudget,
   resolveMaxParallel: () => resolveMaxParallel,
   resolveNodeTimeoutMs: () => resolveNodeTimeoutMs
 });
 import { existsSync as existsSync34 } from "node:fs";
-import path34 from "node:path";
+import path35 from "node:path";
 function resolveMaxParallel(env = process.env) {
   const raw = env.ZELARI_KRAKEN_MAX_PARALLEL;
   if (raw === void 0 || raw === "") return DEFAULT_MAX_PARALLEL;
@@ -35699,11 +35903,27 @@ function resolveFixBudget(env = process.env) {
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n >= 0 ? n : DEFAULT_FIX_BUDGET;
 }
-function resolveNodeTimeoutMs(env = process.env) {
-  const raw = env.ZELARI_KRAKEN_NODE_TIMEOUT_MS;
-  if (raw === void 0 || raw === "") return DEFAULT_NODE_TIMEOUT_MS;
+function resolveCancelGraceMs(env = process.env) {
+  const raw = env.ZELARI_KRAKEN_CANCEL_GRACE_MS;
+  if (raw === void 0 || raw === "") return DEFAULT_CANCEL_GRACE_MS;
   const n = Number.parseInt(raw, 10);
-  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_NODE_TIMEOUT_MS;
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_CANCEL_GRACE_MS;
+}
+function resolveNodeTimeoutMs(env = process.env, agent) {
+  const raw = env.ZELARI_KRAKEN_NODE_TIMEOUT_MS;
+  if (raw !== void 0 && raw !== "") {
+    const n = Number.parseInt(raw, 10);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  if (agent === "general") {
+    const rawWriter = env.ZELARI_KRAKEN_WRITER_NODE_TIMEOUT_MS;
+    if (rawWriter !== void 0 && rawWriter !== "") {
+      const n = Number.parseInt(rawWriter, 10);
+      if (Number.isFinite(n) && n >= 0) return n;
+    }
+    return DEFAULT_WRITER_NODE_TIMEOUT_MS;
+  }
+  return DEFAULT_NODE_TIMEOUT_MS;
 }
 function isKrakenGraphEnabled(env = process.env) {
   return env.ZELARI_KRAKEN_GRAPH !== "0";
@@ -35714,12 +35934,12 @@ function isWorldModelGateEnabled(cwd, env = process.env, checksExists = defaultC
 }
 function defaultChecksExists(cwd) {
   try {
-    return existsSync34(path34.join(cwd, ".zelari", "world", "checks.json"));
+    return existsSync34(path35.join(cwd, ".zelari", "world", "checks.json"));
   } catch {
     return false;
   }
 }
-var DEFAULT_MAX_PARALLEL, DEFAULT_FIX_BUDGET, DEFAULT_NODE_TIMEOUT_MS, KrakenGraphExecutor;
+var DEFAULT_MAX_PARALLEL, DEFAULT_FIX_BUDGET, DEFAULT_NODE_TIMEOUT_MS, DEFAULT_WRITER_NODE_TIMEOUT_MS, DEFAULT_CANCEL_GRACE_MS, KrakenGraphExecutor;
 var init_executor = __esm({
   "src/cli/kraken/executor.ts"() {
     "use strict";
@@ -35729,15 +35949,21 @@ var init_executor = __esm({
     init_krakenRadio();
     init_worldModel();
     init_graphStatus();
+    init_graphMemory();
     DEFAULT_MAX_PARALLEL = 12;
     DEFAULT_FIX_BUDGET = 3;
     DEFAULT_NODE_TIMEOUT_MS = 3e5;
+    DEFAULT_WRITER_NODE_TIMEOUT_MS = 9e5;
+    DEFAULT_CANCEL_GRACE_MS = 3e4;
     KrakenGraphExecutor = class {
       deps;
       parentCwd;
       sessionId;
+      goal;
       maxParallel;
+      /** Explicit all-kinds override; when undefined the budget is per-kind. */
       nodeTimeoutMs;
+      cancelGraceMs;
       fixBudgetRemaining;
       worldModelGateOverride;
       runTentacleFn;
@@ -35749,8 +35975,10 @@ var init_executor = __esm({
         this.deps = opts.taskToolDeps;
         this.parentCwd = opts.parentCwd;
         this.sessionId = opts.sessionId;
+        this.goal = opts.goal;
         this.maxParallel = opts.maxParallel ?? resolveMaxParallel();
-        this.nodeTimeoutMs = opts.nodeTimeoutMs ?? resolveNodeTimeoutMs();
+        this.nodeTimeoutMs = opts.nodeTimeoutMs;
+        this.cancelGraceMs = opts.cancelGraceMs;
         this.fixBudgetRemaining = opts.fixBudget ?? resolveFixBudget();
         this.worldModelGateOverride = opts.worldModelGate;
         this.runTentacleFn = opts.runTentacleFn ?? runTentacle;
@@ -35808,6 +36036,10 @@ var init_executor = __esm({
           });
         }
         endKrakenGraphLive(graph, converged);
+        await saveGraphSnapshot(
+          this.parentCwd,
+          toGraphSnapshot(graph, { goal: this.goal ?? graph.id, converged })
+        );
         return {
           graph,
           converged,
@@ -35824,6 +36056,7 @@ var init_executor = __esm({
         }
         const usesWorktree = node.kind === "general" || node.kind === "fix";
         const agent = node.kind === "fix" ? "general" : node.kind;
+        const controller = new AbortController();
         const res = await this.withNodeTimeout(
           this.runTentacleFn({
             deps: this.deps,
@@ -35841,9 +36074,11 @@ var init_executor = __esm({
             // (Correction 4); explore/verify never create a worktree.
             deferMerge: usesWorktree,
             graphId: graph.id,
-            nodeId: node.id
+            nodeId: node.id,
+            signal: controller.signal
           }),
-          agent
+          agent,
+          controller
         );
         if (res.ok && usesWorktree) {
           this.nodeRunState.set(node.id, { worktreeHandle: res.worktreeHandle });
@@ -35851,25 +36086,50 @@ var init_executor = __esm({
         return res;
       }
       /**
-       * Bound a tentacle run to `nodeTimeoutMs` wall-clock. On timeout, resolves
-       * to a synthetic `TentacleFailure` so the normal retry/fix/cascade-skip
-       * path handles it — this only bounds how long the EXECUTOR waits, it does
-       * not (cannot) forcibly cancel the underlying sub-agent run; the point is
-       * to guarantee `execute()` itself always settles so the caller's process
-       * can exit instead of hanging forever on one stuck node.
+       * Bound a tentacle run to its wall-clock budget (explicit `nodeTimeoutMs`
+       * option, else per-kind — writers get more than readers). On timeout the
+       * run is CANCELLED via its AbortSignal, then given `cancelGraceMs` to
+       * unwind. Cancellation lands at the sub-agent's next event boundary (an
+       * async generator only observes `.return()` when it next yields), so a run
+       * blocked on a slow provider call can outlive the grace period — that case
+       * resolves with `cancelled: false` and `applyResult` refuses to re-spawn
+       * the node, since a tentacle that may still be writing must not be joined
+       * by a second one on the same scope.
+       *
+       * Either way `execute()` always settles, so the caller's process can exit
+       * instead of hanging forever on one stuck node.
        */
-      withNodeTimeout(promise2, agent) {
-        if (this.nodeTimeoutMs <= 0) return promise2;
-        const ms = this.nodeTimeoutMs;
+      async withNodeTimeout(promise2, agent, controller) {
+        const ms = this.nodeTimeoutMs ?? resolveNodeTimeoutMs(process.env, agent);
+        if (ms <= 0) return promise2;
         let timer;
+        const TIMED_OUT = Symbol("timeout");
         const timeout = new Promise((resolve3) => {
-          timer = setTimeout(() => {
-            resolve3({ ok: false, agent, error: `tentacle timed out after ${ms}ms` });
-          }, ms);
+          timer = setTimeout(() => resolve3(TIMED_OUT), ms);
         });
-        return Promise.race([promise2, timeout]).finally(() => {
+        const raced = await Promise.race([promise2, timeout]).finally(() => {
           if (timer) clearTimeout(timer);
         });
+        if (raced !== TIMED_OUT) return raced;
+        controller?.abort();
+        const graceMs = this.cancelGraceMs ?? resolveCancelGraceMs();
+        let graceTimer;
+        const grace = new Promise((resolve3) => {
+          graceTimer = setTimeout(() => resolve3(TIMED_OUT), graceMs);
+        });
+        const settled = await Promise.race([promise2, grace]).finally(() => {
+          if (graceTimer) clearTimeout(graceTimer);
+        });
+        if (settled !== TIMED_OUT) {
+          if (settled.ok) return settled;
+          return { ...settled, cancelled: true };
+        }
+        return {
+          ok: false,
+          agent,
+          error: `tentacle timed out after ${ms}ms and did not stop within ${graceMs}ms of being cancelled; not retrying to avoid two tentacles writing the same scope`,
+          cancelled: false
+        };
       }
       /**
        * Sequentially merge every dep node's deferred worktree (in dep order) into
@@ -35933,6 +36193,16 @@ var init_executor = __esm({
           return;
         }
         node.error = res.error;
+        if (res.cancelled === false) {
+          node.status = "error";
+          this.radio("node_end", {
+            description: node.label,
+            agent: node.kind,
+            detail: res.error,
+            ok: false
+          });
+          return;
+        }
         if (node.retryCount < node.maxRetries) {
           node.retryCount += 1;
           node.status = "pending";
@@ -36421,10 +36691,10 @@ var init_prereqChecks = __esm({
 
 // src/cli/plugins/prefs.ts
 import { existsSync as existsSync36, readFileSync as readFileSync29, writeFileSync as writeFileSync18, mkdirSync as mkdirSync15 } from "node:fs";
-import path35 from "node:path";
+import path36 from "node:path";
 import os9 from "node:os";
 function getPluginPrefsPath() {
-  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path35.join(os9.homedir(), ".tmp", "zelari-code", "plugins.json");
+  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path36.join(os9.homedir(), ".tmp", "zelari-code", "plugins.json");
 }
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
@@ -36445,7 +36715,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync15(path35.dirname(file2), { recursive: true });
+  mkdirSync15(path36.dirname(file2), { recursive: true });
   writeFileSync18(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -36482,7 +36752,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync37 } from "node:fs";
-import path36 from "node:path";
+import path37 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -36500,7 +36770,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync37;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path36.win32 : path36.posix;
+  const pathMod = platform === "win32" ? path37.win32 : path37.posix;
   const sep2 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep2).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -36809,10 +37079,10 @@ __export(triggerLock_exports, {
   lockPath: () => lockPath,
   releaseLock: () => releaseLock
 });
-import { promises as fs23 } from "node:fs";
-import * as path41 from "node:path";
+import { promises as fs24 } from "node:fs";
+import * as path42 from "node:path";
 function lockPath(projectRoot) {
-  return path41.join(projectRoot, ".zelari", "trigger.lock");
+  return path42.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -36825,10 +37095,10 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path41.dirname(lp);
-  await fs23.mkdir(dir, { recursive: true });
+  const dir = path42.dirname(lp);
+  await fs24.mkdir(dir, { recursive: true });
   try {
-    const raw = await fs23.readFile(lp, "utf8");
+    const raw = await fs24.readFile(lp, "utf8");
     const existing = JSON.parse(raw);
     if (existing.pid && isPidAlive(existing.pid)) {
       return { acquired: false, heldBy: existing.pid, lockPath: lp };
@@ -36839,13 +37109,13 @@ async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date())
     pid: process.pid,
     acquiredAt: now().toISOString()
   };
-  await fs23.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  await fs24.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
   return { acquired: true, lockPath: lp };
 }
 async function releaseLock(projectRoot) {
   const lp = lockPath(projectRoot);
   try {
-    await fs23.unlink(lp);
+    await fs24.unlink(lp);
   } catch {
   }
 }
@@ -37133,12 +37403,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path43 = getCompanionConfigPath();
-  if (!existsSync43(path43)) {
+  const path44 = getCompanionConfigPath();
+  if (!existsSync43(path44)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync34(path43, "utf8"));
+    const raw = JSON.parse(readFileSync34(path44, "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) => ({
@@ -37176,16 +37446,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path43 = getCompanionTokenPath();
-  if (existsSync43(path43)) {
-    const t = readFileSync34(path43, "utf8").trim();
+  const path44 = getCompanionTokenPath();
+  if (existsSync43(path44)) {
+    const t = readFileSync34(path44, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes3(24).toString("base64url");
-  writeFileSync21(path43, token + "\n", "utf8");
+  writeFileSync21(path44, token + "\n", "utf8");
   try {
-    const fs24 = __require("node:fs");
-    fs24.chmodSync?.(path43, 384);
+    const fs25 = __require("node:fs");
+    fs25.chmodSync?.(path44, 384);
   } catch {
   }
   return { token, created: true };
@@ -37210,17 +37480,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path43 = raw.trim();
-    if (!path43) continue;
-    let id = slugFromPath(path43);
+    const path44 = raw.trim();
+    if (!path44) continue;
+    let id = slugFromPath(path44);
     let n = 2;
-    while (byId.has(id) && byId.get(id).path !== path43) {
-      id = `${slugFromPath(path43)}-${n++}`;
+    while (byId.has(id) && byId.get(id).path !== path44) {
+      id = `${slugFromPath(path44)}-${n++}`;
     }
     byId.set(id, {
       id,
-      name: slugFromPath(path43),
-      path: path43
+      name: slugFromPath(path44),
+      path: path44
     });
   }
   return [...byId.values()];
@@ -37597,9 +37867,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path43 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path44 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path43 === "/health" || path43 === "/v1/health")) {
+      if (req.method === "GET" && (path44 === "/health" || path44 === "/v1/health")) {
         sendJson(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -37611,18 +37881,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path43.startsWith("/v1")) {
+      if (path44.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path43 === "/v1/config") {
+      if (req.method === "GET" && path44 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path43 === "/v1/projects") {
+      if (req.method === "GET" && path44 === "/v1/projects") {
         sendJson(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -37633,7 +37903,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path43 === "/v1/runs") {
+      if (req.method === "GET" && path44 === "/v1/runs") {
         sendJson(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -37651,7 +37921,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path43 === "/v1/runs") {
+      if (req.method === "POST" && path44 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -37698,7 +37968,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path43);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path44);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -37763,7 +38033,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path43);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path44);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -37875,11 +38145,11 @@ import { execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync45, readFileSync as readFileSync35, readlinkSync, statSync as statSync7 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import path42 from "node:path";
+import path43 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path42.join(dir, "package.json");
+    const candidate = path43.join(dir, "package.json");
     if (existsSync45(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync35(candidate, "utf8"));
@@ -37887,11 +38157,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path42.dirname(dir);
+    const parent = path43.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path42.resolve(__dirname3, "..", "..", "..");
+  return path43.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -37905,7 +38175,7 @@ function tryExec(cmd) {
 }
 function readPackageJson3() {
   try {
-    const pkgPath = path42.join(packageRoot, "package.json");
+    const pkgPath = path43.join(packageRoot, "package.json");
     return JSON.parse(readFileSync35(pkgPath, "utf8"));
   } catch {
     return null;
@@ -37921,7 +38191,7 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path42.join(prefix, shimName);
+  const shimPath = path43.join(prefix, shimName);
   if (!existsSync45(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
@@ -37949,8 +38219,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path42.resolve(path42.dirname(shimPath), target);
-    const expected = path42.join(
+    const resolved = path43.resolve(path43.dirname(shimPath), target);
+    const expected = path43.join(
       prefix,
       "node_modules",
       pkgName,
@@ -37989,7 +38259,7 @@ function checkNode(pkg) {
   return OK(`node ${raw}`);
 }
 function checkBundle() {
-  const bundle = path42.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path43.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync45(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -38010,7 +38280,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path42.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path43.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -38186,7 +38456,7 @@ var init_doctor = __esm({
     "use strict";
     init_prereqChecks();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path42.dirname(fileURLToPath2(import.meta.url));
+    __dirname3 = path43.dirname(fileURLToPath2(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -44601,6 +44871,7 @@ init_krakenRadio();
 init_auditLogger();
 init_toolRegistry();
 init_planner();
+init_graphMemory();
 init_executor();
 init_graphStatus();
 async function handleKrakenGraph(ctx, prompt) {
@@ -44625,12 +44896,22 @@ async function handleKrakenGraph(ctx, prompt) {
     })
   };
   try {
-    const graph = await planTaskGraph({ prompt, graphId: `kraken-${Date.now().toString(36)}` });
+    const previous = await loadGraphSnapshot(ctx.cwd);
+    const previousAttempt = formatSnapshotForPlanner(previous);
+    if (previousAttempt) {
+      appendSystem(ctx.setMessages, "[kraken] resuming from the previous unfinished graph");
+    }
+    const graph = await planTaskGraph({
+      prompt,
+      graphId: `kraken-${Date.now().toString(36)}`,
+      ...previousAttempt ? { previousAttempt } : {}
+    });
     appendSystem(ctx.setMessages, formatKrakenGraphAscii(graph));
     const executor = new KrakenGraphExecutor({
       taskToolDeps,
       parentCwd: ctx.cwd,
-      sessionId: ctx.sessionId
+      sessionId: ctx.sessionId,
+      goal: prompt
     });
     const summary = await executor.execute(graph);
     appendSystem(
@@ -44944,17 +45225,17 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 }
 
 // src/cli/slashHandlers/promoteMember.ts
-import { promises as fs19 } from "node:fs";
-import path37 from "node:path";
+import { promises as fs20 } from "node:fs";
+import path38 from "node:path";
 import os10 from "node:os";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
-    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path37.join(os10.homedir(), ".tmp", "zelari-code", "skills");
-    await fs19.mkdir(skillDir, { recursive: true });
-    const filePath = path37.join(skillDir, `${skill.id}.md`);
-    await fs19.writeFile(filePath, markdown, "utf8");
+    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path38.join(os10.homedir(), ".tmp", "zelari-code", "skills");
+    await fs20.mkdir(skillDir, { recursive: true });
+    const filePath = path38.join(skillDir, `${skill.id}.md`);
+    await fs20.writeFile(filePath, markdown, "utf8");
     appendSystem(
       ctx.setMessages,
       `[promote-member] ${skill.name} (${memberId}) \u2192 ${filePath}
@@ -44970,25 +45251,25 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs20, existsSync as existsSync38, readFileSync as readFileSync30, writeFileSync as writeFileSync19, mkdirSync as mkdirSync16, statSync as statSync4, rmSync as rmSync3 } from "node:fs";
-import path38 from "node:path";
+import { promises as fs21, existsSync as existsSync38, readFileSync as readFileSync30, writeFileSync as writeFileSync19, mkdirSync as mkdirSync16, statSync as statSync4, rmSync as rmSync3 } from "node:fs";
+import path39 from "node:path";
 import os11 from "node:os";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
-  return process.env.ANATHEMA_BRANCHES_DIR ?? path38.join(os11.homedir(), ".tmp", "zelari-code", "branches");
+  return process.env.ANATHEMA_BRANCHES_DIR ?? path39.join(os11.homedir(), ".tmp", "zelari-code", "branches");
 }
 function getSessionsBaseDir() {
-  return process.env.ANATHEMA_SESSIONS_DIR ?? path38.join(os11.homedir(), ".tmp", "zelari-code", "sessions");
+  return process.env.ANATHEMA_SESSIONS_DIR ?? path39.join(os11.homedir(), ".tmp", "zelari-code", "sessions");
 }
 function branchPathFor(name, baseDir) {
-  return path38.join(baseDir, name);
+  return path39.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path38.join(baseDir, name, META_FILENAME);
+  return path39.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path38.join(baseDir, name, SESSIONS_SUBDIR);
+  return path39.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -45013,13 +45294,13 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync16(path38.dirname(metaPath), { recursive: true });
+  mkdirSync16(path39.dirname(metaPath), { recursive: true });
   writeFileSync19(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
   try {
-    const entries = await fs20.readdir(sessionsPath);
+    const entries = await fs21.readdir(sessionsPath);
     return entries.filter((e) => e.endsWith(".jsonl")).length;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
@@ -45064,15 +45345,15 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path38.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path39.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync38(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync16(branchSessionsPath, { recursive: true });
-  const destPath = path38.join(branchSessionsPath, `${fromSessionId}.jsonl`);
-  await fs20.copyFile(sourcePath, destPath);
+  const destPath = path39.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  await fs21.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
     createdAt: Date.now(),
@@ -45090,7 +45371,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
 async function listBranches(baseDir = getBranchesBaseDir()) {
   let entries;
   try {
-    entries = await fs20.readdir(baseDir);
+    entries = await fs21.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -45171,26 +45452,26 @@ async function handleBranchCheckout(ctx, branchName) {
 }
 
 // src/cli/slashHandlers/workspace.ts
-import { promises as fs21 } from "node:fs";
-import path39 from "node:path";
+import { promises as fs22 } from "node:fs";
+import path40 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path39.join(process.cwd(), ".zelari");
+    const zelari = path40.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path39.join(zelari, "plan.md");
+        const planPath = path40.join(zelari, "plan.md");
         try {
-          content = await fs21.readFile(planPath, "utf-8");
+          content = await fs22.readFile(planPath, "utf-8");
         } catch {
           content = "(no plan.md yet \u2014 run a council session first)";
         }
         break;
       }
       case "decisions": {
-        const decisionsDir = path39.join(zelari, "decisions");
+        const decisionsDir = path40.join(zelari, "decisions");
         try {
-          const files = (await fs21.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs22.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
             content = "(no ADRs yet \u2014 invoke /council to generate some)";
           } else {
@@ -45198,7 +45479,7 @@ async function handleWorkspaceShow(ctx, what) {
 `];
             const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
             for (const f of files) {
-              const raw = await fs21.readFile(path39.join(decisionsDir, f), "utf-8");
+              const raw = await fs22.readFile(path40.join(decisionsDir, f), "utf-8");
               const { meta: meta3, body } = parseFrontmatter2(raw);
               const title = meta3.title ?? body.split("\n")[0]?.replace(/^#\s*/, "").trim() ?? f;
               lines.push(`- **${f.replace(/\.md$/, "")}** [${meta3.status ?? "unknown"}] ${title}`);
@@ -45211,27 +45492,27 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path39.join(zelari, "risks.md");
+        const risksPath = path40.join(zelari, "risks.md");
         try {
-          content = await fs21.readFile(risksPath, "utf-8");
+          content = await fs22.readFile(risksPath, "utf-8");
         } catch {
           content = "(no risks.md yet)";
         }
         break;
       }
       case "agents": {
-        const agentsPath = path39.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path40.join(process.cwd(), "AGENTS.MD");
         try {
-          content = await fs21.readFile(agentsPath, "utf-8");
+          content = await fs22.readFile(agentsPath, "utf-8");
         } catch {
           content = "(no AGENTS.MD yet at project root \u2014 run `/workspace sync` after a council session)";
         }
         break;
       }
       case "docs": {
-        const docsDir = path39.join(zelari, "docs");
+        const docsDir = path40.join(zelari, "docs");
         try {
-          const files = (await fs21.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs22.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
 
 ` + files.map((f) => `- ${f}`).join("\n") : "(no docs drafts yet)";
@@ -45271,8 +45552,8 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path39.join(process.cwd(), ".zelari");
-    await fs21.rm(target, { recursive: true, force: true });
+    const target = path40.join(process.cwd(), ".zelari");
+    await fs22.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
     appendSystem(ctx.setMessages, `[workspace reset error] ${err instanceof Error ? err.message : String(err)}`);
@@ -45631,16 +45912,16 @@ function handleModelsRefresh(ctx) {
 }
 
 // src/cli/slashHandlers/skills.ts
-import path40 from "node:path";
+import path41 from "node:path";
 import os12 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs22, existsSync as existsSync39, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync4, mkdirSync as mkdirSync17 } from "node:fs";
+import { promises as fs23, existsSync as existsSync39, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync4, mkdirSync as mkdirSync17 } from "node:fs";
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
   try {
-    raw = await fs22.readFile(file2, "utf-8");
+    raw = await fs23.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -45757,7 +46038,7 @@ function handleSkillPicker(ctx, skills, openPicker, fallbackMessage) {
   });
 }
 async function handleSkillStats(ctx, skillId) {
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path40.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path41.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const records = await readSkillHistory(historyFile);
     const stats = getSkillStats(records, skillId);
@@ -45773,7 +46054,7 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
     appendSystem(ctx.setMessages, fallbackMessage ?? "[skill-compare] missing args");
     return;
   }
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path40.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path41.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const formatted = await compareSkillsFromFile(ids[0], ids[1], historyFile);
     appendSystem(ctx.setMessages, formatted);
@@ -47498,6 +47779,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     return 1;
   }
   const { planTaskGraph: planTaskGraph2 } = await Promise.resolve().then(() => (init_planner(), planner_exports));
+  const { loadGraphSnapshot: loadGraphSnapshot2, formatSnapshotForPlanner: formatSnapshotForPlanner2 } = await Promise.resolve().then(() => (init_graphMemory(), graphMemory_exports));
   const { formatKrakenGraphAscii: formatKrakenGraphAscii2 } = await Promise.resolve().then(() => (init_graphStatus(), graphStatus_exports));
   const { AuditLogger: AuditLogger2 } = await Promise.resolve().then(() => (init_auditLogger(), auditLogger_exports));
   const { createKrakenSubAgentContextFactory: createKrakenSubAgentContextFactory2 } = await Promise.resolve().then(() => (init_toolRegistry(), toolRegistry_exports));
@@ -47513,7 +47795,15 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   };
   try {
     log(`planning kraken graph: ${prompt}`);
-    const graph = await planTaskGraph2({ prompt, provider, model });
+    const previous = await loadGraphSnapshot2(cwd);
+    const previousAttempt = formatSnapshotForPlanner2(previous);
+    if (previousAttempt) log("resuming from the previous unfinished graph");
+    const graph = await planTaskGraph2({
+      prompt,
+      provider,
+      model,
+      ...previousAttempt ? { previousAttempt } : {}
+    });
     log(formatKrakenGraphAscii2(graph));
     const audit = new AuditLogger2();
     const executor = new KrakenGraphExecutor2({
@@ -47532,7 +47822,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
         })
       },
       parentCwd: cwd,
-      sessionId
+      sessionId,
+      goal: prompt
     });
     const summary = await executor.execute(graph);
     const finalAscii = formatKrakenGraphAscii2(summary.graph);
@@ -48677,7 +48968,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path43 = skillFilePath(dir, name);
+  const path44 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -48686,13 +48977,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path43);
+  const parsed = parseSkillMd(content, path44);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync18(dirname9(path43), { recursive: true });
-  writeFileSync20(path43, content, "utf8");
-  return { ok: true, path: path43 };
+  mkdirSync18(dirname9(path44), { recursive: true });
+  writeFileSync20(path44, content, "utf8");
+  return { ok: true, path: path44 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -48710,8 +49001,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join34(dir, name);
-  const path43 = skillFilePath(dir, name);
-  if (!existsSync42(path43) && !existsSync42(skillDir)) {
+  const path44 = skillFilePath(dir, name);
+  if (!existsSync42(path44) && !existsSync42(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -48722,7 +49013,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path43 };
+  return { ok: true, path: path44 };
 }
 
 // src/cli/generateSkillFromUrl.ts
@@ -48812,8 +49103,8 @@ function normalizeDraft(raw, sourceUrl, provider, model) {
   let name = String(o.name ?? "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
   if (!name || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
     try {
-      const path43 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
-      name = path43 && /^[a-z0-9]/.test(path43) ? path43 : "imported-skill";
+      const path44 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+      name = path44 && /^[a-z0-9]/.test(path44) ? path44 : "imported-skill";
     } catch {
       name = "imported-skill";
     }