zelari-code 1.27.2 → 1.29.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();
       }
     }
@@ -25074,14 +25074,6 @@ function canRunParallel(a, b) {
   }
   return false;
 }
-function selectParallelWave(candidates) {
-  const wave = [];
-  for (const node of candidates) {
-    if (wave.every((w) => canRunParallel(w, node)))
-      wave.push(node);
-  }
-  return wave;
-}
 var READ_ONLY_KINDS, WRITER_KINDS;
 var init_conflict = __esm({
   "packages/core/dist/kraken/conflict.js"() {
@@ -25091,12 +25083,49 @@ var init_conflict = __esm({
   }
 });
 
+// packages/core/dist/kraken/verdict.js
+function parseVerifyVerdict(text) {
+  const source = typeof text === "string" ? text : "";
+  if (source.trim() === "")
+    return { verdict: "unknown", findings: "" };
+  VERDICT_LINE.lastIndex = 0;
+  let match;
+  let last = null;
+  while ((match = VERDICT_LINE.exec(source)) !== null) {
+    last = match;
+    if (match.index === VERDICT_LINE.lastIndex)
+      VERDICT_LINE.lastIndex += 1;
+  }
+  if (!last) {
+    return { verdict: "unknown", findings: capFindings(source) };
+  }
+  const verdict = last[1].toUpperCase() === "FAIL" ? "fail" : "pass";
+  const findings = capFindings(source.slice(0, last.index));
+  return { verdict, findings };
+}
+function capFindings(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length <= MAX_FINDINGS_CHARS)
+    return trimmed;
+  return `${trimmed.slice(0, MAX_FINDINGS_CHARS)}
+\u2026 [truncated]`;
+}
+var MAX_FINDINGS_CHARS, VERDICT_LINE;
+var init_verdict = __esm({
+  "packages/core/dist/kraken/verdict.js"() {
+    "use strict";
+    MAX_FINDINGS_CHARS = 2800;
+    VERDICT_LINE = /^[\s>*_-]*VERDICT[\s*_]*:[\s*_]*(PASS|FAIL)\b/gim;
+  }
+});
+
 // packages/core/dist/kraken/index.js
 var init_kraken = __esm({
   "packages/core/dist/kraken/index.js"() {
     "use strict";
     init_graph();
     init_conflict();
+    init_verdict();
   }
 });
 
@@ -25118,8 +25147,11 @@ var init_dist = __esm({
 // src/cli/kraken/graphStatus.ts
 var graphStatus_exports = {};
 __export(graphStatus_exports, {
+  DEFAULT_DIGEST_RESULT_CHARS: () => DEFAULT_DIGEST_RESULT_CHARS,
   endKrakenGraphLive: () => endKrakenGraphLive,
+  formatDuration: () => formatDuration2,
   formatKrakenGraphAscii: () => formatKrakenGraphAscii,
+  formatKrakenGraphDigest: () => formatKrakenGraphDigest,
   formatKrakenGraphSummary: () => formatKrakenGraphSummary,
   getKrakenGraphLive: () => getKrakenGraphLive,
   resetKrakenGraphLive: () => resetKrakenGraphLive,
@@ -25147,6 +25179,46 @@ function formatKrakenGraphAscii(graph) {
   if (lines.length === 0) return summary;
   return [summary, ...lines].join("\n");
 }
+function formatDuration2(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "?";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const totalSeconds = Math.round(ms / 1e3);
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const m = Math.floor(totalSeconds / 60);
+  const s = totalSeconds % 60;
+  return s === 0 ? `${m}m` : `${m}m${s}s`;
+}
+function formatKrakenGraphDigest(graph, opts = {}) {
+  const maxChars = opts.maxResultChars ?? DEFAULT_DIGEST_RESULT_CHARS;
+  const durations = opts.durationsMs ?? {};
+  const ordered = topoLevels(graph).flat();
+  for (const id of graph.nodes.keys()) {
+    if (!ordered.includes(id)) ordered.push(id);
+  }
+  const lines = [];
+  for (const id of ordered) {
+    const n = graph.nodes.get(id);
+    if (!n) continue;
+    const took = durations[id] !== void 0 ? `, ${formatDuration2(durations[id])}` : "";
+    const detail = n.status === "error" ? n.error : n.result;
+    const firstLine2 = (detail ?? "").trim().split("\n")[0] ?? "";
+    const body = firstLine2.length > maxChars ? `${firstLine2.slice(0, maxChars)}\u2026` : firstLine2;
+    lines.push(
+      `[${STATUS_ICON[n.status]}] ${n.id} (${n.kind}${took})${body ? ` \u2014 ${body}` : ""}`
+    );
+  }
+  const unresolved = opts.unresolvedFindings ?? [];
+  if (unresolved.length > 0) {
+    lines.push("", "unresolved verify findings:");
+    for (const u of unresolved) {
+      const why = u.reason === "fail" ? "rejected, rework budget spent" : "no parseable verdict";
+      const detail = u.findings.trim().split("\n")[0]?.trim() ?? "";
+      const body = detail.length > maxChars ? `${detail.slice(0, maxChars)}\u2026` : detail;
+      lines.push(`  ${u.nodeId} (${why})${body ? ` \u2014 ${body}` : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
 function state() {
   return globalThis;
 }
@@ -25195,7 +25267,7 @@ function formatKrakenGraphSummary() {
   if (live.error) parts.push(`${live.error}\u2717`);
   return `graph ${parts.join(" \xB7 ")}`;
 }
-var STATUS_ICON;
+var STATUS_ICON, DEFAULT_DIGEST_RESULT_CHARS;
 var init_graphStatus = __esm({
   "src/cli/kraken/graphStatus.ts"() {
     "use strict";
@@ -25207,6 +25279,7 @@ var init_graphStatus = __esm({
       error: "\u2717",
       skipped: "\xBB"
     };
+    DEFAULT_DIGEST_RESULT_CHARS = 200;
   }
 });
 
@@ -25700,9 +25773,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 +25821,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 +26654,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 = "";
@@ -26612,7 +26694,7 @@ async function runTentacle(opts) {
   const started = Date.now();
   const g = globalThis;
   let worktree = null;
-  let effectiveCwd = parentCwd;
+  let effectiveCwd = opts.cwdOverride || parentCwd;
   const wantWt = agent === "general" && deps.allowWorktree !== false && isKrakenWorktreeEnabled();
   if (wantWt) {
     try {
@@ -26715,8 +26797,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 +28765,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 +28808,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 +28826,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 +29076,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 +31932,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 +32031,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 +32197,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 +32214,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 +32418,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 +32444,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 +32526,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 +33077,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 +33096,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 +33132,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 +33143,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 +33503,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 +33588,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 +34157,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,
@@ -35271,9 +35376,17 @@ __export(planner_exports, {
   KRAKEN_PLANNER_SYSTEM_PROMPT: () => KRAKEN_PLANNER_SYSTEM_PROMPT,
   PlannerTransportError: () => PlannerTransportError,
   buildGraphFromPlan: () => buildGraphFromPlan,
+  buildPlannerUserPrompt: () => buildPlannerUserPrompt,
   extractJsonObject: () => extractJsonObject,
-  planTaskGraph: () => planTaskGraph
+  planTaskGraph: () => planTaskGraph,
+  stripReasoningBlocks: () => stripReasoningBlocks
 });
+function resolvePlannerWorkspaceChars(env = process.env) {
+  const raw = env.ZELARI_KRAKEN_PLANNER_WORKSPACE_CHARS;
+  if (raw === void 0 || raw === "") return DEFAULT_PLANNER_WORKSPACE_CHARS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_PLANNER_WORKSPACE_CHARS;
+}
 function resolvePlannerTimeoutMs(env = process.env) {
   const raw = env.ZELARI_KRAKEN_PLANNER_TIMEOUT_MS;
   if (raw === void 0 || raw === "") return DEFAULT_LLM_TIMEOUT_MS;
@@ -35286,22 +35399,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;
@@ -35527,11 +35695,32 @@ async function createDefaultLlmClient(opts) {
     }
   };
 }
-function buildPlannerUserPrompt(prompt) {
-  return `Goal:
-${prompt.trim()}
-
-Return ONLY the JSON object described in the system prompt.`;
+function resolveWorkspaceListing(opts) {
+  if (opts.workspace !== void 0) return opts.workspace || void 0;
+  if (!opts.cwd) return void 0;
+  const maxChars = resolvePlannerWorkspaceChars();
+  if (maxChars <= 0) return void 0;
+  try {
+    return buildWorkspaceSummary(opts.cwd, { maxEntries: 24, maxChars }) || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildPlannerUserPrompt(prompt, opts = {}) {
+  const parts = [`Goal:
+${prompt.trim()}`];
+  if (opts.workspace?.trim()) {
+    parts.push(
+      "",
+      "## The project this goal is about (real files on disk)",
+      opts.workspace.trim()
+    );
+  }
+  if (opts.previousAttempt?.trim()) {
+    parts.push("", opts.previousAttempt.trim());
+  }
+  parts.push("", "Return ONLY the JSON object described in the system prompt.");
+  return parts.join("\n");
 }
 function uniqueId(base, existing) {
   if (!existing.has(base)) return base;
@@ -35540,11 +35729,40 @@ function uniqueId(base, existing) {
   return `${base}-${i}`;
 }
 function buildAutoVerifyPrompt(general) {
-  const acc = general.acceptance && general.acceptance.length > 0 ? `
-
-Acceptance criteria to check:
-${general.acceptance.map((a) => `- ${a}`).join("\n")}` : "";
-  return `Verify the following work was completed correctly on disk: ${general.label}.${acc}`;
+  const taskPrompt = general.prompt.length > MAX_VERIFY_TASK_PROMPT_CHARS ? `${general.prompt.slice(0, MAX_VERIFY_TASK_PROMPT_CHARS)}
+\u2026 [truncated]` : general.prompt;
+  const parts = [
+    `Verify on disk that this work was actually completed correctly: ${general.label}.`,
+    "",
+    "## The task that was carried out",
+    taskPrompt
+  ];
+  if (general.scope && general.scope.length > 0) {
+    parts.push("", "## Paths the work was scoped to", ...general.scope.map((s) => `- ${s}`));
+  }
+  if (general.acceptance && general.acceptance.length > 0) {
+    parts.push(
+      "",
+      "## Acceptance criteria to check explicitly",
+      ...general.acceptance.map((a) => `- ${a}`)
+    );
+  }
+  parts.push(
+    "",
+    "Read the files involved rather than trusting any summary. Report the commands you ran and every gap you found.",
+    "",
+    "## How to report your verdict",
+    "End your final message with a line of exactly this form, as the LAST line:",
+    "",
+    "VERDICT: PASS",
+    "",
+    "or",
+    "",
+    "VERDICT: FAIL",
+    "",
+    "This line is parsed. FAIL sends the work back to the tentacle that wrote it, together with everything you write above the line \u2014 so state each gap concretely enough to be acted on (file, what is wrong, what it should be). Only report FAIL for a real defect against the task or its acceptance criteria: a rework round is expensive and there is only a small number of them. Stylistic preferences are not a FAIL."
+  );
+  return parts.join("\n");
 }
 function buildGraphFromPlan(graphId, planned) {
   const nodes = planned.map((p3) => ({
@@ -35597,14 +35815,23 @@ 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 workspace = resolveWorkspaceListing(opts);
+  const userBase = buildPlannerUserPrompt(opts.prompt, {
+    ...opts.previousAttempt ? { previousAttempt: opts.previousAttempt } : {},
+    ...workspace ? { workspace } : {}
+  });
   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) {
@@ -35623,7 +35850,7 @@ Your previous response was invalid (${lastError}). Return ONLY corrected JSON ma
     `kraken planner: failed to produce a valid task graph after ${MAX_PLAN_ATTEMPTS} attempts \u2014 ${lastError}`
   );
 }
-var MAX_PLAN_ATTEMPTS, DEFAULT_LLM_TIMEOUT_MS, PlannerTransportError, DEFAULT_LLM_MAX_TOKENS, DEFAULT_MAX_RETRIES, KRAKEN_PLANNER_SYSTEM_PROMPT, PlannedNodeSchema, PlannedGraphSchema;
+var MAX_PLAN_ATTEMPTS, DEFAULT_PLANNER_WORKSPACE_CHARS, DEFAULT_LLM_TIMEOUT_MS, PlannerTransportError, DEFAULT_LLM_MAX_TOKENS, DEFAULT_MAX_RETRIES, KRAKEN_PLANNER_SYSTEM_PROMPT, PlannedNodeSchema, PlannedGraphSchema, MAX_VERIFY_TASK_PROMPT_CHARS;
 var init_planner = __esm({
   "src/cli/kraken/planner.ts"() {
     "use strict";
@@ -35632,7 +35859,9 @@ var init_planner = __esm({
     init_providerConfig();
     init_keyStore();
     init_openai_compatible();
+    init_workspaceSummary();
     MAX_PLAN_ATTEMPTS = 2;
+    DEFAULT_PLANNER_WORKSPACE_CHARS = 3e3;
     DEFAULT_LLM_TIMEOUT_MS = 3e5;
     PlannerTransportError = class extends Error {
       constructor(message) {
@@ -35660,12 +35889,14 @@ var init_planner = __esm({
       '- kind "general": can edit files for one bounded, self-contained unit of work.',
       '- Do NOT emit "verify", "fix", or "merge" nodes \u2014 the executor adds those automatically.',
       '- "id" must be short, unique, kebab-case (e.g. "e1", "g-auth", "g-ui").',
-      '- "prompt" must be fully self-contained: the sub-agent sees ONLY this prompt, not this conversation.',
+      '- "prompt" must be self-contained: the sub-agent sees ONLY this prompt, not this conversation.',
       '- "deps" lists ids of nodes that must finish first (topological order); [] if none.',
+      '- A node DOES receive what its "deps" reported when they finished \u2014 the executor injects their conclusions into its prompt. So write a dependent node as "using the findings above, \u2026" rather than duplicating the research its dependency will do.',
       '- When two "general" nodes touch disjoint parts of the codebase, give each a "scope" (path/glob allowlist) so they can run in parallel safely. If scopes might overlap, either omit scope (forces sequential execution) or add a dep between them.',
+      '- The user message includes a listing of the real project on disk. Build every "scope" from paths that appear there (or new paths that clearly belong beside them) \u2014 an invented path makes the parallelism decision meaningless, since scopes are exactly what the executor uses to decide which writers may run at the same time.',
       '- Prefer one "explore" node feeding several parallel "general" nodes over one giant node.',
       "- Keep the graph small: most goals need 3-8 nodes total.",
-      '- "acceptance" (optional) lists concrete, checkable criteria for a "general" node.'
+      '- "acceptance" (optional) lists concrete, checkable criteria for a "general" node. These are ENFORCED: the executor adds a verify tentacle that checks them on disk and can send the work back for a rework round when they are not met. Write criteria a reader can settle by opening a file or running a command ("exports slugify(input: string): string", "npm test passes"), never subjective ones ("the code is elegant") \u2014 a criterion nobody can check just burns a rework round.'
     ].join("\n");
     PlannedNodeSchema = external_exports.object({
       id: external_exports.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/, "id must be alphanumeric/dash/underscore"),
@@ -35679,6 +35910,118 @@ var init_planner = __esm({
     PlannedGraphSchema = external_exports.object({
       nodes: external_exports.array(PlannedNodeSchema).min(1).max(DEFAULT_MAX_NODES)
     });
+    MAX_VERIFY_TASK_PROMPT_CHARS = 1200;
+  }
+});
+
+// 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) {
+  const unresolved = (opts.unresolvedFindings ?? []).map((u) => ({
+    ...u,
+    findings: u.findings.slice(0, MAX_SNAPSHOT_FINDINGS_CHARS)
+  }));
+  return {
+    graphId: graph.id,
+    goal: opts.goal,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    converged: opts.converged,
+    ...unresolved.length > 0 ? { unresolvedFindings: unresolved } : {},
+    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");
+  const rejected = snapshot.unresolvedFindings ?? [];
+  if (failed.length === 0 && skipped.length === 0 && rejected.length === 0) return "";
+  const line = (n) => `- ${n.label}${n.scope ? ` [${n.scope.join(", ")}]` : ""}${n.error ? ` \u2014 ${n.error}` : ""}`;
+  const rejectedIds = new Set(rejected.map((r) => r.nodeId));
+  const outcome = [
+    `${done.length} done`,
+    `${failed.length} failed`,
+    `${skipped.length} never ran`,
+    ...rejected.length > 0 ? [`${rejected.length} rejected by review`] : []
+  ].join(", ");
+  const parts = [
+    "",
+    "## Previous unfinished task graph in this project",
+    `Goal it was working on: "${snapshot.goal}"`,
+    `It did NOT finish cleanly (${outcome}).`,
+    "",
+    "If that goal is unrelated to the one above, ignore this section entirely.",
+    ""
+  ];
+  const cleanlyDone = done.filter((n) => !rejectedIds.has(n.id));
+  if (cleanlyDone.length > 0) {
+    parts.push("Already completed \u2014 do NOT redo this work:", ...cleanlyDone.map(line), "");
+  }
+  if (rejected.length > 0) {
+    parts.push(
+      "Completed but REJECTED by review \u2014 the code exists, the defects do not fix themselves:",
+      ...rejected.map(
+        (r) => `- ${r.label} \u2014 ${r.findings.trim().split("\n")[0] ?? "no detail"}`
+      ),
+      ""
+    );
+  }
+  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, MAX_SNAPSHOT_FINDINGS_CHARS;
+var init_graphMemory = __esm({
+  "src/cli/kraken/graphMemory.ts"() {
+    "use strict";
+    SNAPSHOT_DIR = path34.join(".zelari", "kraken");
+    SNAPSHOT_FILE = "last-graph.json";
+    MAX_SNAPSHOT_FINDINGS_CHARS = 400;
   }
 });
 
@@ -35693,30 +36036,60 @@ 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_GRAPH_TIMEOUT_MS: () => DEFAULT_GRAPH_TIMEOUT_MS,
   DEFAULT_MAX_PARALLEL: () => DEFAULT_MAX_PARALLEL,
+  DEFAULT_MAX_REVIEW_ROUNDS: () => DEFAULT_MAX_REVIEW_ROUNDS,
   DEFAULT_NODE_TIMEOUT_MS: () => DEFAULT_NODE_TIMEOUT_MS,
   DEFAULT_WRITER_NODE_TIMEOUT_MS: () => DEFAULT_WRITER_NODE_TIMEOUT_MS,
   KrakenGraphExecutor: () => KrakenGraphExecutor,
+  MAX_UPSTREAM_CHARS_PER_DEP: () => MAX_UPSTREAM_CHARS_PER_DEP,
+  MAX_UPSTREAM_CHARS_TOTAL: () => MAX_UPSTREAM_CHARS_TOTAL,
+  buildUpstreamContext: () => buildUpstreamContext,
   isKrakenGraphEnabled: () => isKrakenGraphEnabled,
   isWorldModelGateEnabled: () => isWorldModelGateEnabled,
+  resolveCancelGraceMs: () => resolveCancelGraceMs,
   resolveFixBudget: () => resolveFixBudget,
+  resolveGraphTimeoutMs: () => resolveGraphTimeoutMs,
   resolveMaxParallel: () => resolveMaxParallel,
-  resolveNodeTimeoutMs: () => resolveNodeTimeoutMs
+  resolveMaxReviewRounds: () => resolveMaxReviewRounds,
+  resolveNodeTimeoutMs: () => resolveNodeTimeoutMs,
+  thoroughnessForKind: () => thoroughnessForKind
 });
 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;
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_MAX_PARALLEL;
 }
-function resolveFixBudget(env = process.env) {
+function resolveFixBudget(env = process.env, nodeCount = 0) {
   const raw = env.ZELARI_KRAKEN_FIX_BUDGET;
-  if (raw === void 0 || raw === "") return DEFAULT_FIX_BUDGET;
+  if (raw === void 0 || raw === "") {
+    return Math.max(DEFAULT_FIX_BUDGET, Math.ceil(nodeCount / 2));
+  }
   const n = Number.parseInt(raw, 10);
-  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_FIX_BUDGET;
+  return Number.isFinite(n) && n >= 0 ? n : Math.max(DEFAULT_FIX_BUDGET, Math.ceil(nodeCount / 2));
+}
+function resolveMaxReviewRounds(env = process.env) {
+  const raw = env.ZELARI_KRAKEN_MAX_REVIEW_ROUNDS;
+  if (raw === void 0 || raw === "") return DEFAULT_MAX_REVIEW_ROUNDS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_MAX_REVIEW_ROUNDS;
+}
+function resolveGraphTimeoutMs(env = process.env) {
+  const raw = env.ZELARI_KRAKEN_GRAPH_TIMEOUT_MS;
+  if (raw === void 0 || raw === "") return DEFAULT_GRAPH_TIMEOUT_MS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_GRAPH_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_CANCEL_GRACE_MS;
 }
 function resolveNodeTimeoutMs(env = process.env, agent) {
   const raw = env.ZELARI_KRAKEN_NODE_TIMEOUT_MS;
@@ -35743,12 +36116,56 @@ 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, DEFAULT_WRITER_NODE_TIMEOUT_MS, KrakenGraphExecutor;
+function buildUpstreamContext(graph, node) {
+  const parts = [];
+  const omitted = [];
+  let budget = MAX_UPSTREAM_CHARS_TOTAL;
+  for (const depId of node.deps) {
+    const dep = graph.nodes.get(depId);
+    if (!dep || dep.status !== "done") continue;
+    const raw = (dep.result ?? "").trim();
+    if (!raw) continue;
+    const cap2 = Math.min(MAX_UPSTREAM_CHARS_PER_DEP, budget);
+    if (cap2 <= 0) {
+      omitted.push(dep.label);
+      continue;
+    }
+    const body = raw.length > cap2 ? `${raw.slice(0, cap2)}
+\u2026 [truncated ${raw.length}\u2192${cap2} chars]` : raw;
+    budget -= Math.min(raw.length, cap2);
+    const scope = dep.scope && dep.scope.length > 0 ? `, scope: ${dep.scope.join(", ")}` : "";
+    parts.push(`### ${dep.label} (${dep.kind}${scope})
+${body}`);
+  }
+  if (parts.length === 0) return "";
+  const lines = [
+    "",
+    "## Context from completed upstream tasks",
+    "Results reported by the tasks this one depends on. Treat them as hypotheses \u2014 prefer the actual files on disk where they conflict.",
+    "",
+    ...parts
+  ];
+  if (omitted.length > 0) {
+    lines.push("", `(omitted for context budget: ${omitted.join(", ")})`);
+  }
+  return lines.join("\n");
+}
+function thoroughnessForKind(kind) {
+  return kind === "general" || kind === "fix" ? "deep" : "medium";
+}
+function firstLine(text, maxChars = 160) {
+  const line = text.trim().split("\n").find((l) => l.trim() !== "")?.trim() ?? "";
+  return line.length > maxChars ? `${line.slice(0, maxChars)}\u2026` : line;
+}
+function agentForNode(node) {
+  return node.kind === "explore" || node.kind === "verify" ? node.kind : "general";
+}
+var DEFAULT_MAX_PARALLEL, DEFAULT_FIX_BUDGET, DEFAULT_MAX_REVIEW_ROUNDS, DEFAULT_GRAPH_TIMEOUT_MS, DEFAULT_NODE_TIMEOUT_MS, DEFAULT_WRITER_NODE_TIMEOUT_MS, DEFAULT_CANCEL_GRACE_MS, MAX_UPSTREAM_CHARS_PER_DEP, MAX_UPSTREAM_CHARS_TOTAL, KrakenGraphExecutor;
 var init_executor = __esm({
   "src/cli/kraken/executor.ts"() {
     "use strict";
@@ -35758,40 +36175,116 @@ var init_executor = __esm({
     init_krakenRadio();
     init_worldModel();
     init_graphStatus();
+    init_graphMemory();
     DEFAULT_MAX_PARALLEL = 12;
     DEFAULT_FIX_BUDGET = 3;
+    DEFAULT_MAX_REVIEW_ROUNDS = 1;
+    DEFAULT_GRAPH_TIMEOUT_MS = 0;
     DEFAULT_NODE_TIMEOUT_MS = 3e5;
     DEFAULT_WRITER_NODE_TIMEOUT_MS = 9e5;
+    DEFAULT_CANCEL_GRACE_MS = 3e4;
+    MAX_UPSTREAM_CHARS_PER_DEP = 2800;
+    MAX_UPSTREAM_CHARS_TOTAL = 8e3;
     KrakenGraphExecutor = class {
       deps;
       parentCwd;
       sessionId;
+      goal;
       maxParallel;
       /** Explicit all-kinds override; when undefined the budget is per-kind. */
       nodeTimeoutMs;
+      cancelGraceMs;
+      /** Explicit override; when undefined the budget scales with the graph size. */
+      fixBudgetOption;
       fixBudgetRemaining;
+      maxReviewRounds;
+      graphTimeoutMs;
       worldModelGateOverride;
       runTentacleFn;
       mergeFn;
       backtestFn;
       nodeRunState = /* @__PURE__ */ new Map();
+      /** fix node id → id of the failed node it was spawned to repair. */
+      repairs = /* @__PURE__ */ new Map();
+      /**
+       * rework node id → id of the writer whose work it is redoing. A rework is a
+       * `fix` node, but unlike a repair it must NOT create a worktree of its own:
+       * it edits the writer's existing one (see {@link spawnReworkPair}).
+       */
+      reworks = /* @__PURE__ */ new Map();
+      /** lineage root writer id → rework rounds already spent on that lineage. */
+      reviewRounds = /* @__PURE__ */ new Map();
+      /**
+       * rework node id → the ORIGINAL writer its lineage started from.
+       *
+       * The budget has to be per lineage, not per node: a rework is itself a
+       * writer, so counting rounds against the node being reworked reset the
+       * counter every round and the graph chained rework → verify → rework
+       * forever, terminating only on the scheduler's iteration cap.
+       */
+      reviewLineage = /* @__PURE__ */ new Map();
+      /** Verify verdicts left unresolved when the run ends. */
+      unresolved = [];
+      /** Live cancellation handles for the tentacles currently running. */
+      nodeControllers = /* @__PURE__ */ new Map();
+      /** Wall-clock duration of each node's last run, by node id. */
+      durationsMs = /* @__PURE__ */ new Map();
+      signal;
+      /** Set once the run has been cancelled: stops admission, retries and fixes. */
+      aborted = false;
       fixCounter = 0;
       constructor(opts) {
         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;
+        this.cancelGraceMs = opts.cancelGraceMs;
+        this.fixBudgetOption = opts.fixBudget;
         this.fixBudgetRemaining = opts.fixBudget ?? resolveFixBudget();
+        this.maxReviewRounds = opts.maxReviewRounds ?? resolveMaxReviewRounds();
+        this.graphTimeoutMs = opts.graphTimeoutMs ?? resolveGraphTimeoutMs();
         this.worldModelGateOverride = opts.worldModelGate;
+        this.signal = opts.signal;
         this.runTentacleFn = opts.runTentacleFn ?? runTentacle;
         this.mergeFn = opts.mergeFn ?? mergeKrakenWorktree;
         this.backtestFn = opts.backtestFn ?? runBacktest;
       }
       /** Execute the graph in place (mutates node statuses) until it settles. */
       async execute(graph) {
+        if (this.fixBudgetOption === void 0) {
+          this.fixBudgetRemaining = resolveFixBudget(process.env, graph.nodes.size);
+        }
+        const onAbort = () => this.cancelRun();
+        if (this.signal) {
+          if (this.signal.aborted) this.aborted = true;
+          else this.signal.addEventListener("abort", onAbort, { once: true });
+        }
+        let graphTimer;
+        if (this.graphTimeoutMs > 0) {
+          graphTimer = setTimeout(() => {
+            this.radio("graph_failed", {
+              description: "graph executor",
+              detail: `graph exceeded its ${this.graphTimeoutMs}ms wall-clock budget \u2014 cancelling`,
+              ok: false
+            });
+            this.cancelRun();
+          }, this.graphTimeoutMs);
+          graphTimer.unref?.();
+        }
+        try {
+          return await this.schedule(graph);
+        } finally {
+          if (graphTimer) clearTimeout(graphTimer);
+          this.signal?.removeEventListener("abort", onAbort);
+        }
+      }
+      /** The scheduling loop proper. See {@link execute} for the cancellation wrapper. */
+      async schedule(graph) {
         const maxIterations = Math.max(64, graph.nodes.size * 8);
         let iterations = 0;
+        const inFlight = /* @__PURE__ */ new Map();
         startKrakenGraphLive(graph);
         while (!isSettled(graph)) {
           iterations += 1;
@@ -35803,24 +36296,39 @@ var init_executor = __esm({
             });
             break;
           }
-          const ready = getReadyNodes(graph);
-          if (ready.length === 0) {
-            const skippedAny = this.skipBlockedNodes(graph);
-            if (!skippedAny) {
+          if (this.aborted && inFlight.size === 0) break;
+          const admitted = this.aborted ? [] : this.admit(graph, inFlight);
+          if (admitted.length > 0) {
+            for (const node of admitted) node.status = "running";
+            updateKrakenGraphLive(graph);
+            for (const node of admitted) inFlight.set(node.id, this.runNodeSafely(node, graph));
+          }
+          if (inFlight.size === 0) {
+            if (!this.skipBlockedNodes(graph)) {
               break;
             }
             continue;
           }
-          const wave = selectParallelWave(ready).slice(0, this.maxParallel);
-          for (const node of wave) node.status = "running";
-          const results = await Promise.all(wave.map((node) => this.runNode(node, graph)));
-          for (let i = 0; i < wave.length; i++) {
-            this.applyResult(graph, wave[i], results[i]);
-          }
+          const { id, res } = await Promise.race(inFlight.values());
+          inFlight.delete(id);
+          const settledNode = graph.nodes.get(id);
+          if (settledNode) this.applyResult(graph, settledNode, res);
           updateKrakenGraphLive(graph);
         }
+        if (inFlight.size > 0) {
+          for (const { id, res } of await Promise.all(inFlight.values())) {
+            const node = graph.nodes.get(id);
+            if (node) this.applyResult(graph, node, res);
+          }
+          inFlight.clear();
+        }
+        if (this.aborted) {
+          for (const n of graph.nodes.values()) {
+            if (n.status === "pending") n.status = "skipped";
+          }
+        }
         let backtest;
-        const converged = isConverged(graph);
+        const converged = !this.aborted && isConverged(graph);
         if (converged) {
           const gateOn = this.worldModelGateOverride ?? isWorldModelGateEnabled(this.parentCwd);
           if (gateOn) {
@@ -35834,47 +36342,140 @@ var init_executor = __esm({
         } else {
           this.radio("graph_failed", {
             description: "graph executor",
-            detail: `failed nodes: ${failedNodeIds(graph).join(", ") || "none"}`,
+            detail: this.aborted ? "cancelled by caller" : `failed nodes: ${failedNodeIds(graph).join(", ") || "none"}`,
             ok: false
           });
         }
         endKrakenGraphLive(graph, converged);
+        await saveGraphSnapshot(
+          this.parentCwd,
+          toGraphSnapshot(graph, {
+            goal: this.goal ?? graph.id,
+            converged,
+            unresolvedFindings: this.unresolved
+          })
+        );
         return {
           graph,
           converged,
           failedNodeIds: failedNodeIds(graph),
           counts: countByStatus(graph),
+          durationsMs: Object.fromEntries(this.durationsMs),
+          cancelled: this.aborted,
+          unresolvedFindings: [...this.unresolved],
           ...backtest ? { backtest } : {}
         };
       }
+      /**
+       * Stop the run: no further admissions, and every tentacle currently running
+       * is told to unwind. Each node's own timeout/grace machinery then resolves
+       * it, so `execute()` settles instead of leaving orphans behind.
+       */
+      cancelRun() {
+        if (this.aborted) return;
+        this.aborted = true;
+        this.radio("graph_failed", {
+          description: "graph executor",
+          detail: `cancelling ${this.nodeControllers.size} running tentacle(s)`,
+          ok: false
+        });
+        for (const controller of this.nodeControllers.values()) controller.abort();
+      }
+      /**
+       * Pick the ready nodes that may start right now: parallel-safe against every
+       * node already running AND against each other, within the concurrency cap.
+       *
+       * Unlike a wave-at-a-time scheduler this is called on every completion, so a
+       * node becomes eligible the moment its blocker settles instead of waiting
+       * for the slowest member of some earlier batch.
+       */
+      admit(graph, inFlight) {
+        const capacity = this.maxParallel - inFlight.size;
+        if (capacity <= 0) return [];
+        const running = [];
+        for (const id of inFlight.keys()) {
+          const n = graph.nodes.get(id);
+          if (n) running.push(n);
+        }
+        const admitted = [];
+        for (const node of getReadyNodes(graph)) {
+          if (admitted.length >= capacity) break;
+          const safe = running.every((r) => canRunParallel(r, node)) && admitted.every((a) => canRunParallel(a, node));
+          if (safe) admitted.push(node);
+        }
+        return admitted;
+      }
+      /**
+       * Run one node, tagging the result with its id and converting an unexpected
+       * throw into a node failure. The scheduler races these promises, so a
+       * rejection would abandon every other in-flight tentacle mid-write; one
+       * failed node that the retry/fix machinery can reason about is strictly
+       * better than an aborted graph.
+       */
+      runNodeSafely(node, graph) {
+        return this.runNode(node, graph).then(
+          (res) => ({ id: node.id, res }),
+          (err) => ({
+            id: node.id,
+            res: {
+              ok: false,
+              agent: agentForNode(node),
+              error: `tentacle threw: ${err instanceof Error ? err.message : String(err)}`,
+              cancelled: true
+            }
+          })
+        );
+      }
       /** Run one node: dispatch to the merge handler for `merge` nodes, else a tentacle. */
       async runNode(node, graph) {
+        const startedAt = Date.now();
+        try {
+          return await this.runNodeInner(node, graph);
+        } finally {
+          this.durationsMs.set(node.id, Date.now() - startedAt);
+          this.nodeControllers.delete(node.id);
+        }
+      }
+      async runNodeInner(node, graph) {
         this.radio("node_start", { description: node.label, agent: node.kind });
         if (node.kind === "merge") {
           return this.runMergeNode(node, graph);
         }
-        const usesWorktree = node.kind === "general" || node.kind === "fix";
+        const isRework = this.reworks.has(node.id);
+        const usesWorktree = (node.kind === "general" || node.kind === "fix") && !isRework;
         const agent = node.kind === "fix" ? "general" : node.kind;
+        const controller = new AbortController();
+        this.nodeControllers.set(node.id, controller);
+        if (this.aborted) controller.abort();
+        const upstream = buildUpstreamContext(graph, node);
+        const inheritedCwd = node.kind === "verify" || isRework ? this.inheritedWorktreeCwdFor(node, graph) : void 0;
         const res = await this.withNodeTimeout(
           this.runTentacleFn({
-            deps: this.deps,
+            // `allowWorktree: false` is what actually stops a rework from opening
+            // its own worktree: creation is driven by the agent kind ('general')
+            // inside runTentacle, not by anything the executor passes per-call.
+            deps: isRework ? { ...this.deps, allowWorktree: false } : this.deps,
             args: {
               description: node.label,
-              prompt: node.prompt,
+              prompt: upstream ? `${node.prompt}
+${upstream}` : node.prompt,
               scope: node.scope,
               acceptance: node.acceptance
             },
             agent,
-            thoroughness: "medium",
+            thoroughness: thoroughnessForKind(node.kind),
             parentCwd: this.parentCwd,
+            ...inheritedCwd ? { cwdOverride: inheritedCwd } : {},
             sessionId: this.sessionId,
             // Defer merge for writers so the executor controls merge ordering
-            // (Correction 4); explore/verify never create a worktree.
+            // (Correction 4); explore/verify/rework 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 });
@@ -35883,41 +36484,116 @@ var init_executor = __esm({
       }
       /**
        * Bound a tentacle run to its wall-clock budget (explicit `nodeTimeoutMs`
-       * option, else per-kind — writers get more than readers). 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.
+       * 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) {
+      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
-       * parent HEAD. Deps without a recorded worktree handle (worktree isolation
-       * disabled, or a read-only node) are a no-op. On conflict the branch is
-       * kept and the conflict is surfaced in the merge node's error — remaining
-       * deps still attempt to merge (independent branches shouldn't be blocked
-       * by one conflict).
+       * The worktree a node should run in, inherited from the writer behind it.
+       *
+       * For a `verify`: verification happens BEFORE the merge node, so when its
+       * writer worked in an isolated worktree the changes are not in the parent
+       * tree yet — a verify tentacle pointed at `parentCwd` was inspecting a tree
+       * that provably did not contain the work it was asked to check, and reported
+       * it missing.
+       *
+       * For a rework: the same tree, for the stronger reason that writing anywhere
+       * else would strand the round on a second branch.
+       *
+       * Returns undefined when there is no single tree: no worktrees (isolation
+       * disabled — the writers edited the parent tree directly), or several
+       * distinct ones, in which case no single cwd is correct and the parent tree
+       * is the honest default.
+       */
+      inheritedWorktreeCwdFor(node, graph) {
+        const paths = new Set(
+          this.collectWorktreeSources(node, graph).map((s) => s.handle.path)
+        );
+        return paths.size === 1 ? [...paths][0] : void 0;
+      }
+      /**
+       * Resolve the deferred worktrees produced behind a node's dependencies, in
+       * ancestors-first order. Used to decide what a `merge` node must merge, and
+       * which tree a `verify` node should actually inspect.
+       *
+       * A merge node's direct deps are NOT the writers: `buildGraphFromPlan`
+       * injects a `verify` node after every `general` node and points the merge at
+       * those verifies, while worktree handles are recorded against the writer
+       * node ids. Looking only at direct deps therefore found nothing to merge and
+       * silently reported success while every tentacle's work stayed stranded on
+       * its branch. Walk up through non-writer deps until the writers are found.
+       *
+       * Post-order so a writer that depends on another writer merges after it (the
+       * later branch was cut from a HEAD that already contained the earlier work).
+       * `merge` nodes terminate the walk: another merge already owns its subtree.
+       */
+      collectWorktreeSources(node, graph) {
+        const out = [];
+        const seen = /* @__PURE__ */ new Set();
+        const visit = (id) => {
+          if (seen.has(id)) return;
+          seen.add(id);
+          const n = graph.nodes.get(id);
+          if (!n || n.kind === "merge") return;
+          for (const dep of n.deps) visit(dep);
+          const handle = this.nodeRunState.get(id)?.worktreeHandle;
+          if (handle) out.push({ id, handle });
+        };
+        for (const depId of node.deps) visit(depId);
+        return out;
+      }
+      /**
+       * Sequentially merge every deferred worktree this node covers (in
+       * ancestors-first order) into parent HEAD. Nodes without a recorded worktree
+       * handle (worktree isolation disabled, or a read-only node) are a no-op. On
+       * conflict the branch is kept and the conflict is surfaced in the merge
+       * node's error — remaining sources still attempt to merge (independent
+       * branches shouldn't be blocked by one conflict).
        */
       async runMergeNode(node, graph) {
         const conflicts = [];
         const merged = [];
-        for (const depId of node.deps) {
-          const state3 = this.nodeRunState.get(depId);
-          const handle = state3?.worktreeHandle;
-          if (!handle) continue;
+        for (const { id: depId, handle } of this.collectWorktreeSources(node, graph)) {
           let result;
           try {
             result = await this.mergeFn(handle, {
@@ -35935,6 +36611,7 @@ var init_executor = __esm({
           if (!result.ok) {
             conflicts.push(`${depId}: ${result.message}`);
           } else {
+            this.nodeRunState.set(depId, { worktreeHandle: null });
             merged.push(depId);
           }
         }
@@ -35962,9 +36639,31 @@ var init_executor = __esm({
           node.status = "done";
           node.result = res.result;
           this.radio("node_end", { description: node.label, agent: node.kind, ok: true });
+          this.reconcileRepairedNode(graph, node);
+          if (node.kind === "verify") this.applyVerifyVerdict(graph, node);
           return;
         }
         node.error = res.error;
+        if (this.aborted) {
+          node.status = "error";
+          this.radio("node_end", {
+            description: node.label,
+            agent: node.kind,
+            detail: res.error,
+            ok: false
+          });
+          return;
+        }
+        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";
@@ -35997,6 +36696,180 @@ var init_executor = __esm({
           ok: false
         });
       }
+      /**
+       * A `fix` node just completed the work its failed predecessor could not.
+       * That unit of work IS done — but the predecessor was left terminally
+       * `error`, and since `isConverged` requires every node to be `done`/
+       * `skipped`, a fully repaired graph reported "did not converge" and listed
+       * the repaired node under `failedNodeIds`. The cross-run snapshot then told
+       * the next planner to redo work the fix had already completed.
+       *
+       * Marking it `done` has no scheduling effect (dependents were re-pointed at
+       * the fix when it was spawned) — it is purely how the run is reported. The
+       * original failure stays visible as the separate `fix: …` node and in the
+       * repaired node's result line.
+       */
+      reconcileRepairedNode(graph, fixNode) {
+        const failedId = this.repairs.get(fixNode.id);
+        if (!failedId) return;
+        const failed = graph.nodes.get(failedId);
+        if (!failed || failed.status !== "error") return;
+        const original = failed.error ? ` (original failure: ${failed.error})` : "";
+        failed.status = "done";
+        failed.result = `repaired by "${fixNode.label}"${original}${fixNode.result ? `: ${fixNode.result}` : ""}`;
+        failed.error = void 0;
+        this.radio("node_end", {
+          description: failed.label,
+          agent: failed.kind,
+          detail: `repaired by ${fixNode.id}`,
+          ok: true
+        });
+      }
+      /**
+       * Act on what a completed `verify` node concluded.
+       *
+       * The verify itself stays `done` either way — it did its job, and doing it
+       * well means being free to say "no". A FAIL instead sends the WRITER back
+       * through a bounded rework round.
+       *
+       * Without this the verdict text was never read: a verify that reported the
+       * work as wrong was recorded exactly like one that reported it correct, the
+       * graph converged over the defect, and the only iteration the engine could
+       * do was on execution failure. An `unknown` verdict (no parseable trailer)
+       * is deliberately non-blocking — a prompt drift must not be able to wedge
+       * every graph — but it is recorded, because a gate that has silently stopped
+       * working is worse than no gate.
+       */
+      applyVerifyVerdict(graph, verify) {
+        const { verdict, findings } = parseVerifyVerdict(verify.result);
+        if (verdict === "pass") return;
+        const writer = this.writerBehind(verify, graph);
+        if (!writer) return;
+        if (verdict === "unknown") {
+          this.unresolved.push({
+            nodeId: writer.id,
+            label: writer.label,
+            reason: "unknown",
+            findings: findings || "(verify produced no parseable VERDICT line)"
+          });
+          return;
+        }
+        const root = this.reviewLineage.get(writer.id) ?? writer.id;
+        const spent = this.reviewRounds.get(root) ?? 0;
+        if (this.aborted || spent >= this.maxReviewRounds) {
+          this.unresolved.push({
+            nodeId: writer.id,
+            label: writer.label,
+            reason: "fail",
+            findings
+          });
+          writer.result = `${writer.result ?? ""}
+
+[accepted with unresolved verify findings from ` + `"${verify.label}"]${findings ? `: ${firstLine(findings)}` : ""}`.trim();
+          this.radio("node_end", {
+            description: writer.label,
+            agent: writer.kind,
+            detail: this.aborted ? "verify FAIL left unresolved (run cancelled)" : `verify FAIL left unresolved (rework budget ${this.maxReviewRounds} spent)`,
+            ok: false
+          });
+          return;
+        }
+        this.reviewRounds.set(root, spent + 1);
+        this.spawnReworkPair(graph, writer, verify, findings, root, spent + 1);
+      }
+      /**
+       * The writer whose work a `verify` node judged.
+       *
+       * Walks up through non-writer deps, the same shape `collectWorktreeSources`
+       * relies on: a verify's dep is normally its writer directly, but after a
+       * rework round the chain is writer → verify → rework → verify, and the
+       * rework (a `fix` node) is itself the writer to send back.
+       */
+      writerBehind(verify, graph) {
+        const seen = /* @__PURE__ */ new Set();
+        const visit = (id) => {
+          if (seen.has(id)) return void 0;
+          seen.add(id);
+          const n = graph.nodes.get(id);
+          if (!n || n.kind === "merge") return void 0;
+          if (n.kind === "general" || n.kind === "fix") return n;
+          for (const dep of n.deps) {
+            const found = visit(dep);
+            if (found) return found;
+          }
+          return void 0;
+        };
+        for (const depId of verify.deps) {
+          const found = visit(depId);
+          if (found) return found;
+        }
+        return void 0;
+      }
+      /**
+       * Send a writer's work back for one more round: a rework node carrying the
+       * verify's findings, plus a fresh verify to judge the result.
+       *
+       * The rework runs INSIDE the writer's worktree instead of creating one of
+       * its own. Two worktrees for one scope means two branches, and the merge
+       * node walks up to the writer — so a rework on its own branch would be
+       * merged never or twice, exactly the stranded-work failure the merge fix
+       * addressed. `allowWorktree: false` on this node's deps suppresses creation,
+       * and `cwdOverride` (resolved via {@link inheritedWorktreeCwdFor}) points it
+       * at the existing tree; the handle stays registered against the writer.
+       *
+       * Acyclicity is preserved by construction: both new nodes point only at
+       * nodes that already exist, and the rewiring moves an existing edge forward
+       * along the chain rather than back into it.
+       */
+      spawnReworkPair(graph, writer, verify, findings, root, round) {
+        const reworkId = `rework-${root}-${round}`;
+        const reworkNode = {
+          id: reworkId,
+          kind: "fix",
+          label: `rework: ${writer.label}`,
+          prompt: `A reviewer inspected this work on disk and REJECTED it. Address every finding below, then leave the work in a state that satisfies the original task.
+
+## Original task
+${writer.prompt}
+
+## Reviewer findings (these are what must change)
+${findings || "(the reviewer reported FAIL without detail)"}`,
+          ...writer.scope ? { scope: writer.scope } : {},
+          ...writer.acceptance ? { acceptance: writer.acceptance } : {},
+          // The verify is already `done`, so the rework is immediately ready.
+          deps: [verify.id],
+          status: "pending",
+          retryCount: 0,
+          maxRetries: 0
+        };
+        graph.nodes.set(reworkId, reworkNode);
+        this.reworks.set(reworkId, writer.id);
+        this.reviewLineage.set(reworkId, root);
+        const reVerifyId = `verify-${reworkId}`;
+        const reVerifyNode = {
+          id: reVerifyId,
+          kind: "verify",
+          label: `verify: ${writer.label} (rework ${round})`,
+          prompt: verify.prompt,
+          deps: [reworkId],
+          status: "pending",
+          retryCount: 0,
+          maxRetries: verify.maxRetries
+        };
+        graph.nodes.set(reVerifyId, reVerifyNode);
+        for (const other of graph.nodes.values()) {
+          if (other.id === reworkId || other.id === reVerifyId) continue;
+          if (other.deps.includes(verify.id)) {
+            other.deps = other.deps.map((d) => d === verify.id ? reVerifyId : d);
+          }
+        }
+        this.radio("node_fix", {
+          description: reworkNode.label,
+          agent: "fix",
+          detail: `verify FAIL on "${writer.label}" \u2014 rework round ${round}/${this.maxReviewRounds}`,
+          ok: false
+        });
+      }
       /**
        * Create a `fix` node that attempts to redo the failed node's work, wired
        * so downstream dependents of the failed node also wait on the fix.
@@ -36023,6 +36896,7 @@ ${failed.error ?? "unknown error"}`,
           // no further retries — one fix attempt per failed node in v1
         };
         graph.nodes.set(fixId, fixNode);
+        this.repairs.set(fixId, failed.id);
         for (const other of graph.nodes.values()) {
           if (other.id === fixId) continue;
           if (other.deps.includes(failed.id)) {
@@ -36453,10 +37327,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();
@@ -36477,7 +37351,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
@@ -36514,7 +37388,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 {
@@ -36532,7 +37406,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];
@@ -36841,10 +37715,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 {
@@ -36857,10 +37731,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 };
@@ -36871,13 +37745,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 {
   }
 }
@@ -37165,12 +38039,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) => ({
@@ -37208,16 +38082,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 };
@@ -37242,17 +38116,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()];
@@ -37629,9 +38503,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",
@@ -37643,18 +38517,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) => ({
@@ -37665,7 +38539,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(),
@@ -37683,7 +38557,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 {
@@ -37730,7 +38604,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);
@@ -37795,7 +38669,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);
@@ -37907,11 +38781,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"));
@@ -37919,11 +38793,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 {
@@ -37937,7 +38811,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;
@@ -37953,7 +38827,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}
@@ -37981,8 +38855,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,
@@ -38021,7 +38895,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}
@@ -38042,7 +38916,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);
@@ -38218,7 +39092,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,
@@ -44633,6 +45507,7 @@ init_krakenRadio();
 init_auditLogger();
 init_toolRegistry();
 init_planner();
+init_graphMemory();
 init_executor();
 init_graphStatus();
 async function handleKrakenGraph(ctx, prompt) {
@@ -44657,19 +45532,36 @@ 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)}`,
+      cwd: ctx.cwd,
+      ...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);
+    const digest = formatKrakenGraphDigest(summary.graph, {
+      durationsMs: summary.durationsMs,
+      unresolvedFindings: summary.unresolvedFindings
+    });
     appendSystem(
       ctx.setMessages,
       `${formatKrakenGraphAscii(summary.graph)}
 
-` + (summary.converged ? "[kraken] graph converged." : `[kraken] graph did not converge \u2014 failed: ${summary.failedNodeIds.join(", ") || "none"}`)
+${digest}
+
+` + (summary.converged ? "[kraken] graph converged." : summary.cancelled ? "[kraken] graph cancelled." : `[kraken] graph did not converge \u2014 failed: ${summary.failedNodeIds.join(", ") || "none"}`)
     );
   } catch (err) {
     appendSystem(
@@ -44976,17 +45868,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}
@@ -45002,25 +45894,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);
@@ -45045,13 +45937,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;
@@ -45096,15 +45988,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(),
@@ -45122,7 +46014,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;
@@ -45203,26 +46095,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 {
@@ -45230,7 +46122,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}`);
@@ -45243,27 +46135,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)";
@@ -45303,8 +46195,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)}`);
@@ -45663,16 +46555,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 [];
   }
@@ -45789,7 +46681,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);
@@ -45805,7 +46697,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);
@@ -47530,7 +48422,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     return 1;
   }
   const { planTaskGraph: planTaskGraph2 } = await Promise.resolve().then(() => (init_planner(), planner_exports));
