zelari-code 1.28.0 → 1.29.0

package/dist/cli/main.bundled.js

@@ -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;
   }
 });
 
@@ -26621,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 {
@@ -35303,10 +35376,17 @@ __export(planner_exports, {
   KRAKEN_PLANNER_SYSTEM_PROMPT: () => KRAKEN_PLANNER_SYSTEM_PROMPT,
   PlannerTransportError: () => PlannerTransportError,
   buildGraphFromPlan: () => buildGraphFromPlan,
+  buildPlannerUserPrompt: () => buildPlannerUserPrompt,
   extractJsonObject: () => extractJsonObject,
   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;
@@ -35615,14 +35695,32 @@ async function createDefaultLlmClient(opts) {
     }
   };
 }
-function buildPlannerUserPrompt(prompt, previousAttempt) {
-  const prev2 = previousAttempt?.trim() ? `
-${previousAttempt.trim()}
-` : "";
-  return `Goal:
-${prompt.trim()}
-${prev2}
-Return ONLY the JSON object described in the system prompt.`;
+function 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;
@@ -35631,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) => ({
@@ -35688,7 +35815,11 @@ 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, opts.previousAttempt);
+  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++) {
@@ -35719,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";
@@ -35728,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) {
@@ -35756,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"),
@@ -35775,6 +35910,7 @@ 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;
   }
 });
 
@@ -35792,11 +35928,16 @@ 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,
@@ -35831,19 +35972,37 @@ function formatSnapshotForPlanner(snapshot) {
   const done = snapshot.nodes.filter((n) => n.status === "done");
   const failed = snapshot.nodes.filter((n) => n.status === "error");
   const skipped = snapshot.nodes.filter((n) => n.status === "skipped");
-  if (failed.length === 0 && skipped.length === 0) return "";
+  const 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 (${done.length} done, ${failed.length} failed, ${skipped.length} never ran).`,
+    `It did NOT finish cleanly (${outcome}).`,
     "",
     "If that goal is unrelated to the one above, ignore this section entirely.",
     ""
   ];
-  if (done.length > 0) {
-    parts.push("Already completed \u2014 do NOT redo this work:", ...done.map(line), "");
+  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), "");
@@ -35856,12 +36015,13 @@ function formatSnapshotForPlanner(snapshot) {
   );
   return parts.join("\n");
 }
-var SNAPSHOT_DIR, SNAPSHOT_FILE;
+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;
   }
 });
 
@@ -35878,16 +36038,24 @@ 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 path35 from "node:path";
@@ -35897,11 +36065,25 @@ function resolveMaxParallel(env = process.env) {
   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;
@@ -35939,7 +36121,51 @@ function defaultChecksExists(cwd) {
     return false;
   }
 }
-var DEFAULT_MAX_PARALLEL, DEFAULT_FIX_BUDGET, DEFAULT_NODE_TIMEOUT_MS, DEFAULT_WRITER_NODE_TIMEOUT_MS, DEFAULT_CANCEL_GRACE_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";
@@ -35952,9 +36178,13 @@ var init_executor = __esm({
     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;
@@ -35964,12 +36194,44 @@ var init_executor = __esm({
       /** 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;
@@ -35979,16 +36241,50 @@ var init_executor = __esm({
         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;
@@ -36000,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) {
@@ -36031,47 +36342,133 @@ 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 })
+          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,
@@ -36132,20 +36529,71 @@ var init_executor = __esm({
         };
       }
       /**
-       * 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, {
@@ -36163,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);
           }
         }
@@ -36190,9 +36639,21 @@ 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", {
@@ -36235,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.
@@ -36261,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)) {
@@ -44904,6 +45540,7 @@ async function handleKrakenGraph(ctx, prompt) {
     const graph = await planTaskGraph({
       prompt,
       graphId: `kraken-${Date.now().toString(36)}`,
+      cwd: ctx.cwd,
       ...previousAttempt ? { previousAttempt } : {}
     });
     appendSystem(ctx.setMessages, formatKrakenGraphAscii(graph));
@@ -44914,11 +45551,17 @@ async function handleKrakenGraph(ctx, prompt) {
       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(
@@ -47780,7 +48423,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   }
   const { planTaskGraph: planTaskGraph2 } = await Promise.resolve().then(() => (init_planner(), planner_exports));
   const { loadGraphSnapshot: loadGraphSnapshot2, formatSnapshotForPlanner: formatSnapshotForPlanner2 } = await Promise.resolve().then(() => (init_graphMemory(), graphMemory_exports));
-  const { formatKrakenGraphAscii: formatKrakenGraphAscii2 } = await Promise.resolve().then(() => (init_graphStatus(), graphStatus_exports));
+  const { 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();
@@ -47793,6 +48436,12 @@ 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 previous = await loadGraphSnapshot2(cwd);
@@ -47802,6 +48451,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
       prompt,
       provider,
       model,
+      cwd,
       ...previousAttempt ? { previousAttempt } : {}
     });
     log(formatKrakenGraphAscii2(graph));
@@ -47823,10 +48473,20 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
       },
       parentCwd: cwd,
       sessionId,
-      goal: prompt
+      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 });
@@ -47853,6 +48513,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
 `);
     }
     return 2;
+  } finally {
+    process.off("SIGINT", onSigint);
   }
 }
 function planModeFromOpts(opts) {