-  const { formatKrakenGraphAscii: formatKrakenGraphAscii2 } = await Promise.resolve().then(() => (init_graphStatus(), graphStatus_exports));
+  const { loadGraphSnapshot: loadGraphSnapshot2, formatSnapshotForPlanner: formatSnapshotForPlanner2 } = await Promise.resolve().then(() => (init_graphMemory(), graphMemory_exports));
+  const { formatKrakenGraphAscii: formatKrakenGraphAscii2, formatKrakenGraphDigest: formatKrakenGraphDigest2 } = 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));
   const cwd = process.cwd();
@@ -47543,9 +48436,24 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
 `);
     }
   };
+  const abort = new AbortController();
+  const onSigint = () => {
+    log("SIGINT \u2014 cancelling the graph; press Ctrl-C again to force quit");
+    abort.abort();
+  };
+  process.once("SIGINT", onSigint);
   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,
+      cwd,
+      ...previousAttempt ? { previousAttempt } : {}
+    });
     log(formatKrakenGraphAscii2(graph));
     const audit = new AuditLogger2();
     const executor = new KrakenGraphExecutor2({
@@ -47564,10 +48472,21 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
         })
       },
       parentCwd: cwd,
-      sessionId
+      sessionId,
+      goal: prompt,
+      signal: abort.signal
     });
     const summary = await executor.execute(graph);
-    const finalAscii = formatKrakenGraphAscii2(summary.graph);
+    if (summary.cancelled) log("graph cancelled \u2014 partial results below");
+    const finalAscii = `${formatKrakenGraphAscii2(summary.graph)}
+
+${formatKrakenGraphDigest2(
+      summary.graph,
+      {
+        durationsMs: summary.durationsMs,
+        unresolvedFindings: summary.unresolvedFindings
+      }
+    )}`;
     if (opts.output === "json") {
       emitEvent({ type: "message_start" });
       emitEvent({ type: "message_delta", delta: finalAscii });
@@ -47594,6 +48513,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
 `);
     }
     return 2;
+  } finally {
+    process.off("SIGINT", onSigint);
   }
 }
 function planModeFromOpts(opts) {
@@ -48709,7 +49630,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path43 = skillFilePath(dir, name);
+  const path44 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -48718,13 +49639,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();
@@ -48742,8 +49663,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 {
@@ -48754,7 +49675,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
@@ -48844,8 +49765,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";
     }