zelari-code 1.28.0 → 1.30.0

package/dist/cli/main.bundled.js

@@ -886,8 +886,8 @@ function loadModelsRegistry(file2 = getModelsFilePath()) {
   }
 }
 function getCachedModels(provider, file2 = getModelsFilePath()) {
-  const registry3 = loadModelsRegistry(file2);
-  return registry3[provider];
+  const registry4 = loadModelsRegistry(file2);
+  return registry4[provider];
 }
 function isModelsCacheStale(provider, maxAgeMs = 6 * 60 * 60 * 1e3, file2 = getModelsFilePath(), now = Date.now()) {
   const entry = getCachedModels(provider, file2);
@@ -1829,10 +1829,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path44) {
-  if (!path44)
+function getElementAtPath(obj, path47) {
+  if (!path47)
     return obj;
-  return path44.reduce((acc, key) => acc?.[key], obj);
+  return path47.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(path44, issues) {
+function prefixIssues(path47, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path44);
+    iss.path.unshift(path47);
     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, path44 = []) => {
+  const processError = (error52, path47 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path44, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path47, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path44, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path47, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path44, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path47, ...issue2.path]);
       } else {
-        const fullpath = [...path44, ...issue2.path];
+        const fullpath = [...path47, ...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, path44 = []) => {
+  const processError = (error52, path47 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path44, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path47, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path44, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path47, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path44, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path47, ...issue2.path]);
       } else {
-        const fullpath = [...path44, ...issue2.path];
+        const fullpath = [...path47, ...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 path44 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path44) {
+  const path47 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path47) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13342,21 +13342,21 @@ var init_to_json_schema = __esm({
 // node_modules/zod/v4/core/json-schema-processors.js
 function toJSONSchema(input, params) {
   if ("_idmap" in input) {
-    const registry3 = input;
+    const registry4 = input;
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
-    for (const entry of registry3._idmap.entries()) {
+    for (const entry of registry4._idmap.entries()) {
       const [_, schema] = entry;
       process2(schema, ctx2);
     }
     const schemas = {};
     const external = {
-      registry: registry3,
+      registry: registry4,
       uri: params?.uri,
       defs
     };
     ctx2.external = external;
-    for (const entry of registry3._idmap.entries()) {
+    for (const entry of registry4._idmap.entries()) {
       const [key, schema] = entry;
       extractDefs(ctx2, schema);
       schemas[key] = finalize(ctx2, schema);
@@ -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 path44 = ref.slice(1).split("/").filter(Boolean);
-  if (path44.length === 0) {
+  const path47 = ref.slice(1).split("/").filter(Boolean);
+  if (path47.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path44[0] === defsKey) {
-    const key = path44[1];
+  if (path47[0] === defsKey) {
+    const key = path47[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 path44 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path47 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path44,
+            path: path47,
             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 "${path44}".`;
+          return `Document "${title}" created at "${path47}".`;
         }
       }
     ];
@@ -18922,10 +18922,10 @@ function computeAgentTools(agent, aiConfig) {
   }
   return merged;
 }
-function getToolDescriptions(toolNames, registry3) {
+function getToolDescriptions(toolNames, registry4) {
   const lines = ["AVAILABLE TOOLS (use ONLY these exact names):"];
   for (const name of toolNames) {
-    const tool = registry3.get(name);
+    const tool = registry4.get(name);
     if (!tool)
       continue;
     let paramList;
@@ -18952,7 +18952,7 @@ function buildSystemPromptSplit(agent, options) {
     includeWorkspaceInPrompt = true,
     durableStateContext
   } = options;
-  const registry3 = new Map(tools.map((t) => [t.name, t]));
+  const registry4 = new Map(tools.map((t) => [t.name, t]));
   const skills = computeAgentSkills(agent, aiConfig);
   const baseModules = getBasePromptModules(mode).filter((m) => !m.conditional || m.conditional(skills));
   const customModulesRaw = aiConfig?.customPromptModules ?? [];
@@ -18987,7 +18987,7 @@ ${projectInstructions.trim()}`);
 ` + skills.map((s) => `## ${s.name}
 ${s.systemPromptFragment}`).join("\n\n"));
   }
-  const toolBlock = getToolDescriptions(toolNames, registry3);
+  const toolBlock = getToolDescriptions(toolNames, registry4);
   if (toolNames.length > 0) {
     stableParts.push(`# Tools
 
@@ -19619,6 +19619,48 @@ var init_krakenLive = __esm({
 });
 
 // packages/core/dist/shared/events.js
+function isBrainAgentStartEvent(e) {
+  return e.type === "agent_start";
+}
+function isBrainAgentEndEvent(e) {
+  return e.type === "agent_end";
+}
+function isBrainMessageStartEvent(e) {
+  return e.type === "message_start";
+}
+function isBrainMessageDeltaEvent(e) {
+  return e.type === "message_delta";
+}
+function isBrainMessageEndEvent(e) {
+  return e.type === "message_end";
+}
+function isBrainThinkingDeltaEvent(e) {
+  return e.type === "thinking_delta";
+}
+function isBrainToolExecutionStartEvent(e) {
+  return e.type === "tool_execution_start";
+}
+function isBrainToolExecutionUpdateEvent(e) {
+  return e.type === "tool_execution_update";
+}
+function isBrainToolExecutionEndEvent(e) {
+  return e.type === "tool_execution_end";
+}
+function isBrainQueueUpdateEvent(e) {
+  return e.type === "queue_update";
+}
+function isBrainSessionCompactedEvent(e) {
+  return e.type === "session_compacted";
+}
+function isBrainErrorEvent(e) {
+  return e.type === "error";
+}
+function isBrainMemberCostEvent(e) {
+  return e.type === "member_cost";
+}
+function isBrainCouncilModeEvent(e) {
+  return e.type === "council_mode";
+}
 function createBrainEvent(type, sessionId, data) {
   return {
     type,
@@ -19635,9 +19677,90 @@ var init_events = __esm({
 });
 
 // packages/core/dist/shared/eventBus.js
+var EventBus;
 var init_eventBus = __esm({
   "packages/core/dist/shared/eventBus.js"() {
     "use strict";
+    EventBus = class {
+      /** Per-type subscriber registry. */
+      subscribers;
+      /** Wildcard subscribers (receive every event). */
+      wildcardSubscribers;
+      constructor() {
+        this.subscribers = /* @__PURE__ */ new Map();
+        this.wildcardSubscribers = /* @__PURE__ */ new Set();
+      }
+      /** Subscribe to a specific event type. Returns an unsubscribe function. */
+      subscribe(type, handler) {
+        let set2 = this.subscribers.get(type);
+        if (!set2) {
+          set2 = /* @__PURE__ */ new Set();
+          this.subscribers.set(type, set2);
+        }
+        const stored = handler;
+        set2.add(stored);
+        return () => {
+          const current = this.subscribers.get(type);
+          if (!current)
+            return;
+          current.delete(stored);
+          if (current.size === 0)
+            this.subscribers.delete(type);
+        };
+      }
+      /** Subscribe to all events. Returns an unsubscribe function. */
+      subscribeAll(handler) {
+        this.wildcardSubscribers.add(handler);
+        return () => {
+          this.wildcardSubscribers.delete(handler);
+        };
+      }
+      /**
+       * Emit an event to all matching subscribers (typed first, then wildcard).
+       * Errors in individual subscribers are logged but do not prevent other
+       * subscribers from receiving the event.
+       */
+      emit(event) {
+        const set2 = this.subscribers.get(event.type);
+        if (set2) {
+          for (const handler of set2)
+            this.dispatch(handler, event);
+        }
+        for (const handler of this.wildcardSubscribers)
+          this.dispatch(handler, event);
+      }
+      /** Remove all subscribers (typed + wildcard). */
+      clear() {
+        this.subscribers.clear();
+        this.wildcardSubscribers.clear();
+      }
+      /**
+       * Number of subscribers. With a `type`, returns typed subscribers for that
+       * type; without, returns the total across all types plus wildcard handlers.
+       */
+      listenerCount(type) {
+        if (type !== void 0) {
+          return this.subscribers.get(type)?.size ?? 0;
+        }
+        let total = this.wildcardSubscribers.size;
+        for (const set2 of this.subscribers.values())
+          total += set2.size;
+        return total;
+      }
+      /** Invoke a single subscriber, isolating sync throws and async rejections. */
+      dispatch(handler, event) {
+        try {
+          const result = handler(event);
+          if (result instanceof Promise) {
+            result.catch((err) => {
+              console.error("[eventBus] subscriber error:", err);
+            });
+          }
+        } catch (err) {
+          console.error("[eventBus] subscriber error:", err);
+        }
+      }
+    };
   }
 });
 
@@ -19658,6 +19781,14 @@ var init_context = __esm({
 });
 
 // packages/core/dist/types/systemTypes.js
+function createDefaultSystemPromptConfig() {
+  return {
+    enabledSkills: [],
+    enabledTools: [],
+    customPromptModules: [],
+    agentSkillConfigs: []
+  };
+}
 var init_systemTypes = __esm({
   "packages/core/dist/types/systemTypes.js"() {
     "use strict";
@@ -21839,11 +21970,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 path44 = join2(zelariRoot, "nfr-spec.json");
-  if (!existsSync6(path44))
+  const path47 = join2(zelariRoot, "nfr-spec.json");
+  if (!existsSync6(path47))
     return null;
   try {
-    const raw = JSON.parse(readFileSync5(path44, "utf8"));
+    const raw = JSON.parse(readFileSync5(path47, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -24149,9 +24280,9 @@ var init_types3 = __esm({
 import { readFileSync as readFileSync10 } from "node:fs";
 import { join as join8 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path44 = join8(zelariRoot, LESSONS_FILE);
+  const path47 = join8(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync10(path44, "utf8");
+    const raw = readFileSync10(path47, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -24252,8 +24383,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path44 = join9(zelariRoot, LESSONS_FILE);
-  appendFileSync(path44, `${JSON.stringify(lesson)}
+  const path47 = join9(zelariRoot, LESSONS_FILE);
+  appendFileSync(path47, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -24866,9 +24997,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path44 = [];
+    const path47 = [];
     color.set(start, GRAY);
-    path44.push(start);
+    path47.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id, idx] = top;
@@ -24881,17 +25012,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path44.indexOf(dep);
-          return [...path44.slice(at), dep];
+          const at = path47.indexOf(dep);
+          return [...path47.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path44.push(dep);
+          path47.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id, BLACK);
-        path44.pop();
+        path47.pop();
         stack.pop();
       }
     }
@@ -24978,10 +25109,15 @@ function countByStatus(graph) {
     counts[node.status] += 1;
   return counts;
 }
-var DEFAULT_MAX_NODES;
+var TERMINAL_STATUSES, DEFAULT_MAX_NODES;
 var init_graph = __esm({
   "packages/core/dist/kraken/graph.js"() {
     "use strict";
+    TERMINAL_STATUSES = [
+      "done",
+      "error",
+      "skipped"
+    ];
     DEFAULT_MAX_NODES = 24;
   }
 });
@@ -25091,16 +25227,1034 @@ var init_conflict = __esm({
   }
 });
 
+// packages/core/dist/kraken/weakness.js
+function weaknessFromVerdict(text) {
+  if (typeof text !== "string")
+    return 0;
+  const trimmed = text.trim();
+  if (trimmed === "")
+    return 0;
+  let score = 0;
+  for (const re of SPECIFICITY_MARKERS) {
+    if (re.test(trimmed))
+      score += SPECIFICITY_MARKER_WEIGHT;
+  }
+  const clauses = trimmed.split(/[.!?;]+|\n+/).map((c) => c.trim()).filter((c) => c.length > 0 && /\b\w+ing\b|\b\w+ed\b|\bwill\b|\bcan\b|\bmust\b|\bshould\b|\bmay\b/i.test(c));
+  const clausePenalty = Math.min(clauses.length, SPECIFICITY_CLAUSE_MAX) * SPECIFICITY_CLAUSE_WEIGHT;
+  score += clausePenalty;
+  return clamp01(score);
+}
+function weaknessScoreFromText(text) {
+  return 1 - weaknessFromVerdict(text);
+}
+function weaknessFromMeter(meter) {
+  return clamp01(1 - clamp01(meter.specificity));
+}
+function specificityFromAssumptions(assumptions) {
+  if (!Array.isArray(assumptions) || assumptions.length === 0)
+    return 0;
+  const raw = Math.min(assumptions.length, 6) / 6;
+  return clamp01(raw);
+}
+function rankByWeakness(candidates) {
+  if (candidates.length === 0)
+    return [];
+  const raws = candidates.map((c) => computeRaw(c));
+  const extScores = raws.filter((r) => r.source === "extensionSize").map((r) => r.raw);
+  const extMax = extScores.length > 0 ? Math.max(...extScores) : 1;
+  const extMin = extScores.length > 0 ? Math.min(...extScores) : 0;
+  const extRange = extMax - extMin;
+  const scored = raws.map((r) => {
+    let score;
+    switch (r.source) {
+      case "extensionSize":
+        score = extRange > 0 ? (r.raw - extMin) / extRange : 1;
+        break;
+      case "meter":
+        score = clamp01(1 - clamp01(r.raw));
+        break;
+      case "heuristic":
+        score = clamp01(r.raw);
+        break;
+    }
+    return { candidate: r.candidate, score, source: r.source };
+  });
+  const indexed = scored.map((s, i) => ({ ...s, originalIndex: i }));
+  indexed.sort((a, b) => {
+    if (b.score !== a.score)
+      return b.score - a.score;
+    return a.originalIndex - b.originalIndex;
+  });
+  let lastScore;
+  let lastRank = 0;
+  let seen = 0;
+  return indexed.map((s) => {
+    seen += 1;
+    if (lastScore === void 0 || s.score !== lastScore) {
+      lastRank = seen;
+      lastScore = s.score;
+    }
+    return {
+      candidate: s.candidate,
+      weaknessScore: s.score,
+      rank: lastRank,
+      source: s.source
+    };
+  });
+}
+function computeRaw(c) {
+  if (typeof c.extensionSize === "number" && Number.isFinite(c.extensionSize) && c.extensionSize >= 0) {
+    return { candidate: c, raw: c.extensionSize, source: "extensionSize" };
+  }
+  if (c.meter && typeof c.meter.specificity === "number" && Number.isFinite(c.meter.specificity)) {
+    return { candidate: c, raw: clamp01(c.meter.specificity), source: "meter" };
+  }
+  return { candidate: c, raw: weaknessScoreFromText(c.text), source: "heuristic" };
+}
+function clamp01(n) {
+  if (!Number.isFinite(n))
+    return 0;
+  if (n < 0)
+    return 0;
+  if (n > 1)
+    return 1;
+  return n;
+}
+function pickWeakest(candidates) {
+  const ranked = rankByWeakness(candidates);
+  return ranked.length > 0 ? ranked[0].candidate : void 0;
+}
+function filterByWeakness(candidates, threshold) {
+  const ranked = rankByWeakness(candidates);
+  return ranked.filter((r) => r.weaknessScore >= threshold).map((r) => r.candidate);
+}
+var BENNETTS_RAZOR, BENNETTS_RAZOR_SHORT, SPECIFICITY_MARKERS, SPECIFICITY_MARKER_WEIGHT, SPECIFICITY_CLAUSE_WEIGHT, SPECIFICITY_CLAUSE_MAX, WEAKNESS_METER_PROMPT, WeaknessMeterResponseSchema;
+var init_weakness = __esm({
+  "packages/core/dist/kraken/weakness.js"() {
+    "use strict";
+    init_zod();
+    BENNETTS_RAZOR = [
+      "Bennett's Razor (arXiv:2301.12987): explanations should be no more specific than necessary.",
+      "When two solutions both satisfy the task, prefer the one that assumes the least.",
+      'A claim is "more specific" when it pins down an exact value, path, version, or invariant that a more general plan would not have to commit to.',
+      "Specificity is a tie-breaker, not a goal: a plan that is too vague to act on is still useless.",
+      "Weakness ranking only applies among solutions that already meet the bar; do not weaken a passing plan below the bar in the name of weakness."
+    ].join(" ");
+    BENNETTS_RAZOR_SHORT = "Prefer the solution that is no more specific than necessary.";
+    SPECIFICITY_MARKERS = [
+      /\bguarantee[ds]?\b/i,
+      /\bexact(?:ly)?\b/i,
+      /\bmust\b/i,
+      /\bshall\b/i,
+      /\balways\b/i,
+      /\bnever\b/i,
+      /\brequire[ds]?\b/i,
+      /\bmandatory\b/i,
+      /\bline\s+\d+/i,
+      // "line 42"
+      /\bversion\s+[\d.]+/i,
+      // "version 1.2.3"
+      /\bv?\d+\.\d+\.\d+\b/,
+      // bare semver
+      /\b[0-9a-f]{7,40}\b/i,
+      // git short SHA / commit hash
+      /\bthe\s+(?:file|path)\s+(?:is|at)\b/i,
+      /\bprecise(?:ly)?\b/i,
+      /\bassert(?:s|ed|ion)?\b/i,
+      /\bconfirm(?:s|ed)?\b/i,
+      /\bwill\s+(?:definitely|certainly|always)\b/i
+    ];
+    SPECIFICITY_MARKER_WEIGHT = 0.25;
+    SPECIFICITY_CLAUSE_WEIGHT = 0.05;
+    SPECIFICITY_CLAUSE_MAX = 6;
+    WEAKNESS_METER_PROMPT = `You are measuring the SPECIFICITY of a candidate solution to a software task.
+
+Specificity means: how many specific commitments does this solution make that a more general plan would not have to make? Examples of specific commitments: exact file paths, exact line numbers, exact semver versions, exact function signatures, guarantees about runtime behaviour, assertions about what other agents/users will do.
+
+A maximally general solution is one that asserts nothing beyond the task itself ("just do the task"). A maximally specific solution is one that pins every possible value, path, and invariant.
+
+Output ONLY a JSON object of the form:
+{"specificity": <float in [0,1]>, "assumptions": [<short string>, ...]}
+
+where
+- specificity = 0.0  \u2192 solution asserts nothing beyond the task
+- specificity = 1.0  \u2192 solution pins every value, path, version, and invariant
+- assumptions = the list of specific commitments you identified, each \u2264 12 words, deduped, sorted by strength (most specific first). Cap the list at 12.
+
+Do not add prose, do not add a code fence, do not explain your reasoning. JSON only.`;
+    WeaknessMeterResponseSchema = external_exports.object({
+      specificity: external_exports.number().min(0).max(1),
+      assumptions: external_exports.array(external_exports.string().min(1).max(200)).max(12)
+    });
+  }
+});
+
+// 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 extractRequirementsBlock(text) {
+  if (typeof text !== "string" || text.trim() === "")
+    return [];
+  const re = /```json\s*([\s\S]*?)```/gi;
+  let m;
+  let last = null;
+  while ((m = re.exec(text)) !== null) {
+    last = m[1];
+    if (m.index === re.lastIndex)
+      re.lastIndex += 1;
+  }
+  if (!last)
+    return [];
+  try {
+    const obj = JSON.parse(last);
+    if (!obj || !Array.isArray(obj.requirements))
+      return [];
+    const out = [];
+    for (const r of obj.requirements) {
+      if (!r || typeof r !== "object")
+        continue;
+      const row = r;
+      const req = typeof row.requirement === "string" ? row.requirement : "";
+      const metRaw = typeof row.met === "string" ? row.met.toLowerCase() : "";
+      const met = metRaw === "pass" || metRaw === "true" ? "pass" : metRaw === "fail" || metRaw === "false" ? "fail" : "unknown";
+      const evidence = typeof row.evidence === "string" ? row.evidence : void 0;
+      if (req)
+        out.push({ requirement: req, met, ...evidence ? { evidence } : {} });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function parsePersonaVerdict(text) {
+  const base = parseVerifyVerdict(text);
+  return {
+    verdict: base.verdict,
+    findings: base.findings,
+    requirements: extractRequirementsBlock(text),
+    // Bennett's weakness = "how little the reviewer's free text asserts"
+    // (arXiv:2301.12987). `weaknessScoreFromText` is the weakness form
+    // (1.0 = maximally general / no claims; 0.0 = maximally specific).
+    // The verdict gate is the trailer; weakness is metadata surfaced in
+    // the workbench so a user can see whether a PASS was earned by a
+    // tightly-asserted or loosely-claimed reviewer.
+    weaknessScore: weaknessScoreFromText(text)
+  };
+}
+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";
+    init_weakness();
+    MAX_FINDINGS_CHARS = 2800;
+    VERDICT_LINE = /^[\s>*_-]*VERDICT[\s*_]*:[\s*_]*(PASS|FAIL)\b/gim;
+  }
+});
+
+// packages/core/dist/kraken/personas/registry.js
+function registerPersona(p3) {
+  registry3.set(p3.kind, p3);
+}
+function getPersona(kind) {
+  return registry3.get(kind);
+}
+function listPersonas() {
+  return [...registry3.values()];
+}
+function isReviewerKind(kind) {
+  return kind === "verify" || kind === "spec" || kind === "conformance";
+}
+function defaultPersonaParse(text) {
+  return parsePersonaVerdict(text);
+}
+var registry3;
+var init_registry = __esm({
+  "packages/core/dist/kraken/personas/registry.js"() {
+    "use strict";
+    init_verdict();
+    registry3 = /* @__PURE__ */ new Map();
+  }
+});
+
+// packages/core/dist/kraken/personas/specReviewer.js
+var SYSTEM_PROMPT, specPersona;
+var init_specReviewer = __esm({
+  "packages/core/dist/kraken/personas/specReviewer.js"() {
+    "use strict";
+    init_registry();
+    SYSTEM_PROMPT = [
+      "You are the spec-reviewer for Kraken. You compare a writer's delivered",
+      "work against a written spec or plan and judge each requirement.",
+      "",
+      'Your bias is CONSERVATIVE. When the spec said "must do X" and the writer',
+      "did a reasonable but slightly different thing, that is a FAIL. Specs",
+      "are meant to catch exactly this kind of drift.",
+      "",
+      "## Output format",
+      "",
+      "You MUST end with a verdict trailer on its own line:",
+      "",
+      "  VERDICT: PASS",
+      "or",
+      "  VERDICT: FAIL",
+      "",
+      "When the verdict is FAIL, you MUST also emit a per-requirement table in",
+      "a JSON code block, BEFORE the trailer:",
+      "",
+      "```json",
+      "{",
+      '  "requirements": [',
+      '    { "requirement": "<verbatim from the spec>", "met": "pass|fail|unknown", "evidence": "<path, line, command output>" },',
+      "    ...",
+      "  ]",
+      "}",
+      "```",
+      "",
+      "Rules:",
+      "  - Cite concrete evidence (file path, function name, command output).",
+      '    "Looks fine" is not evidence.',
+      "  - When a requirement is partially met, mark it `fail` with evidence",
+      "    describing the gap. The downstream `fix` tentacle will read this.",
+      "  - When a requirement is genuinely impossible to assess without running",
+      "    code, mark it `unknown` and explain why in evidence.",
+      "  - The verdict trailer is the GATE: the executor will not read the",
+      "    table if the trailer says PASS. The table is for diagnostics.",
+      "  - Keep the table terse. One line per row.",
+      "",
+      "## What you do NOT do",
+      "",
+      "  - You do not modify any files. You are a judge, not a fixer.",
+      "  - You do not invent requirements that are not in the spec.",
+      "  - You do not say PASS when the spec listed requirements you did not",
+      "    actually assess. Either assess them or mark them `unknown`."
+    ].join("\n");
+    specPersona = {
+      kind: "spec",
+      label: "spec-reviewer",
+      description: "Compares a writer's output against a written spec, per-requirement.",
+      systemPrompt: SYSTEM_PROMPT
+      // Default parser handles both the trailer and the requirements block.
+    };
+    registerPersona(specPersona);
+  }
+});
+
+// packages/core/dist/kraken/personas/conformance.js
+var SYSTEM_PROMPT2, conformancePersona;
+var init_conformance = __esm({
+  "packages/core/dist/kraken/personas/conformance.js"() {
+    "use strict";
+    init_registry();
+    SYSTEM_PROMPT2 = [
+      "You are the conformance-reviewer for Kraken. You compare a writer's",
+      "delivered work against the USER'S ORIGINAL VERBATIM PROMPT \u2014 not a",
+      "spec, not a plan, not what the writer decided to do.",
+      "",
+      'Your bias is LITERAL. When the user said "use JWT", "use session',
+      'cookies" is a FAIL even if it works. When the user said "ship a CLI",',
+      '"ship a library" is a FAIL even if the library is excellent.',
+      "",
+      "## Decomposition",
+      "",
+      "Before judging, decompose the prompt into the discrete asks the user",
+      "made. A good decomposition:",
+      "  - Each user-stated requirement gets one row.",
+      '  - Each user-stated preference ("preferably X", "ideally Y") gets one row.',
+      '  - Each user-stated constraint ("no dependencies", "stay under 100 LOC") gets one row.',
+      "  - If the prompt is ambiguous, decompose into the LITERAL reading AND",
+      "    note in the evidence that a more permissive reading would have passed.",
+      "",
+      "## Output format",
+      "",
+      "You MUST end with a verdict trailer on its own line:",
+      "",
+      "  VERDICT: PASS",
+      "or",
+      "  VERDICT: FAIL",
+      "",
+      "When the verdict is FAIL, you MUST also emit a per-requirement table in",
+      "a JSON code block, BEFORE the trailer:",
+      "",
+      "```json",
+      "{",
+      '  "requirements": [',
+      '    { "requirement": "<verbatim from the user prompt>", "met": "pass|fail|unknown", "evidence": "<path, line, output>" },',
+      "    ...",
+      "  ]",
+      "}",
+      "```",
+      "",
+      "Rules:",
+      "  - Cite concrete evidence (file path, line, function name, command",
+      '    output) for every row. "Looks right" is not evidence.',
+      "  - When a literal reading would have failed but a more permissive",
+      "    reading would have passed, mark it `fail` with evidence explaining",
+      "    the gap. The user is the authority on what they meant.",
+      '  - When the prompt is genuinely too vague to decompose (e.g. "make it',
+      '    better"), say so explicitly in your findings and mark all rows',
+      "    `unknown`. The downstream fix node will then ask the user.",
+      "  - Keep the table terse. One line per row.",
+      "",
+      "## What you do NOT do",
+      "",
+      "  - You do not consult any spec, plan, or intermediate artifact. Only the",
+      "    original user prompt.",
+      "  - You do not modify any files. You are a judge, not a fixer.",
+      "  - You do not say PASS to be polite. The user has only one chance to",
+      "    see your verdict before shipping; be honest."
+    ].join("\n");
+    conformancePersona = {
+      kind: "conformance",
+      label: "conformance-reviewer",
+      description: "Compares a writer's output against the user's original verbatim prompt.",
+      systemPrompt: SYSTEM_PROMPT2
+    };
+    registerPersona(conformancePersona);
+  }
+});
+
+// packages/core/dist/kraken/personas/index.js
+var init_personas = __esm({
+  "packages/core/dist/kraken/personas/index.js"() {
+    "use strict";
+    init_specReviewer();
+    init_conformance();
+    init_registry();
+  }
+});
+
+// packages/core/dist/kraken/runtime/types.js
+var PlanError;
+var init_types6 = __esm({
+  "packages/core/dist/kraken/runtime/types.js"() {
+    "use strict";
+    PlanError = class extends Error {
+      name = "PlanError";
+      kind;
+      cause;
+      constructor(kind, message, cause) {
+        super(message);
+        this.kind = kind;
+        if (cause !== void 0)
+          this.cause = cause;
+      }
+    };
+  }
+});
+
+// packages/core/dist/kraken/runtime/sandbox.js
+import vm from "node:vm";
+function scanForFootguns(bundleCode) {
+  if (bundleCode.length > MAX_BUNDLE_BYTES) {
+    return [
+      `bundle is ${bundleCode.length} bytes; max is ${MAX_BUNDLE_BYTES} (LLM is almost certainly looping)`
+    ];
+  }
+  const hits = [];
+  for (const re of FORBIDDEN_TOKENS) {
+    const m = re.exec(bundleCode);
+    if (m)
+      hits.push(`forbidden token "${m[0]}"`);
+  }
+  return hits;
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Object.isFrozen(value))
+    return value;
+  const obj = value;
+  for (const k of Object.keys(obj))
+    deepFreeze(obj[k]);
+  return Object.freeze(value);
+}
+async function runInSandbox(opts) {
+  const { bundleCode, sdk, timeoutMs } = opts;
+  if (!opts.skipFootgunScan) {
+    const footguns = scanForFootguns(bundleCode);
+    if (footguns.length > 0) {
+      throw new PlanError("sandbox_breach", `script bundle failed footgun scan: ${footguns.join("; ")}`);
+    }
+  }
+  const frozen = deepFreeze({ ...sdk });
+  const sandbox = {
+    __zelari_sdk__: frozen,
+    // A console that prefixes lines with the graph id; useful for the
+    // workbench view and harmless to expose (it just logs to stdout).
+    console: makeSandboxConsole()
+  };
+  const context = vm.createContext(sandbox, {
+    name: "kraken-script",
+    codeGeneration: { strings: false, wasm: false }
+  });
+  const start = Date.now();
+  const vmOpts = {
+    timeout: Math.max(1, timeoutMs),
+    displayErrors: true,
+    breakOnSigint: true
+  };
+  try {
+    const value = await vm.runInContext(bundleCode, context, vmOpts);
+    return { value, durationMs: Date.now() - start };
+  } catch (err) {
+    const msg = err && typeof err === "object" && "message" in err ? String(err.message ?? "") : String(err);
+    if (/timed out/i.test(msg)) {
+      throw new PlanError("budget_exceeded", `script exceeded ${timeoutMs}ms budget`);
+    }
+    if (opts.signal?.aborted) {
+      throw new PlanError("cancelled", "script aborted by host");
+    }
+    if (err instanceof PlanError)
+      throw err;
+    throw new PlanError("runtime_error", msg, err);
+  }
+}
+function makeSandboxConsole() {
+  const prefix = "[kraken-script]";
+  return {
+    ...console,
+    log: (...args) => console.log(prefix, ...args),
+    info: (...args) => console.info(prefix, ...args),
+    warn: (...args) => console.warn(prefix, ...args),
+    error: (...args) => console.error(prefix, ...args)
+  };
+}
+var MAX_BUNDLE_BYTES, FORBIDDEN_TOKENS;
+var init_sandbox = __esm({
+  "packages/core/dist/kraken/runtime/sandbox.js"() {
+    "use strict";
+    init_types6();
+    MAX_BUNDLE_BYTES = 256 * 1024;
+    FORBIDDEN_TOKENS = [
+      /\bprocess\b/,
+      /\brequire\b/,
+      /\bmodule\b/,
+      /\bexports\b/,
+      /\b__dirname\b/,
+      /\b__filename\b/,
+      /\bglobalThis\b/,
+      /\bglobal\b(?!\s*=)/,
+      /\bBuffer\b/,
+      /\beval\b/,
+      /\bFunction\s*\(/,
+      /\bnew\s+Function\b/
+    ];
+  }
+});
+
+// packages/core/dist/kraken/runtime/runner.js
+function resolveMaxTentacles(env = process.env) {
+  const raw = env.ZELARI_KRAKEN_MAX_TENTACLES;
+  if (raw === void 0 || raw === "")
+    return DEFAULT_MAX_TENTACLES;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_MAX_TENTACLES;
+}
+function resolvePlanTimeoutMs(env = process.env) {
+  const raw = env.ZELARI_KRAKEN_PLAN_TIMEOUT_MS;
+  if (raw === void 0 || raw === "")
+    return DEFAULT_PLAN_TIMEOUT_MS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_PLAN_TIMEOUT_MS;
+}
+function cap(text, max) {
+  if (text.length <= max)
+    return text;
+  return `${text.slice(0, max)}
+\u2026 [truncated]`;
+}
+function buildRef(id, opts, result) {
+  const findings = cap(result.ok ? (result.result ?? "").trim() : result.error ?? "unknown error", MAX_FINDINGS_CHARS);
+  const ref = {
+    id,
+    kind: opts.kind,
+    label: opts.label,
+    status: result.ok ? "done" : "error",
+    findings,
+    scope: opts.scope,
+    ...result.durationMs !== void 0 ? { durationMs: result.durationMs } : {},
+    ...result.worktree !== void 0 ? { worktree: result.worktree } : {}
+  };
+  if (isReviewerKind(opts.kind)) {
+    ref.verdict = defaultPersonaParse(findings).verdict;
+  }
+  return ref;
+}
+var DEFAULT_MAX_TENTACLES, DEFAULT_PLAN_TIMEOUT_MS, ScriptRunner;
+var init_runner = __esm({
+  "packages/core/dist/kraken/runtime/runner.js"() {
+    "use strict";
+    init_verdict();
+    init_personas();
+    init_types6();
+    DEFAULT_MAX_TENTACLES = 200;
+    DEFAULT_PLAN_TIMEOUT_MS = 30 * 6e4;
+    ScriptRunner = class {
+      host;
+      goal;
+      graphId;
+      parentCwd;
+      sessionId;
+      maxTentacles;
+      planTimeoutMs;
+      startTime;
+      tentaclesById = /* @__PURE__ */ new Map();
+      tentacleCount = 0;
+      mergeCount = 0;
+      cancelled = false;
+      constructor(opts) {
+        this.host = opts.host;
+        this.goal = opts.goal;
+        this.graphId = opts.graphId;
+        this.parentCwd = opts.parentCwd;
+        this.sessionId = opts.sessionId;
+        this.maxTentacles = opts.maxTentacles ?? resolveMaxTentacles();
+        this.planTimeoutMs = opts.planTimeoutMs ?? resolvePlanTimeoutMs();
+        this.startTime = Date.now();
+      }
+      /** Build the `PlanCapabilities` object the sandbox will see. */
+      buildSdk() {
+        return {
+          tentacle: (opts) => this.callTentacle(opts),
+          barrier: (refs) => this.callBarrier(refs),
+          race: (refs) => this.callRace(refs),
+          while_: (cond, body, maxIter) => this.callWhile(cond, body, maxIter),
+          until: (cond, body, maxIter) => this.callUntil(cond, body, maxIter),
+          merge: (refs, opts) => this.callMerge(refs, opts),
+          checkpoint: (label) => this.callCheckpoint(label),
+          log: (msg, data) => this.callLog(msg, data),
+          emit: (payload) => this.callEmit(payload),
+          getContext: () => this.callGetContext(),
+          sendTo: (peerId, payload) => this.callSendTo(peerId, payload)
+        };
+      }
+      /** One tentacle = one `runTentacle` call. The host returns a raw result;
+       *  we turn it into a `TentacleRef` and stash it. */
+      async callTentacle(opts) {
+        if (this.cancelled)
+          throw new PlanError("cancelled", "runner is cancelled");
+        if (this.tentacleCount >= this.maxTentacles) {
+          throw new PlanError("budget_exceeded", `tentacle cap (${this.maxTentacles}) reached; raise ZELARI_KRAKEN_MAX_TENTACLES`);
+        }
+        if (this.tentacleCount > 0 && Date.now() - this.startTime > this.planTimeoutMs) {
+          throw new PlanError("budget_exceeded", `plan wall-clock budget (${this.planTimeoutMs}ms) exceeded`);
+        }
+        this.tentacleCount += 1;
+        const id = `t${String(this.tentacleCount).padStart(4, "0")}`;
+        const res = await this.host.runTentacle({
+          node: opts,
+          parentCwd: this.parentCwd,
+          sessionId: this.sessionId
+        });
+        const ref = buildRef(id, opts, res);
+        this.tentaclesById.set(id, ref);
+        return ref;
+      }
+      async callBarrier(refs) {
+        if (refs.some((r) => !this.tentaclesById.has(r.id))) {
+          throw new PlanError("runtime_error", "barrier() received a ref not in this runner");
+        }
+        return refs;
+      }
+      async callRace(refs) {
+        if (refs.length === 0) {
+          throw new PlanError("runtime_error", "race() requires at least one ref");
+        }
+        let winner = refs[0];
+        for (const r of refs) {
+          const a = winner.durationMs ?? Number.POSITIVE_INFINITY;
+          const b = r.durationMs ?? Number.POSITIVE_INFINITY;
+          if (b < a || b === a && r.id < winner.id)
+            winner = r;
+        }
+        return winner;
+      }
+      async callWhile(cond, body, maxIter) {
+        if (maxIter < 1)
+          throw new PlanError("runtime_error", "while_() maxIter must be \u2265 1");
+        const out = [];
+        let iter = 0;
+        while (await cond()) {
+          if (iter >= maxIter) {
+            throw new PlanError("budget_exceeded", `while_() exceeded maxIter=${maxIter} without cond turning false`);
+          }
+          out.push(await body());
+          iter += 1;
+        }
+        return out;
+      }
+      async callUntil(cond, body, maxIter) {
+        return this.callWhile(async () => !await cond(), body, maxIter);
+      }
+      /** One merge per plan. A second call is a structured error. */
+      async callMerge(refs, opts = {}) {
+        if (this.mergeCount > 0) {
+          throw new PlanError("merge_already_done", "merge() called more than once; a plan can merge at most one batch");
+        }
+        if (refs.length === 0) {
+          throw new PlanError("runtime_error", "merge() requires at least one ref");
+        }
+        for (const r of refs) {
+          if (!this.tentaclesById.has(r.id)) {
+            throw new PlanError("runtime_error", `merge() received unknown ref "${r.id}"`);
+          }
+        }
+        this.mergeCount += 1;
+        return this.host.mergeWorktrees({
+          refs,
+          parentCwd: this.parentCwd,
+          strategy: opts.strategy ?? "squash-sequential",
+          ...opts.message ? { message: opts.message } : {},
+          ...opts.cleanup !== void 0 ? { cleanup: opts.cleanup } : {}
+        });
+      }
+      async callCheckpoint(label) {
+        const snapshot = {
+          graphId: this.graphId,
+          goal: this.goal,
+          takenAt: (/* @__PURE__ */ new Date()).toISOString(),
+          completed: [...this.tentaclesById.values()].filter((r) => r.status === "done"),
+          inFlight: [...this.tentaclesById.values()].filter((r) => r.status === "running"),
+          failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
+          pending: []
+        };
+        const path47 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path47}`);
+        return snapshot;
+      }
+      callLog(msg, data) {
+        const line = data ? `${msg} ${JSON.stringify(data)}` : msg;
+        this.host.log(line);
+      }
+      callEmit(payload) {
+        this.host.log(`emit: ${payload.kind}${payload.detail ? ` \u2014 ${payload.detail}` : ""}`);
+      }
+      callGetContext() {
+        return {
+          graphId: this.graphId,
+          goal: this.goal,
+          parentCwd: this.parentCwd,
+          sessionId: this.sessionId,
+          tentacles: this.tentaclesById,
+          maxTentacles: this.maxTentacles,
+          planTimeoutMs: this.planTimeoutMs
+        };
+      }
+      callSendTo(peerId, payload) {
+        this.host.log(`sendTo(${peerId}): ${payload.kind}${payload.detail ? ` \u2014 ${payload.detail}` : ""}`);
+      }
+      /** Called by the host after the sandbox returns, to mark the run. */
+      finalize(opts) {
+        if (opts.cancelled)
+          this.cancelled = true;
+        const failed = [...this.tentaclesById.values()].filter((r) => r.status === "error");
+        return {
+          tentacles: this.tentaclesById,
+          mergeCount: this.mergeCount,
+          converged: opts.converged,
+          cancelled: this.cancelled,
+          durationMs: Date.now() - this.startTime,
+          unresolvedFindings: failed.map((r) => ({
+            nodeId: r.id,
+            label: r.label,
+            reason: r.status === "error" ? "fail" : "unknown",
+            findings: r.findings
+          }))
+        };
+      }
+    };
+  }
+});
+
+// packages/core/dist/kraken/runtime/index.js
+var init_runtime = __esm({
+  "packages/core/dist/kraken/runtime/index.js"() {
+    "use strict";
+    init_types6();
+    init_sandbox();
+    init_runner();
+  }
+});
+
 // packages/core/dist/kraken/index.js
 var init_kraken = __esm({
   "packages/core/dist/kraken/index.js"() {
     "use strict";
     init_graph();
     init_conflict();
+    init_verdict();
+    init_personas();
+    init_runtime();
+    init_weakness();
   }
 });
 
 // packages/core/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  ADVANCED_TOOL_DEFINITIONS: () => ADVANCED_TOOL_DEFINITIONS,
+  AGENT_ROLES: () => AGENT_ROLES,
+  ALL_TOOLS: () => ALL_TOOLS,
+  AgentHarness: () => AgentHarness,
+  BENNETTS_RAZOR: () => BENNETTS_RAZOR,
+  BENNETTS_RAZOR_SHORT: () => BENNETTS_RAZOR_SHORT,
+  CLARIFICATION_PROTOCOL_MODULE: () => CLARIFICATION_PROTOCOL_MODULE,
+  CODING_CATEGORY: () => CODING_CATEGORY,
+  CODING_PRACTICES_MODULE: () => CODING_PRACTICES_MODULE,
+  CODING_SKILL_CATALOG: () => CODING_SKILL_CATALOG,
+  COLLABORATION_DIRECTIVE: () => COLLABORATION_DIRECTIVE,
+  COMPOSITOR_ONLY_PROPS: () => COMPOSITOR_ONLY_PROPS,
+  DEFAULT_MAX_NODES: () => DEFAULT_MAX_NODES,
+  DEFAULT_MAX_TENTACLES: () => DEFAULT_MAX_TENTACLES,
+  DEFAULT_NFR_SPEC: () => DEFAULT_NFR_SPEC,
+  DEFAULT_PLAN_TIMEOUT_MS: () => DEFAULT_PLAN_TIMEOUT_MS,
+  DEGRADED_RUN_BANNER: () => DEGRADED_RUN_BANNER,
+  DESIGN_PHASE_MODE_BANNER: () => DESIGN_PHASE_MODE_BANNER,
+  DESIGN_PHASE_REQUIREMENTS: () => DESIGN_PHASE_REQUIREMENTS,
+  DESIGN_PHASE_REQUIREMENT_SETS: () => DESIGN_PHASE_REQUIREMENT_SETS,
+  DOOM_LOOP_THRESHOLD: () => DOOM_LOOP_THRESHOLD,
+  EventBus: () => EventBus,
+  IMPLEMENTATION_ADVISOR_BANNER: () => IMPLEMENTATION_ADVISOR_BANNER,
+  IMPLEMENTATION_IMPLEMENTER_BANNER: () => IMPLEMENTATION_IMPLEMENTER_BANNER,
+  IMPLEMENTATION_MODE_BANNER: () => IMPLEMENTATION_MODE_BANNER,
+  IMPLEMENTATION_WRITE_REQUIREMENTS: () => IMPLEMENTATION_WRITE_REQUIREMENTS,
+  KRAKEN_IDENTITY_MODULE: () => KRAKEN_IDENTITY_MODULE,
+  KRAKEN_LEAD_PLAYBOOK_MODULE: () => KRAKEN_LEAD_PLAYBOOK_MODULE,
+  LANGUAGE_POLICY_MODULE_TYPE: () => LANGUAGE_POLICY_MODULE_TYPE,
+  LAYOUT_MOTION_PROPS: () => LAYOUT_MOTION_PROPS,
+  LESSONS_FILE: () => LESSONS_FILE,
+  MAX_DELIVERY_ATTEMPTS: () => MAX_DELIVERY_ATTEMPTS,
+  MAX_FINDINGS_CHARS: () => MAX_FINDINGS_CHARS,
+  MAX_RETRY_PER_MEMBER: () => MAX_RETRY_PER_MEMBER,
+  MUTATING_PROJECT_TOOLS: () => MUTATING_PROJECT_TOOLS,
+  NATIVE_TOOL_PROTOCOL_MODULE: () => NATIVE_TOOL_PROTOCOL_MODULE,
+  NFR_KEYWORDS: () => NFR_KEYWORDS,
+  NON_RETRY_AGENTS: () => NON_RETRY_AGENTS,
+  OUTPUT_QUALITY_DIRECTIVE: () => OUTPUT_QUALITY_DIRECTIVE,
+  PROMPT_MODULES: () => PROMPT_MODULES,
+  PROPRIETARY_REFUSAL_TEXT: () => PROPRIETARY_REFUSAL_TEXT,
+  PROPRIETARY_SECRECY_MARKER: () => PROPRIETARY_SECRECY_MARKER,
+  PROPRIETARY_SECRECY_MODULE: () => PROPRIETARY_SECRECY_MODULE,
+  PlanError: () => PlanError,
+  SINGLE_AGENT_IDENTITY_MODULE: () => SINGLE_AGENT_IDENTITY_MODULE,
+  SKILL_CATALOG: () => SKILL_CATALOG,
+  STRUCTURED_REASONING_DIRECTIVE: () => STRUCTURED_REASONING_DIRECTIVE,
+  ScriptRunner: () => ScriptRunner,
+  SessionJsonlWriter: () => SessionJsonlWriter,
+  TERMINAL_STATUSES: () => TERMINAL_STATUSES,
+  TEXT_LOOP_RECOVERY_SYSTEM: () => TEXT_LOOP_RECOVERY_SYSTEM,
+  TEXT_LOOP_RECOVERY_USER_PROMPT: () => TEXT_LOOP_RECOVERY_USER_PROMPT,
+  TIER_RANK: () => TIER_RANK,
+  TOOL_DEFINITIONS: () => TOOL_DEFINITIONS,
+  TOOL_USE_PROTOCOL_DIRECTIVE: () => TOOL_USE_PROTOCOL_DIRECTIVE,
+  TURN_COMPLETION_MODULE: () => TURN_COMPLETION_MODULE,
+  UnknownMemberError: () => UnknownMemberError,
+  VAULT_TOOL_DEFINITIONS: () => VAULT_TOOL_DEFINITIONS,
+  WEAKNESS_METER_PROMPT: () => WEAKNESS_METER_PROMPT,
+  WeaknessMeterResponseSchema: () => WeaknessMeterResponseSchema,
+  applyCompletionRetry: () => applyCompletionRetry,
+  applyDeterministicAutofix: () => applyDeterministicAutofix,
+  applyImplementationWriteRetry: () => applyImplementationWriteRetry,
+  applyInlineJsAutofix: () => applyInlineJsAutofix,
+  applyMotionAutofix: () => applyMotionAutofix,
+  applyRetryIfMissing: () => applyRetryIfMissing,
+  auditDegradedBanner: () => auditDegradedBanner,
+  auditSynthesisTiers: () => auditSynthesisTiers,
+  buildCouncilCompletion: () => buildCouncilCompletion,
+  buildCustomParameters: () => buildCustomParameters,
+  buildDeliveryFixPrompt: () => buildDeliveryFixPrompt,
+  buildImplementationVerifyRetryPrompt: () => buildImplementationVerifyRetryPrompt,
+  buildImplementationWriteRetryPrompt: () => buildImplementationWriteRetryPrompt,
+  buildLanguageDirective: () => buildLanguageDirective,
+  buildLanguagePolicyModule: () => buildLanguagePolicyModule,
+  buildLanguagePolicyModuleFor: () => buildLanguagePolicyModuleFor,
+  buildMissionBrief: () => buildMissionBrief,
+  buildMotionFixPrompt: () => buildMotionFixPrompt,
+  buildRetryPrompt: () => buildRetryPrompt,
+  buildSkillDefinition: () => buildSkillDefinition,
+  buildSystemPrompt: () => buildSystemPrompt,
+  buildSystemPromptSplit: () => buildSystemPromptSplit,
+  canRunParallel: () => canRunParallel,
+  captureFailure: () => captureFailure,
+  checkImplementationCompletion: () => checkImplementationCompletion,
+  checkImplementationDelivery: () => checkImplementationDelivery,
+  checkMemberToolEmissionSets: () => checkMemberToolEmissionSets,
+  checkMemberToolEmissions: () => checkMemberToolEmissions,
+  classifyMission: () => classifyMission,
+  classifyTaskScope: () => classifyTaskScope,
+  cleanAgentContent: () => cleanAgentContent,
+  clearCustomTools: () => clearCustomTools,
+  cliToolToEnhanced: () => cliToolToEnhanced,
+  collapseLoopedAssistantText: () => collapseLoopedAssistantText,
+  computeAgentSkills: () => computeAgentSkills,
+  computeAgentTools: () => computeAgentTools,
+  councilModeBanner: () => councilModeBanner,
+  councilTierFromSize: () => councilTierFromSize,
+  countByStatus: () => countByStatus,
+  countEmittedWriteTools: () => countEmittedWriteTools,
+  createBrainEvent: () => createBrainEvent,
+  createDefaultSystemPromptConfig: () => createDefaultSystemPromptConfig,
+  createGraph: () => createGraph,
+  defaultPersonaParse: () => defaultPersonaParse,
+  detectAssistantTextLoop: () => detectAssistantTextLoop,
+  detectDegradedRun: () => detectDegradedRun,
+  detectResponseLanguage: () => detectResponseLanguage,
+  disjointScopeSets: () => disjointScopeSets,
+  enforceDesignPhaseToolEmissions: () => enforceDesignPhaseToolEmissions,
+  executeTool: () => executeTool,
+  extractCitations: () => extractCitations,
+  extractRequirementsBlock: () => extractRequirementsBlock,
+  extractTaskScope: () => extractTaskScope,
+  failedNodeIds: () => failedNodeIds,
+  filterByWeakness: () => filterByWeakness,
+  filterDeliveryBlockingFails: () => filterDeliveryBlockingFails,
+  findCodingSkillsByCategory: () => findCodingSkillsByCategory,
+  findCodingSkillsByTag: () => findCodingSkillsByTag,
+  findSkillsByIds: () => findSkillsByIds,
+  findSkillsByTag: () => findSkillsByTag,
+  formatLessonsForContext: () => formatLessonsForContext,
+  getAgent: () => getAgent,
+  getAllTools: () => getAllTools,
+  getAvailableTools: () => getAvailableTools,
+  getBasePromptModules: () => getBasePromptModules,
+  getBuiltinSkillIds: () => getBuiltinSkillIds,
+  getCodingSkillById: () => getCodingSkillById,
+  getCouncilAgents: () => getCouncilAgents,
+  getCouncilDirectiveModules: () => getCouncilDirectiveModules,
+  getPersona: () => getPersona,
+  getPromptModule: () => getPromptModule,
+  getProviderTools: () => getProviderTools,
+  getReadyNodes: () => getReadyNodes,
+  getSkillById: () => getSkillById,
+  getSkillMetadata: () => getSkillMetadata,
+  getSkillsByCategory: () => getSkillsByCategory,
+  getToolDescriptions: () => getToolDescriptions,
+  hasInteractiveClarification: () => hasInteractiveClarification,
+  hashToolCall: () => hashToolCall,
+  isAnswerLeak: () => isAnswerLeak,
+  isBrainAgentEndEvent: () => isBrainAgentEndEvent,
+  isBrainAgentStartEvent: () => isBrainAgentStartEvent,
+  isBrainCouncilModeEvent: () => isBrainCouncilModeEvent,
+  isBrainErrorEvent: () => isBrainErrorEvent,
+  isBrainMemberCostEvent: () => isBrainMemberCostEvent,
+  isBrainMessageDeltaEvent: () => isBrainMessageDeltaEvent,
+  isBrainMessageEndEvent: () => isBrainMessageEndEvent,
+  isBrainMessageStartEvent: () => isBrainMessageStartEvent,
+  isBrainQueueUpdateEvent: () => isBrainQueueUpdateEvent,
+  isBrainSessionCompactedEvent: () => isBrainSessionCompactedEvent,
+  isBrainThinkingDeltaEvent: () => isBrainThinkingDeltaEvent,
+  isBrainToolExecutionEndEvent: () => isBrainToolExecutionEndEvent,
+  isBrainToolExecutionStartEvent: () => isBrainToolExecutionStartEvent,
+  isBrainToolExecutionUpdateEvent: () => isBrainToolExecutionUpdateEvent,
+  isConverged: () => isConverged,
+  isReviewerKind: () => isReviewerKind,
+  isSettled: () => isSettled,
+  isStatusTheaterUnit: () => isStatusTheaterUnit,
+  isValidTool: () => isValidTool,
+  isVerifyToolCheckSkipped: () => isVerifyToolCheckSkipped,
+  jaccardSimilarity: () => jaccardSimilarity,
+  lintSynthesisHonesty: () => lintSynthesisHonesty,
+  listCodingSkills: () => listCodingSkills,
+  listPersonas: () => listPersonas,
+  listSkills: () => listSkills,
+  loadNfrSpec: () => loadNfrSpec,
+  matchCheckPrefix: () => matchCheckPrefix,
+  normalizeForSignature: () => normalizeForSignature,
+  normalizeLoopUnit: () => normalizeLoopUnit,
+  normalizeScopePath: () => normalizeScopePath,
+  normalizeTextToolArgs: () => normalizeTextToolArgs,
+  parseClarificationRequest: () => parseClarificationRequest,
+  parseEvidenceTier: () => parseEvidenceTier,
+  parseMinimaxStyleToolCalls: () => parseMinimaxStyleToolCalls,
+  parsePersonaVerdict: () => parsePersonaVerdict,
+  parseProjectRootFromWorkspaceContext: () => parseProjectRootFromWorkspaceContext,
+  parseTextToolCalls: () => parseTextToolCalls,
+  parseThinking: () => parseThinking,
+  parseVerificationTable: () => parseVerificationTable,
+  parseVerifyVerdict: () => parseVerifyVerdict,
+  pathsOverlap: () => pathsOverlap,
+  pickWeakest: () => pickWeakest,
+  promoteMember: () => promoteMember,
+  rankByWeakness: () => rankByWeakness,
+  readLessonsDeduped: () => readLessonsDeduped,
+  readSession: () => readSession,
+  recallLessons: () => recallLessons,
+  registerCodingSkill: () => registerCodingSkill,
+  registerCustomTool: () => registerCustomTool,
+  registerPersona: () => registerPersona,
+  registerSkill: () => registerSkill,
+  renderSkillMarkdown: () => renderSkillMarkdown,
+  replayChairmanTextTools: () => replayChairmanTextTools,
+  resolveAgentSkills: () => resolveAgentSkills,
+  resolveCouncilRunMode: () => resolveCouncilRunMode,
+  resolveMaxTentacles: () => resolveMaxTentacles,
+  resolvePlanTimeoutMs: () => resolvePlanTimeoutMs,
+  resolveResponseLanguage: () => resolveResponseLanguage,
+  resolveRoleSystemPrompt: () => resolveRoleSystemPrompt,
+  resolveSkillDependencies: () => resolveSkillDependencies,
+  resolveVerifyRetryTool: () => resolveVerifyRetryTool,
+  restrictImplementationWrites: () => restrictImplementationWrites,
+  runChairmanDeliveryLoop: () => runChairmanDeliveryLoop,
+  runChairmanFixLoop: () => runChairmanFixLoop,
+  runChairmanMicroGate: () => runChairmanMicroGate,
+  runCouncilPure: () => runCouncilPure,
+  runImplementationVerification: () => runImplementationVerification,
+  runInSandbox: () => runInSandbox,
+  runMicroVerificationOnFile: () => runMicroVerificationOnFile,
+  runRetryTurnForMember: () => runRetryTurnForMember,
+  scanForFootguns: () => scanForFootguns,
+  scanKeyframesViolations: () => scanKeyframesViolations,
+  scanTransitionViolations: () => scanTransitionViolations,
+  scrubProprietaryLeak: () => scrubProprietaryLeak,
+  selectParallelWave: () => selectParallelWave,
+  setWorkspaceStubs: () => setWorkspaceStubs,
+  shouldRetryMember: () => shouldRetryMember,
+  slugify: () => slugify2,
+  specificityFromAssumptions: () => specificityFromAssumptions,
+  stripClarificationProtocol: () => stripClarificationProtocol,
+  swapMembers: () => swapMembers,
+  systemMessagesFromSplit: () => systemMessagesFromSplit,
+  taskMatchesNfrKeywords: () => taskMatchesNfrKeywords,
+  tierAtLeast: () => tierAtLeast,
+  tokenizeForSignature: () => tokenizeForSignature,
+  topoLevels: () => topoLevels,
+  unregisterCustomTool: () => unregisterCustomTool,
+  unregisterSkill: () => unregisterSkill,
+  validateCodingSkillRequires: () => validateCodingSkillRequires,
+  validateGraph: () => validateGraph,
+  verifyCitations: () => verifyCitations,
+  warnIfNfrSpecMissing: () => warnIfNfrSpecMissing,
+  weaknessFromMeter: () => weaknessFromMeter,
+  weaknessFromVerdict: () => weaknessFromVerdict,
+  weaknessScoreFromText: () => weaknessScoreFromText,
+  wrapLegacyStream: () => wrapLegacyStream,
+  writeCouncilCompletion: () => writeCouncilCompletion,
+  writeVerificationReport: () => writeVerificationReport
+});
 var init_dist = __esm({
   "packages/core/dist/index.js"() {
     "use strict";
@@ -25118,8 +26272,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 +26304,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 +26392,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 +26404,7 @@ var init_graphStatus = __esm({
       error: "\u2717",
       skipped: "\xBB"
     };
+    DEFAULT_DIGEST_RESULT_CHARS = 200;
   }
 });
 
@@ -25700,9 +26898,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 path44 = join11(dir, file2);
-    writeFileSync10(path44, fullText, "utf8");
-    return path44;
+    const path47 = join11(dir, file2);
+    writeFileSync10(path47, fullText, "utf8");
+    return path47;
   } catch {
     return null;
   }
@@ -25718,21 +26916,21 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
   if (text.length === 0)
     return text;
   const opts = typeof capOrOpts === "number" ? { cap: capOrOpts } : capOrOpts ?? {};
-  const cap2 = typeof opts.cap === "number" && Number.isFinite(opts.cap) && opts.cap >= 10 ? opts.cap : TOOL_RESULT_LINE_CAP;
+  const cap3 = typeof opts.cap === "number" && Number.isFinite(opts.cap) && opts.cap >= 10 ? opts.cap : TOOL_RESULT_LINE_CAP;
   const doSpill = opts.spill !== false;
   const lines = text.split("\n");
-  const charBudget = cap2 * 80;
-  const overLines = lines.length > cap2;
-  const overChars = text.length > charBudget && lines.length <= cap2;
+  const charBudget = cap3 * 80;
+  const overLines = lines.length > cap3;
+  const overChars = text.length > charBudget && lines.length <= cap3;
   if (!overLines && !overChars)
     return text;
   let preview;
   let marker;
   if (overLines) {
-    const half = Math.floor(cap2 / 2);
+    const half = Math.floor(cap3 / 2);
     const head = lines.slice(0, half);
     const tail = lines.slice(lines.length - half);
-    const omitted = lines.length - cap2;
+    const omitted = lines.length - cap3;
     marker = `+${omitted} lines omitted \u2014 showing head:${half}, tail:${half} of ${lines.length} total`;
     preview = head.join("\n") + `
 \u2026 [${marker}] \u2026
@@ -25748,10 +26946,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail}`;
   }
   if (doSpill) {
-    const path44 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path44) {
+    const path47 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path47) {
       const spillNote = `
-\u2026 [full output spilled to: ${path44} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path47} \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}
 `);
@@ -25763,7 +26961,7 @@ ${tail}`;
   return preview;
 }
 var TOOL_NAME_ALIASES, TOOL_RESULT_LINE_CAP, ToolRegistry;
-var init_registry = __esm({
+var init_registry2 = __esm({
   "packages/core/dist/core/tools/registry.js"() {
     "use strict";
     init_zodBridge();
@@ -26621,7 +27819,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 {
@@ -26697,7 +27895,7 @@ async function runTentacle(opts) {
     model: sub.model,
     provider: sub.provider,
     messages: [
-      { role: "system", content: systemPromptForAgent(agent) },
+      { role: "system", content: opts.systemPromptOverride ?? systemPromptForAgent(agent) },
       { role: "user", content: userContent }
     ],
     tools: sub.tools,
@@ -28692,21 +29890,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path44 = getSshSecretsPath();
-  if (!existsSync17(path44)) return {};
+  const path47 = getSshSecretsPath();
+  if (!existsSync17(path47)) return {};
   try {
-    return JSON.parse(readFileSync16(path44, "utf8"));
+    return JSON.parse(readFileSync16(path47, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path44 = getSshSecretsPath();
-  mkdirSync9(dirname2(path44), { recursive: true });
-  writeFileSync11(path44, `${JSON.stringify(data, null, 2)}
+  const path47 = getSshSecretsPath();
+  mkdirSync9(dirname2(path47), { recursive: true });
+  writeFileSync11(path47, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path44, 384);
+    chmodSync(path47, 384);
   } catch {
   }
 }
@@ -28735,10 +29933,10 @@ function deleteSshPassword(id) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path44 = getSshTargetsPath();
-  if (!existsSync17(path44)) return [];
+  const path47 = getSshTargetsPath();
+  if (!existsSync17(path47)) return [];
   try {
-    const parsed = JSON.parse(readFileSync16(path44, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path47, "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"
@@ -28753,11 +29951,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path44 = getSshTargetsPath();
-  mkdirSync9(dirname2(path44), { recursive: true });
+  const path47 = getSshTargetsPath();
+  mkdirSync9(dirname2(path47), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync11(
-    path44,
+    path47,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -28916,12 +30114,12 @@ function runSsh(target, remoteCommand, timeoutMs = 6e4) {
     });
     let stdout = "";
     let stderr = "";
-    const cap2 = 4e4;
+    const cap3 = 4e4;
     child.stdout?.on("data", (d) => {
-      if (stdout.length < cap2) stdout += d.toString("utf8");
+      if (stdout.length < cap3) stdout += d.toString("utf8");
     });
     child.stderr?.on("data", (d) => {
-      if (stderr.length < cap2) stderr += d.toString("utf8");
+      if (stderr.length < cap3) stderr += d.toString("utf8");
     });
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
@@ -29003,11 +30201,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path44 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path47 = 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}${path44}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path47}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -29518,7 +30716,8 @@ __export(krakenModel_exports, {
   isKrakenAutoModelEnabled: () => isKrakenAutoModelEnabled,
   pickCheapModel: () => pickCheapModel,
   resolveKrakenSubModel: () => resolveKrakenSubModel,
-  resolveKrakenSubModelAsync: () => resolveKrakenSubModelAsync
+  resolveKrakenSubModelAsync: () => resolveKrakenSubModelAsync,
+  resolvePersonaModel: () => resolvePersonaModel
 });
 function isCheapModelId(id) {
   if (!id) return false;
@@ -29568,6 +30767,12 @@ function resolveKrakenSubModel(agent, parentModel, env = process.env, opts = {})
   }
   return parentModel;
 }
+function resolvePersonaModel(kind, parentModel, env = process.env, opts = {}) {
+  const personaKey = kind === "spec" ? "ZELARI_KRAKEN_SPEC_MODEL" : kind === "conformance" ? "ZELARI_KRAKEN_CONFORMANCE_MODEL" : kind === "oracle" ? "ZELARI_KRAKEN_ORACLE_MODEL" : "";
+  const specific = personaKey ? env[personaKey]?.trim() : void 0;
+  if (specific) return specific;
+  return resolveKrakenSubModel("verify", parentModel, env, opts);
+}
 async function resolveKrakenSubModelAsync(agent, parentModel, env = process.env, opts = {}) {
   let candidates = [];
   if (opts.provider) {
@@ -29617,7 +30822,7 @@ function createBuiltinToolRegistry(options = {}) {
   const safeBash = wrapWithShellSafety(bashTool, audit, sessionId);
   const safeFetchUrl = wrapWithAudit(fetchUrlTool, audit, sessionId);
   const safeWebSearch = wrapWithAudit(webSearchTool, audit, sessionId);
-  const registry3 = new ToolRegistry();
+  const registry4 = new ToolRegistry();
   const profile = options.profile ?? "full";
   const readOnly = options.readOnly === true || options.planMode === true || profile === "explore";
   const verifyMode = profile === "verify";
@@ -29625,34 +30830,34 @@ function createBuiltinToolRegistry(options = {}) {
   const allowBash = allowMutators || verifyMode;
   const permPolicy = options.permissionPolicy ?? defaultPermissionPolicy();
   const withPerm = (t) => wrapWithPermissions(t, permPolicy, options.onPermissionAsk);
-  registry3.register(withPerm(safeReadFile));
-  registry3.register(withPerm(safeGrepContent));
-  registry3.register(withPerm(safeListFiles));
-  registry3.register(withPerm(safeShowDiff));
-  registry3.register(withPerm(safeFetchUrl));
-  registry3.register(withPerm(safeWebSearch));
+  registry4.register(withPerm(safeReadFile));
+  registry4.register(withPerm(safeGrepContent));
+  registry4.register(withPerm(safeListFiles));
+  registry4.register(withPerm(safeShowDiff));
+  registry4.register(withPerm(safeFetchUrl));
+  registry4.register(withPerm(safeWebSearch));
   if (allowMutators) {
-    registry3.register(withPerm(safeWriteFile));
-    registry3.register(withPerm(safeEditFile));
-    registry3.register(withPerm(safeApplyDiff));
+    registry4.register(withPerm(safeWriteFile));
+    registry4.register(withPerm(safeEditFile));
+    registry4.register(withPerm(safeApplyDiff));
   }
   if (allowBash) {
-    registry3.register(withPerm(safeBash));
+    registry4.register(withPerm(safeBash));
   }
   const askUserTool = options.readOnly === true || profile === "explore" || profile === "verify" ? null : createAskUserTool(options.onAskUser);
   if (askUserTool) {
-    registry3.register(withPerm(askUserTool));
+    registry4.register(withPerm(askUserTool));
   }
   const enableSkill = options.enableSkill !== false && options.readOnly !== true && profile !== "explore" && profile !== "verify";
   const skillTool = enableSkill ? withPerm(createSkillTool({ cwd: root })) : null;
   if (skillTool) {
-    registry3.register(skillTool);
+    registry4.register(skillTool);
   }
   const enableTodos = options.enableTodos !== false && options.readOnly !== true && profile === "full";
   const todoWrite = enableTodos ? withPerm(createTodoWriteTool()) : null;
   const todoRead = enableTodos ? withPerm(createTodoReadTool()) : null;
-  if (todoWrite) registry3.register(todoWrite);
-  if (todoRead) registry3.register(todoRead);
+  if (todoWrite) registry4.register(todoWrite);
+  if (todoRead) registry4.register(todoRead);
   const summary = [
     safeReadFile,
     safeGrepContent,
@@ -29674,13 +30879,13 @@ function createBuiltinToolRegistry(options = {}) {
   }));
   if (process.env.ZELARI_AST !== "0") {
     for (const t of createAstTools()) {
-      registry3.register(t);
+      registry4.register(t);
       tools.push({ name: t.name, description: t.description, permissions: t.permissions ?? [] });
     }
   }
   if (process.env.ZELARI_SEMANTIC !== "0") {
     const semanticTool = createSemanticTool({ root });
-    registry3.register(semanticTool);
+    registry4.register(semanticTool);
     tools.push({
       name: semanticTool.name,
       description: semanticTool.description,
@@ -29689,7 +30894,7 @@ function createBuiltinToolRegistry(options = {}) {
   }
   if (!readOnly && process.env.ZELARI_BROWSER !== "0") {
     const browserTool = createBrowserTool();
-    registry3.register(browserTool);
+    registry4.register(browserTool);
     tools.push({
       name: browserTool.name,
       description: browserTool.description,
@@ -29698,7 +30903,7 @@ function createBuiltinToolRegistry(options = {}) {
   }
   if (!readOnly && process.env.ZELARI_SSH !== "0") {
     for (const t of createSshTools()) {
-      registry3.register(t);
+      registry4.register(t);
       tools.push({
         name: t.name,
         description: t.description,
@@ -29709,7 +30914,7 @@ function createBuiltinToolRegistry(options = {}) {
   if (!readOnly) {
     for (const t of createWorldModelTools()) {
       const safe = wrapWithAudit(t, audit, sessionId);
-      registry3.register(safe);
+      registry4.register(safe);
       tools.push({
         name: t.name,
         description: t.description,
@@ -29722,7 +30927,7 @@ function createBuiltinToolRegistry(options = {}) {
     const taskTool = createTaskTool({
       createSubAgentContext: createKrakenSubAgentContextFactory({ root, audit, sessionId })
     });
-    registry3.register(withPerm(taskTool));
+    registry4.register(withPerm(taskTool));
     tools.push({
       name: taskTool.name,
       description: taskTool.description,
@@ -29732,17 +30937,17 @@ function createBuiltinToolRegistry(options = {}) {
   if (!readOnly && process.env.ZELARI_LSP !== "0" && options.lspProvider !== null) {
     const lspTools = options.lspProvider ? createLspTools(options.lspProvider, root) : createLspTools(getSharedLspManager(root), root);
     for (const t of lspTools) {
-      registry3.register(t);
+      registry4.register(t);
       tools.push({ name: t.name, description: t.description, permissions: t.permissions ?? [] });
     }
   }
-  return { registry: registry3, tools };
+  return { registry: registry4, tools };
 }
-function getCliToolCatalogEntries(registry3) {
+function getCliToolCatalogEntries(registry4) {
   const entries = [];
-  for (const name of registry3.list()) {
+  for (const name of registry4.list()) {
     if (HARNESS_BUILTIN_NAMES.has(name)) continue;
-    const def = registry3.get(name);
+    const def = registry4.get(name);
     if (!def) continue;
     try {
       entries.push(cliToolToEnhanced(def));
@@ -29751,8 +30956,8 @@ function getCliToolCatalogEntries(registry3) {
   }
   return entries;
 }
-function registerCliToolsIntoCouncilCatalog(registry3) {
-  for (const entry of getCliToolCatalogEntries(registry3)) {
+function registerCliToolsIntoCouncilCatalog(registry4) {
+  for (const entry of getCliToolCatalogEntries(registry4)) {
     try {
       registerCustomTool(entry);
     } catch {
@@ -29999,7 +31204,7 @@ var HARNESS_BUILTIN_NAMES;
 var init_toolRegistry = __esm({
   "src/cli/toolRegistry.ts"() {
     "use strict";
-    init_registry();
+    init_registry2();
     init_filesystem();
     init_shell();
     init_search();
@@ -31352,7 +32557,7 @@ __export(composeContext_exports, {
 });
 import { existsSync as existsSync23, readdirSync as readdirSync4, readFileSync as readFileSync19 } from "node:fs";
 import { join as join20 } from "node:path";
-function cap(text, max, label) {
+function cap2(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
   return {
     text: text.slice(0, max) + `
@@ -31396,7 +32601,7 @@ function buildDesignIndex(projectRoot, maxChars) {
     }
   }
   const raw = lines.join("\n");
-  return cap(raw, maxChars, "design-index").text;
+  return cap2(raw, maxChars, "design-index").text;
 }
 function composeProjectContext(input) {
   const cwd = input.cwd ?? process.cwd();
@@ -31450,7 +32655,7 @@ function composeProjectContext(input) {
     default: 12e3,
     min: 2e3
   });
-  const totalCapped = cap(workspaceContext, totalCap, "workspaceContext");
+  const totalCapped = cap2(workspaceContext, totalCap, "workspaceContext");
   workspaceContext = totalCapped.text;
   if (totalCapped.truncated) {
     warnings.push(
@@ -31468,14 +32673,14 @@ function composeProjectContext(input) {
   }
   const ragParts = [];
   if (durableRaw) {
-    const d = cap(durableRaw, durableMax, "durable-state");
+    const d = cap2(durableRaw, durableMax, "durable-state");
     ragParts.push(d.text);
     if (d.truncated) {
       warnings.push(`[context] durable state truncated to ${durableMax} chars.`);
     }
   }
   if (input.memoryHits?.trim()) {
-    const m = cap(input.memoryHits.trim(), memoryMax, "memory");
+    const m = cap2(input.memoryHits.trim(), memoryMax, "memory");
     ragParts.push(m.text);
     if (m.truncated) warnings.push(`[context] memory RAG truncated to ${memoryMax} chars.`);
   }
@@ -31859,28 +33064,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path44) {
-        if (!existsSync25(path44)) {
-          throw new Error(`File not found: ${path44}`);
+      read(path47) {
+        if (!existsSync25(path47)) {
+          throw new Error(`File not found: ${path47}`);
         }
-        const md = readFileSync21(path44, "utf8");
+        const md = readFileSync21(path47, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path44) {
-        if (!existsSync25(path44)) return null;
-        return this.read(path44);
+      readIfExists(path47) {
+        if (!existsSync25(path47)) return null;
+        return this.read(path47);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path44, meta3, body) {
-        mkdirSync11(dirname4(path44), { recursive: true });
-        const tmp = path44 + ".tmp-" + process.pid;
+      write(path47, meta3, body) {
+        mkdirSync11(dirname4(path47), { recursive: true });
+        const tmp = path47 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync13(tmp, md, "utf8");
-        renameSync2(tmp, path44);
+        renameSync2(tmp, path47);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -31958,8 +33163,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path44 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path44);
+  const path47 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path47);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -32124,7 +33329,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path44 = join23(ctx.rootDir, "milestones", `${id}.md`);
+  const path47 = join23(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -32141,7 +33346,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path44, meta3, body);
+  ctx.storage.write(path47, meta3, body);
   return { id, created: true };
 }
 function readPlanSummary(ctx) {
@@ -32345,7 +33550,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path44 = workspaceArtifact(ctx.rootDir, "decisions", id);
+        const path47 = workspaceArtifact(ctx.rootDir, "decisions", id);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -32371,7 +33576,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path44, meta3, body);
+        ctx.storage.write(path47, meta3, body);
         return `ADR ${id} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -32453,14 +33658,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path44 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path47 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path44, meta3, content);
+        ctx.storage.write(path47, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -32621,12 +33826,12 @@ __export(toolRegistry_exports2, {
 });
 function createWorkspaceToolRegistry(ctx) {
   const stubs = createWorkspaceStubs(ctx);
-  const registry3 = new ToolRegistry();
+  const registry4 = new ToolRegistry();
   for (const stub of stubs) {
     const td = adaptStubToToolDefinition(stub, ctx);
-    registry3.register(td);
+    registry4.register(td);
   }
-  return registry3;
+  return registry4;
 }
 function adaptStubToToolDefinition(stub, workspaceCtx) {
   return {
@@ -32658,7 +33863,7 @@ var init_toolRegistry2 = __esm({
   "src/cli/workspace/toolRegistry.ts"() {
     "use strict";
     init_zod();
-    init_registry();
+    init_registry2();
     init_toolTypes();
     init_stubs();
   }
@@ -33004,10 +34209,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join24(projectRoot, ".zelari", "mcp.json");
 }
-function readFile2(path44) {
-  if (!existsSync28(path44)) return {};
+function readFile2(path47) {
+  if (!existsSync28(path47)) return {};
   try {
-    const parsed = JSON.parse(readFileSync23(path44, "utf8"));
+    const parsed = JSON.parse(readFileSync23(path47, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -33023,10 +34228,10 @@ function readFile2(path44) {
     return {};
   }
 }
-function writeFile(path44, servers) {
-  mkdirSync13(dirname6(path44), { recursive: true });
+function writeFile(path47, servers) {
+  mkdirSync13(dirname6(path47), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync15(path44, `${JSON.stringify(body, null, 2)}
+  writeFileSync15(path47, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -33059,9 +34264,9 @@ function upsertMcpServer(opts) {
   if (!opts.config.command?.trim()) {
     return { ok: false, error: "command is required" };
   }
-  let path44;
+  let path47;
   if (opts.scope === "user") {
-    path44 = getUserMcpPath();
+    path47 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -33070,30 +34275,30 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path44 = getProjectMcpPath(root);
+    path47 = getProjectMcpPath(root);
   }
-  const current = readFile2(path44);
+  const current = readFile2(path47);
   current[name] = {
     command: opts.config.command.trim(),
     args: opts.config.args,
     env: opts.config.env,
     enabled: opts.config.enabled !== false
   };
-  writeFile(path44, current);
-  return { ok: true, path: path44 };
+  writeFile(path47, current);
+  return { ok: true, path: path47 };
 }
 function removeMcpServer(opts) {
-  const path44 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path44) {
+  const path47 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path47) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile2(path44);
+  const current = readFile2(path47);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path44}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path47}` };
   }
   delete current[opts.name];
-  writeFile(path44, current);
-  return { ok: true, path: path44 };
+  writeFile(path47, current);
+  return { ok: true, path: path47 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -33237,7 +34442,7 @@ async function ensureLoaded(projectRoot) {
 function sanitizeToolName(raw) {
   return raw.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-async function registerMcpTools(registry3, projectRoot = process.cwd(), opts) {
+async function registerMcpTools(registry4, projectRoot = process.cwd(), opts) {
   if (process.env["ZELARI_MCP"] === "0") return { registered: [], warnings: [] };
   await ensureLoaded(projectRoot);
   const skipCuaForCouncil = opts?.councilMode === true && !isCuaAllowedForCouncil();
@@ -33246,7 +34451,7 @@ async function registerMcpTools(registry3, projectRoot = process.cwd(), opts) {
     if (skipCuaForCouncil && isCuaMcpServerName(t.serverName)) {
       continue;
     }
-    registry3.register({
+    registry4.register({
       name: t.registryName,
       description: `[MCP:${t.serverName}] ${t.info.description}`.slice(0, 1024),
       // The MCP server owns validation; its JSON Schema is forwarded to the
@@ -33430,10 +34635,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 path44 = join26(projectRoot, "package.json");
-  if (!existsSync30(path44)) return null;
+  const path47 = join26(projectRoot, "package.json");
+  if (!existsSync30(path47)) return null;
   try {
-    return JSON.parse(await readFile3(path44, "utf8"));
+    return JSON.parse(await readFile3(path47, "utf8"));
   } catch {
     return null;
   }
@@ -33515,9 +34720,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path44 = join26(ctx.rootDir, "risks.md");
-  if (!existsSync30(path44)) return "_No open questions._";
-  const content = readFileSync25(path44, "utf8");
+  const path47 = join26(ctx.rootDir, "risks.md");
+  if (!existsSync30(path47)) return "_No open questions._";
+  const content = readFileSync25(path47, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -34048,9 +35253,9 @@ async function runPostCouncilHook(ctx, options) {
     lessons = { ran: true, captured: 0, rejected: 0 };
     for (const r of verification.report.results) {
       if (r.ok) continue;
-      const cap2 = captureFailure(ctx.rootDir, r);
-      if (cap2.rejected) lessons.rejected++;
-      else if (cap2.captured) lessons.captured++;
+      const cap3 = captureFailure(ctx.rootDir, r);
+      if (cap3.rejected) lessons.rejected++;
+      else if (cap3.captured) lessons.captured++;
     }
   } else if (process.env["ZELARI_LESSONS"] === "0") {
     lessons = {
@@ -34084,8 +35289,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path44 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path44, completion };
+      const path47 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path47, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -35303,10 +36508,18 @@ __export(planner_exports, {
   KRAKEN_PLANNER_SYSTEM_PROMPT: () => KRAKEN_PLANNER_SYSTEM_PROMPT,
   PlannerTransportError: () => PlannerTransportError,
   buildGraphFromPlan: () => buildGraphFromPlan,
+  buildPlannerSystemPrompt: () => buildPlannerSystemPrompt,
+  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;
@@ -35319,6 +36532,15 @@ function resolvePlannerMaxTokens(env = process.env) {
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_LLM_MAX_TOKENS;
 }
+function resolveBennettsRazorEnabled(env = process.env) {
+  const raw = env.ZELARI_KRAKEN_PLANNER_BENNETTS_RAZOR;
+  if (raw === void 0 || raw === "") return false;
+  return raw === "1" || raw.toLowerCase() === "true";
+}
+function buildPlannerSystemPrompt(env = process.env) {
+  if (!resolveBennettsRazorEnabled(env)) return KRAKEN_PLANNER_SYSTEM_PROMPT;
+  return KRAKEN_PLANNER_SYSTEM_PROMPT + "\n" + KRAKEN_PLANNER_BENNETTS_RAZOR_SECTION;
+}
 function extractJsonObject(text, opts = {}) {
   const stripped = stripReasoningBlocks(text);
   const usable = findJsonIn(stripped, opts);
@@ -35615,14 +36837,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 +36871,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,12 +36957,16 @@ 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++) {
     try {
-      const text = await client.complete({ system: KRAKEN_PLANNER_SYSTEM_PROMPT, user: userMessage });
+      const text = await client.complete({ system: buildPlannerSystemPrompt(), user: userMessage });
       const parsedJson = extractJsonObject(text, { requireKey: "nodes" });
       const validated = PlannedGraphSchema.parse(parsedJson);
       if (!validated.nodes.some((n) => n.kind === "general")) {
@@ -35719,7 +36992,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, KRAKEN_PLANNER_BENNETTS_RAZOR_SECTION, PlannedNodeSchema, PlannedGraphSchema, MAX_VERIFY_TASK_PROMPT_CHARS;
 var init_planner = __esm({
   "src/cli/kraken/planner.ts"() {
     "use strict";
@@ -35728,7 +37001,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) {
@@ -35742,7 +37017,11 @@ var init_planner = __esm({
       general: 1,
       verify: 1,
       fix: 0,
-      merge: 0
+      merge: 0,
+      // Pillar 2 persona kinds: same retry budget as `verify` (the gate is
+      // the same — trailer-based).
+      spec: 1,
+      conformance: 1
     };
     KRAKEN_PLANNER_SYSTEM_PROMPT = [
       "You are the PLANNER for Kraken, a multi-agent graph executor.",
@@ -35754,14 +37033,45 @@ var init_planner = __esm({
       "Rules:",
       '- kind "explore": read-only research (no edits). Use to gather context before edits.',
       '- 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.',
+      '- Do NOT emit "verify", "spec", "conformance", "fix", or "merge" nodes \u2014 the executor adds those automatically based on the writer kind and the goal shape.',
       '- "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.',
+      "",
+      "# Reviewer personas (Pillar 2 spec council)",
+      "",
+      "After every `general` node, the executor auto-injects a `verify` tentacle that checks the `acceptance[]` criteria. For goals that have a written spec or that must literally match the user prompt, the executor also auto-injects two more personas:",
+      '  - `spec` (spec-reviewer) \u2014 compares the writer\'s output against a written spec/plan, per requirement. Conservative: "reasonable but different" is a FAIL.',
+      '  - `conformance` (conformance-reviewer) \u2014 compares the writer\'s output against the USER\'S ORIGINAL VERBATIM PROMPT. Literal: "use session cookies" is a FAIL when the prompt said "use JWT".',
+      "",
+      "You (the JSON planner) do NOT emit these directly; the executor decides when to inject them. To hint that a node needs a `conformance` reviewer, include the user's original ask verbatim in the `prompt`."
+    ].join("\n");
+    KRAKEN_PLANNER_BENNETTS_RAZOR_SECTION = [
+      "",
+      "# Bennett's Razor (tie-breaker)",
+      "",
+      'When two valid plans cover the goal, prefer the one that "assumes the least".',
+      "A plan is *more specific* when it pins exact paths, exact semver, exact function",
+      "signatures, or hard invariants about external state. A more general plan that",
+      "still satisfies the goal generalises better (Bennett, AGI 2023: 1.1\xD7\u20135\xD7 the rate",
+      "of MDL in his experiments).",
+      "",
+      "Examples of the bias you should apply:",
+      '- "edit the user model" > "edit /src/models/user.ts and add a nullable email field"',
+      "  when the goal can be met either way.",
+      '- "use a stable sort" > "use Array.prototype.sort with a custom comparator" unless',
+      "  the user pinned the API.",
+      "- Prefer plans that touch fewer files and assume less about runtime versions.",
+      "",
+      "Hard constraint: do NOT weaken a plan below the bar in the name of weakness. The",
+      "goal must be reachable by following the plan as written; weakness is only a",
+      "tie-breaker among plans that do reach the goal."
     ].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 +37085,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 +37103,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 +37147,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 +37190,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;
   }
 });
 
@@ -35873,21 +37208,149 @@ var init_tentacle = __esm({
   }
 });
 
+// src/cli/kraken/weaknessMeter.ts
+var weaknessMeter_exports = {};
+__export(weaknessMeter_exports, {
+  _resetWeaknessMeterCacheForTests: () => _resetWeaknessMeterCacheForTests,
+  isWeaknessMeterEnabled: () => isWeaknessMeterEnabled,
+  measureWeaknessViaLLM: () => measureWeaknessViaLLM,
+  parseMeterContent: () => parseMeterContent
+});
+function isWeaknessMeterEnabled(env = process.env) {
+  if (meterEnabledCache !== null) return meterEnabledCache;
+  const raw = env.ZELARI_KRAKEN_WEAKNESS_METER;
+  const enabled = raw === "1" || raw === "true" || raw === "yes";
+  meterEnabledCache = enabled;
+  return enabled;
+}
+function _resetWeaknessMeterCacheForTests() {
+  meterEnabledCache = null;
+}
+function resolveMeterModel(env = process.env, fallback) {
+  const raw = env.ZELARI_KRAKEN_WEAKNESS_METER_MODEL;
+  if (raw && raw.trim() !== "") return raw.trim();
+  return fallback;
+}
+async function measureWeaknessViaLLM(text, options = {}) {
+  const env = options.env ?? process.env;
+  if (!isWeaknessMeterEnabled(env)) return null;
+  if (typeof text !== "string" || text.trim() === "") return null;
+  const provider = options.providerOverride ?? await resolveActiveProvider2(env);
+  if (!provider) return null;
+  const model = options.modelOverride ?? resolveMeterModel(env, provider.model);
+  const userPayload = JSON.stringify({
+    task: "measure weakness of the following reviewer reply",
+    reply: text
+  });
+  const start = Date.now();
+  try {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), METER_TIMEOUT_MS);
+    let response;
+    try {
+      response = await fetchImpl(provider.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${provider.apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: "system", content: WEAKNESS_METER_PROMPT },
+            { role: "user", content: userPayload }
+          ],
+          // The meter is a classification call; no need for a hot
+          // sampling distribution. Most providers accept this pair
+          // without complaint; the few that require it get a stable
+          // answer.
+          temperature: 0,
+          stream: false
+        }),
+        signal: ac.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!response.ok) return null;
+    const json2 = await response.json();
+    const raw = json2.choices?.[0]?.message?.content;
+    if (typeof raw !== "string") return null;
+    return parseMeterContent(raw, model, Date.now() - start);
+  } catch {
+    return null;
+  }
+}
+function parseMeterContent(raw, model, durationMs) {
+  const trimmed = raw.trim();
+  const fenced = /^```(?:json)?\s*([\s\S]+?)\s*```$/i.exec(trimmed);
+  const body = fenced ? fenced[1] : trimmed;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  const validated = WeaknessMeterResponseSchema.safeParse(parsed);
+  if (!validated.success) return null;
+  return {
+    meter: validated.data,
+    weakness: weaknessFromMeter(validated.data),
+    durationMs,
+    model
+  };
+}
+async function resolveActiveProvider2(env) {
+  const cfg = await getProviderConfig();
+  if (!cfg) return null;
+  const providerId = cfg.activeProviderId;
+  const key = await resolveApiKeyWithMeta(providerId, env);
+  if (!key?.apiKey) return null;
+  const model = getModelForProvider(providerId) ?? cfg.modelByProvider[providerId] ?? "";
+  const endpoint = getCustomEndpoint(providerId) ?? `https://api.openai.com/v1/chat/completions`;
+  return { providerId, model, endpoint, apiKey: key.apiKey };
+}
+var meterEnabledCache, METER_TIMEOUT_MS;
+var init_weaknessMeter = __esm({
+  "src/cli/kraken/weaknessMeter.ts"() {
+    "use strict";
+    init_dist();
+    init_providerConfig();
+    init_keyStore();
+    meterEnabledCache = null;
+    METER_TIMEOUT_MS = (() => {
+      const raw = process.env.ZELARI_KRAKEN_WEAKNESS_METER_TIMEOUT_MS;
+      if (!raw) return 12e3;
+      const n = Number.parseInt(raw, 10);
+      return Number.isFinite(n) && n > 0 ? n : 12e3;
+    })();
+  }
+});
+
 // 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 path35 from "node:path";
@@ -35897,11 +37360,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 +37416,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 cap3 = Math.min(MAX_UPSTREAM_CHARS_PER_DEP, budget);
+    if (cap3 <= 0) {
+      omitted.push(dep.label);
+      continue;
+    }
+    const body = raw.length > cap3 ? `${raw.slice(0, cap3)}
+\u2026 [truncated ${raw.length}\u2192${cap3} chars]` : raw;
+    budget -= Math.min(raw.length, cap3);
+    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 +37473,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 +37489,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 +37536,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 +37591,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 +37637,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 agent = node.kind === "fix" ? "general" : node.kind;
+        const isRework = this.reworks.has(node.id);
+        const usesWorktree = (node.kind === "general" || node.kind === "fix") && !isRework;
+        const agent = node.kind === "fix" ? "general" : node.kind === "spec" || node.kind === "conformance" ? "verify" : 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 +37824,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 +37906,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 +37934,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 +37991,181 @@ 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;
+        void this.maybeRunWeaknessMeter(verify, verdict);
+        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 +38192,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)) {
@@ -36303,6 +38235,41 @@ ${failed.error ?? "unknown error"}`,
           ...fields.ok !== void 0 ? { ok: fields.ok } : {}
         });
       }
+      /**
+       * Bennett's Razor meter (Slice L/N+3 wiring): when the env flag is
+       * set, fire a non-blocking LLM call to refine the persona verdict's
+       * weakness score. The local heuristic already produced a score in
+       * `parsePersonaVerdict`; the meter just refines it. Results land in
+       * the radio stream as a `node_meter` event so the desktop / tail
+       * can surface the distinction between a "tightly asserted" PASS
+       * (specificity > 0.6) and a "loosely claimed" one (specificity < 0.3).
+       *
+       * No-op when:
+       *   - the meter is disabled (default)
+       *   - the result text is empty
+       *   - the meter call fails (silent: the local score is good enough)
+       *
+       * @since v1.31.x
+       */
+      async maybeRunWeaknessMeter(verify, verdict) {
+        const text = typeof verify.result === "string" ? verify.result : "";
+        if (text.length === 0) return;
+        let meter;
+        try {
+          ({ measureWeaknessViaLLM: meter } = await Promise.resolve().then(() => (init_weaknessMeter(), weaknessMeter_exports)));
+        } catch {
+          return;
+        }
+        if (!meter) return;
+        const outcome = await meter(text);
+        if (!outcome) return;
+        this.radio("node_meter", {
+          description: `meter: ${verify.id}`,
+          agent: "weakness-meter",
+          detail: `v=${verdict} specificity=${outcome.meter.specificity.toFixed(2)} weakness=${outcome.weakness.toFixed(2)} model=${outcome.model} dur=${outcome.durationMs}ms assumptions=${outcome.meter.assumptions.length}`,
+          ok: true
+        });
+      }
     };
   }
 });
@@ -36691,10 +38658,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 path36 from "node:path";
+import path38 from "node:path";
 import os9 from "node:os";
 function getPluginPrefsPath() {
-  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path36.join(os9.homedir(), ".tmp", "zelari-code", "plugins.json");
+  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path38.join(os9.homedir(), ".tmp", "zelari-code", "plugins.json");
 }
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
@@ -36715,7 +38682,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync15(path36.dirname(file2), { recursive: true });
+  mkdirSync15(path38.dirname(file2), { recursive: true });
   writeFileSync18(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -36752,7 +38719,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync37 } from "node:fs";
-import path37 from "node:path";
+import path39 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -36770,7 +38737,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" ? path37.win32 : path37.posix;
+  const pathMod = platform === "win32" ? path39.win32 : path39.posix;
   const sep2 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep2).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -36839,7 +38806,7 @@ function findPlugin(id) {
   return PLUGINS.find((p3) => p3.id === id);
 }
 var PLUGINS;
-var init_registry2 = __esm({
+var init_registry3 = __esm({
   "src/cli/plugins/registry.ts"() {
     "use strict";
     init_engine();
@@ -36908,7 +38875,7 @@ __export(atMentions_exports, {
   hasAtMentions: () => hasAtMentions
 });
 import { existsSync as existsSync40, readFileSync as readFileSync31, statSync as statSync6 } from "node:fs";
-import { isAbsolute, relative as relative3, resolve, sep } from "node:path";
+import { isAbsolute as isAbsolute2, relative as relative3, resolve, sep } from "node:path";
 function isProbablyText(name, head) {
   if (/\.(txt|md|markdown|json|jsonc|ts|tsx|js|jsx|mjs|cjs|css|scss|html|htm|xml|yml|yaml|toml|ini|cfg|conf|rs|go|py|java|kt|swift|c|cc|cpp|h|hpp|cs|rb|php|sh|bash|zsh|ps1|sql|graphql|env|gitignore|dockerfile|makefile|cmake|lock|svg)$/i.test(
     name
@@ -36939,8 +38906,8 @@ function extractAtMentions(text) {
   return out;
 }
 function resolveMention(token, cwd) {
-  const abs = isAbsolute(token) ? resolve(token) : resolve(cwd, token);
-  if (!underRoot(abs, cwd) && !isAbsolute(token)) {
+  const abs = isAbsolute2(token) ? resolve(token) : resolve(cwd, token);
+  if (!underRoot(abs, cwd) && !isAbsolute2(token)) {
     if (!underRoot(abs, cwd)) {
       return {
         raw: token,
@@ -36951,7 +38918,7 @@ function resolveMention(token, cwd) {
       };
     }
   }
-  if (isAbsolute(token) && !underRoot(abs, cwd)) {
+  if (isAbsolute2(token) && !underRoot(abs, cwd)) {
     return {
       raw: token,
       path: token,
@@ -37079,10 +39046,10 @@ __export(triggerLock_exports, {
   lockPath: () => lockPath,
   releaseLock: () => releaseLock
 });
-import { promises as fs24 } from "node:fs";
-import * as path42 from "node:path";
+import { promises as fs27 } from "node:fs";
+import * as path44 from "node:path";
 function lockPath(projectRoot) {
-  return path42.join(projectRoot, ".zelari", "trigger.lock");
+  return path44.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -37095,10 +39062,10 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path42.dirname(lp);
-  await fs24.mkdir(dir, { recursive: true });
+  const dir = path44.dirname(lp);
+  await fs27.mkdir(dir, { recursive: true });
   try {
-    const raw = await fs24.readFile(lp, "utf8");
+    const raw = await fs27.readFile(lp, "utf8");
     const existing = JSON.parse(raw);
     if (existing.pid && isPidAlive(existing.pid)) {
       return { acquired: false, heldBy: existing.pid, lockPath: lp };
@@ -37109,13 +39076,13 @@ async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date())
     pid: process.pid,
     acquiredAt: now().toISOString()
   };
-  await fs24.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  await fs27.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
   return { acquired: true, lockPath: lp };
 }
 async function releaseLock(projectRoot) {
   const lp = lockPath(projectRoot);
   try {
-    await fs24.unlink(lp);
+    await fs27.unlink(lp);
   } catch {
   }
 }
@@ -37386,7 +39353,7 @@ import {
 } from "node:fs";
 import { join as join35 } from "node:path";
 import { homedir as homedir11 } from "node:os";
-import { createHash as createHash6, randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes4, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
   return join35(homedir11(), ".zelari-code");
 }
@@ -37403,12 +39370,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path44 = getCompanionConfigPath();
-  if (!existsSync43(path44)) {
+  const path47 = getCompanionConfigPath();
+  if (!existsSync43(path47)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync34(path44, "utf8"));
+    const raw = JSON.parse(readFileSync34(path47, "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) => ({
@@ -37446,16 +39413,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path44 = getCompanionTokenPath();
-  if (existsSync43(path44)) {
-    const t = readFileSync34(path44, "utf8").trim();
+  const path47 = getCompanionTokenPath();
+  if (existsSync43(path47)) {
+    const t = readFileSync34(path47, "utf8").trim();
     if (t) return { token: t, created: false };
   }
-  const token = randomBytes3(24).toString("base64url");
-  writeFileSync21(path44, token + "\n", "utf8");
+  const token = randomBytes4(24).toString("base64url");
+  writeFileSync21(path47, token + "\n", "utf8");
   try {
-    const fs25 = __require("node:fs");
-    fs25.chmodSync?.(path44, 384);
+    const fs29 = __require("node:fs");
+    fs29.chmodSync?.(path47, 384);
   } catch {
   }
   return { token, created: true };
@@ -37480,17 +39447,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path44 = raw.trim();
-    if (!path44) continue;
-    let id = slugFromPath(path44);
+    const path47 = raw.trim();
+    if (!path47) continue;
+    let id = slugFromPath(path47);
     let n = 2;
-    while (byId.has(id) && byId.get(id).path !== path44) {
-      id = `${slugFromPath(path44)}-${n++}`;
+    while (byId.has(id) && byId.get(id).path !== path47) {
+      id = `${slugFromPath(path47)}-${n++}`;
     }
     byId.set(id, {
       id,
-      name: slugFromPath(path44),
-      path: path44
+      name: slugFromPath(path47),
+      path: path47
     });
   }
   return [...byId.values()];
@@ -37540,7 +39507,7 @@ var init_config = __esm({
 // src/cli/companion/runManager.ts
 import { spawn as spawn11 } from "node:child_process";
 import { createInterface } from "node:readline";
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { writeFileSync as writeFileSync22, unlinkSync as unlinkSync2 } from "node:fs";
 import { join as join36 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
@@ -37609,7 +39576,7 @@ var init_runManager = __esm({
         }
         const prompt = args.prompt?.trim();
         if (!prompt) return { ok: false, error: "prompt is required" };
-        const id = randomUUID6();
+        const id = randomUUID7();
         const mode = (args.mode || "kraken").toLowerCase();
         const phase2 = (args.phase || "build").toLowerCase();
         const run = {
@@ -37867,9 +39834,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path44 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path47 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path44 === "/health" || path44 === "/v1/health")) {
+      if (req.method === "GET" && (path47 === "/health" || path47 === "/v1/health")) {
         sendJson(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -37881,18 +39848,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path44.startsWith("/v1")) {
+      if (path47.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path44 === "/v1/config") {
+      if (req.method === "GET" && path47 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path44 === "/v1/projects") {
+      if (req.method === "GET" && path47 === "/v1/projects") {
         sendJson(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -37903,7 +39870,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path44 === "/v1/runs") {
+      if (req.method === "GET" && path47 === "/v1/runs") {
         sendJson(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -37921,7 +39888,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path44 === "/v1/runs") {
+      if (req.method === "POST" && path47 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -37968,7 +39935,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path44);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path47);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -38033,7 +40000,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path44);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path47);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -38145,11 +40112,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 path43 from "node:path";
+import path46 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path43.join(dir, "package.json");
+    const candidate = path46.join(dir, "package.json");
     if (existsSync45(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync35(candidate, "utf8"));
@@ -38157,11 +40124,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path43.dirname(dir);
+    const parent = path46.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path43.resolve(__dirname3, "..", "..", "..");
+  return path46.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -38175,7 +40142,7 @@ function tryExec(cmd) {
 }
 function readPackageJson3() {
   try {
-    const pkgPath = path43.join(packageRoot, "package.json");
+    const pkgPath = path46.join(packageRoot, "package.json");
     return JSON.parse(readFileSync35(pkgPath, "utf8"));
   } catch {
     return null;
@@ -38191,7 +40158,7 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path43.join(prefix, shimName);
+  const shimPath = path46.join(prefix, shimName);
   if (!existsSync45(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
@@ -38219,8 +40186,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path43.resolve(path43.dirname(shimPath), target);
-    const expected = path43.join(
+    const resolved = path46.resolve(path46.dirname(shimPath), target);
+    const expected = path46.join(
       prefix,
       "node_modules",
       pkgName,
@@ -38259,7 +40226,7 @@ function checkNode(pkg) {
   return OK(`node ${raw}`);
 }
 function checkBundle() {
-  const bundle = path43.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path46.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync45(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -38280,7 +40247,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path43.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path46.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -38357,7 +40324,7 @@ function prereqToCheckResult(r) {
   return r.severity === "critical" ? FAIL(r.message, "critical") : WARN(r.message);
 }
 async function checkOptionalPlugins() {
-  const { detectMissingPlugins: detectMissingPlugins2 } = await Promise.resolve().then(() => (init_registry2(), registry_exports));
+  const { detectMissingPlugins: detectMissingPlugins2 } = await Promise.resolve().then(() => (init_registry3(), registry_exports));
   let missing;
   try {
     missing = await detectMissingPlugins2(packageRoot, { includeMuted: true });
@@ -38456,7 +40423,7 @@ var init_doctor = __esm({
     "use strict";
     init_prereqChecks();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path43.dirname(fileURLToPath2(import.meta.url));
+    __dirname3 = path46.dirname(fileURLToPath2(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -38696,9 +40663,9 @@ function tryParseJson(s) {
   }
 }
 function truncateLines(lines) {
-  const cap2 = toolOutputLineCap();
-  if (lines.length <= cap2) return lines;
-  return [...lines.slice(0, cap2), `\u2026 (+${lines.length - cap2} lines)`];
+  const cap3 = toolOutputLineCap();
+  if (lines.length <= cap3) return lines;
+  return [...lines.slice(0, cap3), `\u2026 (+${lines.length - cap3} lines)`];
 }
 function formatBytes(n) {
   if (n >= 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(1)} MB`;
@@ -38886,7 +40853,7 @@ function rel(p3) {
   }
 }
 function formatToolSummary(toolName, args, maxWidth) {
-  const cap2 = maxWidth && maxWidth > 10 ? maxWidth : 100;
+  const cap3 = maxWidth && maxWidth > 10 ? maxWidth : 100;
   const lower = toolName.toLowerCase();
   const a = args && typeof args === "object" ? args : {};
   let summary;
@@ -38909,7 +40876,7 @@ function formatToolSummary(toolName, args, maxWidth) {
     const json2 = JSON.stringify(args) ?? "";
     summary = json2;
   }
-  return summary.length > cap2 ? `${summary.slice(0, cap2 - 1)}\u2026` : summary;
+  return summary.length > cap3 ? `${summary.slice(0, cap3 - 1)}\u2026` : summary;
 }
 
 // src/cli/components/ToolOutput.tsx
@@ -44321,6 +46288,20 @@ ${formatSkillList(availableSkills)}`
           graphPrompt: args.slice(1).join(" ").trim()
         };
       }
+      if (args[0] === "fanout") {
+        return {
+          handled: true,
+          kind: "kraken_fanout",
+          fanoutArgs: args.slice(1).join(" ").trim()
+        };
+      }
+      if (args[0] === "workbench") {
+        return {
+          handled: true,
+          kind: "kraken_workbench",
+          workbenchArgs: args.slice(1).join(" ").trim()
+        };
+      }
       const sessionArg = args.join(" ").trim();
       return {
         handled: true,
@@ -44904,6 +46885,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 +46896,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(
@@ -44928,6 +46916,508 @@ async function handleKrakenGraph(ctx, prompt) {
   }
 }
 
+// src/cli/slashHandlers/krakenFanout.ts
+init_auditLogger();
+init_toolRegistry();
+import { promises as fs21 } from "node:fs";
+
+// src/cli/tools/krakenCsvFanout.ts
+init_zod();
+init_taskTool();
+import { promises as fs20 } from "node:fs";
+import path36 from "node:path";
+import { randomBytes as randomBytes3 } from "node:crypto";
+var CsvFanoutArgsSchema = external_exports.object({
+  csv_path: external_exports.string().min(1),
+  id_column: external_exports.string().min(1),
+  output_csv_path: external_exports.string().min(1),
+  /** Template with `{column_name}` placeholders. The tentacle's prompt is
+   *  the template with each row's values substituted. */
+  instruction_template: external_exports.string().min(1),
+  /** Default 'verify' — read-mostly workloads are the common case. */
+  agent_kind: external_exports.enum(["explore", "general", "verify"]).default("verify"),
+  thoroughness: external_exports.enum(["quick", "medium", "deep"]).default("medium"),
+  /** Optional: per-row scope template with `{column}` placeholders. The
+   *  resulting path/glob list is fed to the scope-overlap check. */
+  scope_template: external_exports.array(external_exports.string()).optional(),
+  /** Default: ZELARI_KRAKEN_MAX_PARALLEL. */
+  max_concurrency: external_exports.number().int().positive().optional(),
+  /** Per-row timeout (ms). Default: 5 min for verify, 15 min for general. */
+  max_runtime_seconds: external_exports.number().int().positive().optional()
+});
+async function readCsv(filePath) {
+  const text = await fs20.readFile(filePath, "utf8");
+  return parseCsv(text);
+}
+function parseCsv(text) {
+  const records = [];
+  let row = [];
+  let field = "";
+  let inQuotes = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          field += '"';
+          i += 1;
+        } else inQuotes = false;
+      } else {
+        field += ch;
+      }
+    } else {
+      if (ch === '"') inQuotes = true;
+      else if (ch === ",") {
+        row.push(field);
+        field = "";
+      } else if (ch === "\n") {
+        row.push(field);
+        records.push(row);
+        row = [];
+        field = "";
+      } else if (ch === "\r") {
+      } else field += ch;
+    }
+  }
+  if (field !== "" || row.length > 0) {
+    row.push(field);
+    records.push(row);
+  }
+  while (records.length > 0 && records[records.length - 1].length === 1 && records[records.length - 1][0] === "") {
+    records.pop();
+  }
+  if (records.length === 0) return { headers: [], rows: [] };
+  const headers = records[0];
+  const rows = records.slice(1).map((r) => {
+    const obj = {};
+    for (let i = 0; i < headers.length; i++) obj[headers[i]] = r[i] ?? "";
+    return obj;
+  });
+  return { headers, rows };
+}
+function applyTemplate(template, row) {
+  return template.replace(/\{([a-zA-Z_][\w-]*)\}/g, (_, k) => row[k] ?? "");
+}
+function serializeCsv(headers, rows) {
+  const escape = (v) => {
+    if (v.includes(",") || v.includes("\n") || v.includes('"')) {
+      return `"${v.replace(/"/g, '""')}"`;
+    }
+    return v;
+  };
+  const out = [headers.map(escape).join(",")];
+  for (const row of rows) {
+    out.push(headers.map((h) => escape(row[h] ?? "")).join(","));
+  }
+  return out.join("\n") + "\n";
+}
+function resolveMaxConcurrency(env = process.env) {
+  const raw = env.ZELARI_KRAKEN_MAX_PARALLEL;
+  if (raw === void 0 || raw === "") return 12;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : 12;
+}
+async function runCsvFanout(args, deps, opts) {
+  const start = Date.now();
+  const absCsv = path36.isAbsolute(args.csv_path) ? args.csv_path : path36.join(opts.parentCwd, args.csv_path);
+  const absOut = path36.isAbsolute(args.output_csv_path) ? args.output_csv_path : path36.join(opts.parentCwd, args.output_csv_path);
+  const { headers, rows } = await readCsv(absCsv);
+  if (headers.length === 0) {
+    throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
+  }
+  if (!args.id_column) {
+    throw new Error("kraken_csv_fanout: id_column is required");
+  }
+  if (!headers.includes(args.id_column)) {
+    throw new Error(`kraken_csv_fanout: id_column "${args.id_column}" not in CSV header [${headers.join(", ")}]`);
+  }
+  const concurrency = args.max_concurrency ?? resolveMaxConcurrency();
+  opts.onLog?.(`csv fanout: ${rows.length} rows \xD7 ${args.agent_kind} @ concurrency=${concurrency}`);
+  const perRowMs = args.max_runtime_seconds !== void 0 ? args.max_runtime_seconds * 1e3 : args.agent_kind === "general" ? 9e5 : 3e5;
+  const outputRecords = rows.map((r) => ({ ...r, status: "pending", result: "", error: "" }));
+  const outHeaders = [...headers, "status", "result", "error"];
+  let writeChain2 = Promise.resolve();
+  function queueWrite(contents) {
+    const next = writeChain2.then(() => atomicWrite(absOut, contents));
+    writeChain2 = next.catch(() => {
+    });
+    return next;
+  }
+  let nextIndex = 0;
+  let completed = 0;
+  let errored = 0;
+  const errors = [];
+  async function worker() {
+    while (true) {
+      const i = nextIndex;
+      nextIndex += 1;
+      if (i >= rows.length) return;
+      const row = rows[i];
+      const prompt = applyTemplate(args.instruction_template, row);
+      const scope = args.scope_template?.map((t) => applyTemplate(t, row));
+      const res = await runTentacle({
+        deps,
+        args: {
+          description: `csv-row ${row[args.id_column] ?? i}`,
+          prompt,
+          ...scope ? { scope } : {}
+        },
+        agent: args.agent_kind,
+        thoroughness: args.thoroughness,
+        parentCwd: opts.parentCwd,
+        sessionId: opts.sessionId
+      });
+      outputRecords[i].status = res.ok ? "ok" : "error";
+      if (res.ok) {
+        outputRecords[i].result = res.result;
+        completed += 1;
+      } else {
+        outputRecords[i].error = res.error;
+        errored += 1;
+        errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
+      }
+      await fs20.mkdir(path36.dirname(absOut), { recursive: true });
+      await queueWrite(serializeCsv(outHeaders, outputRecords));
+    }
+  }
+  const pool = Array.from({ length: Math.min(concurrency, rows.length) }, () => worker());
+  await Promise.all(pool);
+  const durationMs = Date.now() - start;
+  opts.onLog?.(`csv fanout: ${completed} ok, ${errored} error, ${durationMs}ms`);
+  if (errored > 0) {
+    opts.onLog?.(`csv fanout: first 3 errors:
+  - ${errors.slice(0, 3).join("\n  - ")}`);
+  }
+  return {
+    rows: rows.length,
+    completed,
+    errored,
+    output_csv_path: absOut,
+    durationMs
+  };
+}
+async function atomicWrite(file2, contents) {
+  const tmp = `${file2}.${process.pid}.${Date.now()}.${randomBytes3(6).toString("hex")}.tmp`;
+  await fs20.writeFile(tmp, contents, "utf8");
+  await fs20.rename(tmp, file2);
+}
+
+// src/cli/slashHandlers/krakenFanout.ts
+function parseFanoutArgs(argv) {
+  if (argv.length === 0) {
+    return { ok: false, usage: USAGE };
+  }
+  const positional = [];
+  const flags = {};
+  const listFlags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq >= 0) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+      } else if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
+        flags[a.slice(2)] = argv[i + 1];
+        i += 1;
+      } else {
+        flags[a.slice(2)] = true;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  const csv = positional[0] ?? (typeof flags.csv === "string" ? flags.csv : void 0);
+  const col = typeof flags.col === "string" ? flags.col : void 0;
+  const out = typeof flags.out === "string" ? flags.out : void 0;
+  const instruction = typeof flags.instruction === "string" ? flags.instruction : void 0;
+  if (!csv) return { ok: false, error: "csv_path is required (positional or --csv)" };
+  if (!col) return { ok: false, error: "--col <id_column> is required" };
+  if (!out) return { ok: false, error: "--out <output_csv_path> is required" };
+  if (!instruction) return { ok: false, error: "--instruction <template> is required" };
+  const agentKindRaw = typeof flags.agent === "string" ? flags.agent : "verify";
+  if (agentKindRaw !== "explore" && agentKindRaw !== "verify" && agentKindRaw !== "general") {
+    return { ok: false, error: `--agent must be one of explore, verify, general (got "${agentKindRaw}")` };
+  }
+  const thoroughnessRaw = typeof flags.thoroughness === "string" ? flags.thoroughness : "medium";
+  if (thoroughnessRaw !== "quick" && thoroughnessRaw !== "medium" && thoroughnessRaw !== "deep") {
+    return { ok: false, error: `--thoroughness must be one of quick, medium, deep (got "${thoroughnessRaw}")` };
+  }
+  let concurrency;
+  if (typeof flags.concurrency === "string") {
+    concurrency = Number.parseInt(flags.concurrency, 10);
+    if (!Number.isFinite(concurrency) || concurrency <= 0) {
+      return { ok: false, error: `--concurrency must be a positive integer (got "${flags.concurrency}")` };
+    }
+  }
+  let maxRuntimeSeconds;
+  if (typeof flags["max-runtime"] === "string") {
+    maxRuntimeSeconds = Number.parseInt(flags["max-runtime"], 10);
+    if (!Number.isFinite(maxRuntimeSeconds) || maxRuntimeSeconds <= 0) {
+      return { ok: false, error: `--max-runtime must be a positive integer (got "${flags["max-runtime"]}")` };
+    }
+  }
+  const scopeList = listFlags.scope ?? (typeof flags.scope === "string" ? [flags.scope] : void 0);
+  return {
+    ok: true,
+    args: {
+      csv_path: csv,
+      id_column: col,
+      output_csv_path: out,
+      instruction_template: instruction,
+      agent_kind: agentKindRaw,
+      thoroughness: thoroughnessRaw,
+      ...scopeList ? { scope_template: scopeList } : {},
+      ...concurrency !== void 0 ? { max_concurrency: concurrency } : {},
+      ...maxRuntimeSeconds !== void 0 ? { max_runtime_seconds: maxRuntimeSeconds } : {}
+    }
+  };
+}
+var USAGE = `Usage:
+  /kraken fanout <csv_path>
+    --col <id_column>
+    --out <output_csv_path>
+    --instruction "<template with {column} placeholders>"
+    [--agent explore|verify|general]            (default: verify)
+    [--thoroughness quick|medium|deep]           (default: medium)
+    [--scope "<glob template>"]                  (repeatable)
+    [--concurrency <n>]                          (default: ZELARI_KRAKEN_MAX_PARALLEL)
+    [--max-runtime <seconds>]
+
+Each row in <csv_path> becomes one sub-agent tentacle. The result CSV
+gets one row per input row, with extra columns \`status\`, \`result\`, \`error\`.`;
+async function handleKrakenFanout(ctx, raw) {
+  const argv = splitArgs(stripPrefix(raw, "fanout"));
+  const parsed = parseFanoutArgs(argv);
+  if (!parsed.ok || !parsed.args) {
+    appendSystem(ctx.setMessages, parsed.usage ?? `Usage: ${USAGE}`);
+    if (parsed.error) {
+      appendSystem(ctx.setMessages, `[kraken fanout] ${parsed.error}`);
+    }
+    return;
+  }
+  const absCsv = isAbsolute(parsed.args.csv_path) ? parsed.args.csv_path : joinPath(ctx.cwd, parsed.args.csv_path);
+  try {
+    await fs21.access(absCsv);
+  } catch {
+    appendSystem(ctx.setMessages, `[kraken fanout] source CSV not found: ${absCsv}`);
+    return;
+  }
+  appendSystem(
+    ctx.setMessages,
+    `[kraken fanout] starting: ${parsed.args.csv_path} \u2192 ${parsed.args.output_csv_path} (agent=${parsed.args.agent_kind})`
+  );
+  const audit = new AuditLogger();
+  const taskToolDeps = {
+    createSubAgentContext: createKrakenSubAgentContextFactory({
+      root: ctx.cwd,
+      audit,
+      sessionId: ctx.sessionId
+    })
+  };
+  try {
+    const summary = await runCsvFanout(parsed.args, taskToolDeps, {
+      parentCwd: ctx.cwd,
+      sessionId: ctx.sessionId,
+      onLog: (line) => appendSystem(ctx.setMessages, `[kraken fanout] ${line}`)
+    });
+    appendSystem(
+      ctx.setMessages,
+      `[kraken fanout] done: ${summary.completed}/${summary.rows} ok, ${summary.errored} error, ${summary.durationMs}ms \u2192 ${summary.output_csv_path}`
+    );
+  } catch (err) {
+    appendSystem(
+      ctx.setMessages,
+      `[kraken fanout] failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function isAbsolute(p3) {
+  return /^([A-Za-z]:[\\/]|[\\/])/.test(p3);
+}
+function joinPath(a, b) {
+  if (a.endsWith("\\") || a.endsWith("/")) return a + b;
+  return `${a}\\${b}`;
+}
+function stripPrefix(s, prefix) {
+  const trimmed = s.trim();
+  if (trimmed.toLowerCase().startsWith(prefix.toLowerCase())) {
+    return trimmed.slice(prefix.length).trim();
+  }
+  return trimmed;
+}
+function splitArgs(s) {
+  const out = [];
+  let cur = "";
+  let inQuotes = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (!inQuotes && /\s/.test(ch)) {
+      if (cur !== "") {
+        out.push(cur);
+        cur = "";
+      }
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur !== "") out.push(cur);
+  return out;
+}
+
+// src/cli/slashHandlers/krakenWorkbench.ts
+import { promises as fs22 } from "node:fs";
+import path37 from "node:path";
+
+// src/cli/kraken/workbenchView.ts
+var EMPTY = {
+  goal: "",
+  graphId: "",
+  started: "",
+  elapsed: "",
+  progress: "",
+  nodes: [],
+  events: []
+};
+function parseWorkbench(content) {
+  if (!content) return { ...EMPTY, nodes: [], events: [] };
+  const lines = content.split(/\r?\n/);
+  const out = { ...EMPTY, nodes: [], events: [] };
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const goalM = /^\*\*Goal:\*\*\s*(.*)$/.exec(line);
+    if (goalM) {
+      out.goal = goalM[1];
+      i += 1;
+      continue;
+    }
+    const gidM = /^\*\*Graph id:\*\*\s*`?([^`\s]*)`?/.exec(line);
+    if (gidM) {
+      out.graphId = gidM[1];
+      i += 1;
+      continue;
+    }
+    const startedM = /^\*\*Started:\*\*\s*(.+?)\s*·\s*\*\*Elapsed:\*\*\s*(\S+)/.exec(line);
+    if (startedM) {
+      out.started = startedM[1];
+      out.elapsed = startedM[2];
+      i += 1;
+      continue;
+    }
+    const justStarted = /^\*\*Started:\*\*\s*(.*)$/.exec(line);
+    if (justStarted) {
+      out.started = justStarted[1];
+      i += 1;
+      continue;
+    }
+    const sectionM = /^##\s+([^:\s]+)(?::\s*(.*))?/.exec(line);
+    if (!sectionM) {
+      i += 1;
+      continue;
+    }
+    const section = sectionM[1];
+    const inline = sectionM[2] ?? "";
+    if (section === "Progress") {
+      if (inline) out.progress = inline;
+      i += 1;
+      continue;
+    }
+    if (section === "Wave") {
+      while (i < lines.length && !lines[i].startsWith("| t")) i += 1;
+      while (i < lines.length && lines[i].startsWith("| t")) {
+        const cells = splitRow(lines[i]);
+        if (cells.length >= 7) {
+          out.nodes.push({
+            id: cells[0],
+            label: cells[1],
+            kind: cells[2],
+            scope: cells[3],
+            status: cells[4],
+            model: cells[5],
+            duration: cells[6]
+          });
+        }
+        i += 1;
+      }
+      continue;
+    }
+    if (section === "Events" || section.startsWith("Events")) {
+      while (i < lines.length && !lines[i].startsWith("- ")) i += 1;
+      while (i < lines.length && lines[i].startsWith("- ")) {
+        const m = /^-\s+(\d{2}:\d{2}:\d{2})\s+(.*)$/.exec(lines[i]);
+        if (m) out.events.push({ ts: m[1], text: m[2] });
+        i += 1;
+      }
+      continue;
+    }
+    i += 1;
+  }
+  return out;
+}
+function splitRow(line) {
+  return line.replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+}
+function formatWorkbenchForTerminal(p3) {
+  const lines = [];
+  if (p3.goal) lines.push(`[kraken] ${p3.goal}`);
+  if (p3.progress) lines.push(`[kraken] progress: ${p3.progress}`);
+  if (p3.elapsed) lines.push(`[kraken] elapsed: ${p3.elapsed}`);
+  lines.push("");
+  if (p3.nodes.length > 0) {
+    lines.push("[kraken] wave:");
+    for (const n of p3.nodes) {
+      const scope = n.scope ? ` (${n.scope})` : "";
+      const dur = n.duration ? ` ${n.duration}` : "";
+      lines.push(`  ${n.status}  ${n.id}  ${n.label}${scope}${dur ? " " + dur : ""}`);
+    }
+    lines.push("");
+  }
+  if (p3.events.length > 0) {
+    lines.push("[kraken] events (latest):");
+    for (const e of p3.events.slice(-10)) {
+      lines.push(`  ${e.ts}  ${e.text}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/slashHandlers/krakenWorkbench.ts
+async function handleKrakenWorkbench(ctx) {
+  const dir = path37.join(ctx.cwd, ".zelari", "radio");
+  let latest = null;
+  let latestMtime = 0;
+  try {
+    const files = await fs22.readdir(dir);
+    for (const f of files) {
+      if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
+      const full = path37.join(dir, f);
+      const stat = await fs22.stat(full);
+      if (stat.mtimeMs > latestMtime) {
+        latestMtime = stat.mtimeMs;
+        latest = full;
+      }
+    }
+  } catch {
+  }
+  if (!latest) {
+    appendSystem(ctx.setMessages, "[kraken workbench] no workbench file found (.zelari/radio/workbench-*.md)");
+    return;
+  }
+  const content = await fs22.readFile(latest, "utf8");
+  const parsed = parseWorkbench(content);
+  const rendered = formatWorkbenchForTerminal(parsed);
+  if (!rendered.trim()) {
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path37.basename(latest)}: (no nodes / no events yet)`);
+    return;
+  }
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path37.basename(latest)}:
+${rendered}`);
+}
+
 // src/cli/compaction.ts
 function compactTranscript(messages, options = {}) {
   const threshold = options.threshold ?? 50;
@@ -45071,7 +47561,7 @@ ${output}`.toLowerCase();
 }
 
 // src/cli/slashHandlers/plugins.ts
-init_registry2();
+init_registry3();
 
 // src/cli/plugins/installer.ts
 init_cmdline();
@@ -45225,17 +47715,17 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 }
 
 // src/cli/slashHandlers/promoteMember.ts
-import { promises as fs20 } from "node:fs";
-import path38 from "node:path";
+import { promises as fs23 } from "node:fs";
+import path40 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 ?? 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");
+    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path40.join(os10.homedir(), ".tmp", "zelari-code", "skills");
+    await fs23.mkdir(skillDir, { recursive: true });
+    const filePath = path40.join(skillDir, `${skill.id}.md`);
+    await fs23.writeFile(filePath, markdown, "utf8");
     appendSystem(
       ctx.setMessages,
       `[promote-member] ${skill.name} (${memberId}) \u2192 ${filePath}
@@ -45251,25 +47741,25 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-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 { promises as fs24, existsSync as existsSync38, readFileSync as readFileSync30, writeFileSync as writeFileSync19, mkdirSync as mkdirSync16, statSync as statSync4, rmSync as rmSync3 } from "node:fs";
+import path41 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 ?? path39.join(os11.homedir(), ".tmp", "zelari-code", "branches");
+  return process.env.ANATHEMA_BRANCHES_DIR ?? path41.join(os11.homedir(), ".tmp", "zelari-code", "branches");
 }
 function getSessionsBaseDir() {
-  return process.env.ANATHEMA_SESSIONS_DIR ?? path39.join(os11.homedir(), ".tmp", "zelari-code", "sessions");
+  return process.env.ANATHEMA_SESSIONS_DIR ?? path41.join(os11.homedir(), ".tmp", "zelari-code", "sessions");
 }
 function branchPathFor(name, baseDir) {
-  return path39.join(baseDir, name);
+  return path41.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path39.join(baseDir, name, META_FILENAME);
+  return path41.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path39.join(baseDir, name, SESSIONS_SUBDIR);
+  return path41.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -45294,13 +47784,13 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync16(path39.dirname(metaPath), { recursive: true });
+  mkdirSync16(path41.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 fs21.readdir(sessionsPath);
+    const entries = await fs24.readdir(sessionsPath);
     return entries.filter((e) => e.endsWith(".jsonl")).length;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
@@ -45345,15 +47835,15 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path39.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path41.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 = path39.join(branchSessionsPath, `${fromSessionId}.jsonl`);
-  await fs21.copyFile(sourcePath, destPath);
+  const destPath = path41.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  await fs24.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
     createdAt: Date.now(),
@@ -45371,7 +47861,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
 async function listBranches(baseDir = getBranchesBaseDir()) {
   let entries;
   try {
-    entries = await fs21.readdir(baseDir);
+    entries = await fs24.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -45452,26 +47942,26 @@ async function handleBranchCheckout(ctx, branchName) {
 }
 
 // src/cli/slashHandlers/workspace.ts
-import { promises as fs22 } from "node:fs";
-import path40 from "node:path";
+import { promises as fs25 } from "node:fs";
+import path42 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path40.join(process.cwd(), ".zelari");
+    const zelari = path42.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path40.join(zelari, "plan.md");
+        const planPath = path42.join(zelari, "plan.md");
         try {
-          content = await fs22.readFile(planPath, "utf-8");
+          content = await fs25.readFile(planPath, "utf-8");
         } catch {
           content = "(no plan.md yet \u2014 run a council session first)";
         }
         break;
       }
       case "decisions": {
-        const decisionsDir = path40.join(zelari, "decisions");
+        const decisionsDir = path42.join(zelari, "decisions");
         try {
-          const files = (await fs22.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs25.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
             content = "(no ADRs yet \u2014 invoke /council to generate some)";
           } else {
@@ -45479,7 +47969,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 fs22.readFile(path40.join(decisionsDir, f), "utf-8");
+              const raw = await fs25.readFile(path42.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}`);
@@ -45492,27 +47982,27 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path40.join(zelari, "risks.md");
+        const risksPath = path42.join(zelari, "risks.md");
         try {
-          content = await fs22.readFile(risksPath, "utf-8");
+          content = await fs25.readFile(risksPath, "utf-8");
         } catch {
           content = "(no risks.md yet)";
         }
         break;
       }
       case "agents": {
-        const agentsPath = path40.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path42.join(process.cwd(), "AGENTS.MD");
         try {
-          content = await fs22.readFile(agentsPath, "utf-8");
+          content = await fs25.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 = path40.join(zelari, "docs");
+        const docsDir = path42.join(zelari, "docs");
         try {
-          const files = (await fs22.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs25.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
 
 ` + files.map((f) => `- ${f}`).join("\n") : "(no docs drafts yet)";
@@ -45552,8 +48042,8 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path40.join(process.cwd(), ".zelari");
-    await fs22.rm(target, { recursive: true, force: true });
+    const target = path42.join(process.cwd(), ".zelari");
+    await fs25.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)}`);
@@ -45912,16 +48402,16 @@ function handleModelsRefresh(ctx) {
 }
 
 // src/cli/slashHandlers/skills.ts
-import path41 from "node:path";
+import path43 from "node:path";
 import os12 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs23, existsSync as existsSync39, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync4, mkdirSync as mkdirSync17 } from "node:fs";
+import { promises as fs26, 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 fs23.readFile(file2, "utf-8");
+    raw = await fs26.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -46038,7 +48528,7 @@ function handleSkillPicker(ctx, skills, openPicker, fallbackMessage) {
   });
 }
 async function handleSkillStats(ctx, skillId) {
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path41.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path43.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const records = await readSkillHistory(historyFile);
     const stats = getSkillStats(records, skillId);
@@ -46054,7 +48544,7 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
     appendSystem(ctx.setMessages, fallbackMessage ?? "[skill-compare] missing args");
     return;
   }
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path41.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path43.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const formatted = await compareSkillsFromFile(ids[0], ids[1], historyFile);
     appendSystem(ctx.setMessages, formatted);
@@ -46478,6 +48968,18 @@ function useSlashDispatch(params) {
       await handleKrakenGraph({ setMessages, cwd: process.cwd(), sessionId: sid }, result.graphPrompt ?? "");
       return;
     }
+    if (result.kind === "kraken_fanout") {
+      const sid = (sessionId || "default").trim();
+      await handleKrakenFanout(
+        { setMessages, cwd: process.cwd(), sessionId: sid },
+        result.fanoutArgs ?? ""
+      );
+      return;
+    }
+    if (result.kind === "kraken_workbench") {
+      await handleKrakenWorkbench({ setMessages, cwd: process.cwd() });
+      return;
+    }
     if (result.kind === "phase_set" && result.phaseTarget) {
       const { setPhase: setPhase2 } = await Promise.resolve().then(() => (init_phaseState(), phaseState_exports));
       const { describePhase: describePhase2 } = await Promise.resolve().then(() => (init_phase(), phase_exports));
@@ -47061,7 +49563,7 @@ function SplashGate({
 // src/cli/components/PluginGate.tsx
 import React12, { useEffect as useEffect9, useState as useState10, useCallback as useCallback6 } from "react";
 import { Box as Box11, Text as Text12, useStdin as useStdin4 } from "ink";
-init_registry2();
+init_registry3();
 init_prefs();
 var CHOICE_INSTALL = "__install__";
 var CHOICE_LATER = "__later__";
@@ -47501,6 +50003,8 @@ function parseHeadlessFlags(argv) {
   let history2;
   let once = false;
   let krakenGraph;
+  let planOnly = process.env.ZELARI_KRAKEN_PLAN_ONLY === "1" || process.env.ZELARI_KRAKEN_PLAN_ONLY === "true";
+  let runPlan = process.env.ZELARI_KRAKEN_RUN_PLAN;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--headless") continue;
@@ -47594,6 +50098,11 @@ function parseHeadlessFlags(argv) {
     } else if (arg === "--kraken-graph") {
       krakenGraph = argv[i + 1];
       i++;
+    } else if (arg === "--plan-only") {
+      planOnly = true;
+    } else if (arg === "--run-plan") {
+      runPlan = argv[i + 1];
+      i++;
     }
   }
   if (councilFlag && !modeExplicit) {
@@ -47621,7 +50130,9 @@ function parseHeadlessFlags(argv) {
       model,
       ...history2 && history2.length > 0 ? { history: history2 } : {},
       ...once ? { once: true } : {},
-      ...krakenGraph ? { krakenGraph } : {}
+      ...krakenGraph ? { krakenGraph } : {},
+      ...planOnly ? { planOnly: true } : {},
+      ...runPlan ? { runPlan } : {}
     }
   };
 }
@@ -47692,6 +50203,9 @@ function createStreamScrubber() {
 
 // src/cli/runHeadless.ts
 init_taskTool();
+import { promises as fs28 } from "node:fs";
+import path45 from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
 async function runHeadless(opts) {
   resetTaskSpawnCount();
   try {
@@ -47780,7 +50294,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,18 +50307,69 @@ 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 {
+    let preflightGraph;
+    if (opts.runPlan && opts.runPlan.trim() !== "") {
+      const planPath = path45.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      log(`loading pre-flight plan: ${planPath}`);
+      let raw;
+      try {
+        raw = await fs28.readFile(planPath, "utf8");
+      } catch (e) {
+        log(`plan file not found: ${planPath} (${e.message})`);
+        return 1;
+      }
+      let planJson;
+      try {
+        planJson = JSON.parse(raw);
+      } catch (e) {
+        log(`plan file is malformed JSON: ${e.message}`);
+        return 1;
+      }
+      if (!planJson || !Array.isArray(planJson.nodes)) {
+        log(`plan file is malformed: missing "nodes" array`);
+        return 1;
+      }
+      const { createGraph: createGraph2, validateGraph: validateGraph2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+      const validated = createGraph2(planJson.graphId ?? opts.runPlan, planJson.nodes);
+      validateGraph2(validated);
+      preflightGraph = validated;
+      log(`pre-flight plan loaded (${validated.nodes.size} nodes); executing`);
+    }
     log(`planning kraken graph: ${prompt}`);
     const previous = await loadGraphSnapshot2(cwd);
     const previousAttempt = formatSnapshotForPlanner2(previous);
     if (previousAttempt) log("resuming from the previous unfinished graph");
-    const graph = await planTaskGraph2({
+    const graph = preflightGraph ?? await planTaskGraph2({
       prompt,
       provider,
       model,
+      cwd,
       ...previousAttempt ? { previousAttempt } : {}
     });
     log(formatKrakenGraphAscii2(graph));
+    if (opts.planOnly) {
+      const planId = randomUUID6();
+      const planDir = path45.join(cwd, ".zelari", "radio");
+      const planPath = path45.join(planDir, `plan-${planId}.json`);
+      await fs28.mkdir(planDir, { recursive: true });
+      await fs28.writeFile(planPath, JSON.stringify(graph, null, 2), "utf8");
+      log(`plan-only: wrote ${planPath} (${graph.nodes.size} nodes)`);
+      log(
+        `re-run with ZELARI_KRAKEN_RUN_PLAN=${planId} to execute (or --run-plan <id> when the desktop wiring is in place)`
+      );
+      if (opts.output === "json") {
+        emitEvent({ type: "log", message: `plan_only_id=${planId}` });
+        emitEvent({ type: "log", message: `plan_only_path=${planPath}` });
+      }
+      return 0;
+    }
     const audit = new AuditLogger2();
     const executor = new KrakenGraphExecutor2({
       taskToolDeps: {
@@ -47823,10 +50388,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 +50428,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
 `);
     }
     return 2;
+  } finally {
+    process.off("SIGINT", onSigint);
   }
 }
 function planModeFromOpts(opts) {
@@ -48668,7 +51245,7 @@ ${ragContext}` : slicePrompt;
 init_desktopConfig();
 
 // src/cli/plugins/cliFlags.ts
-init_registry2();
+init_registry3();
 function getArg(argv, flag) {
   const i = argv.indexOf(flag);
   if (i < 0) return void 0;
@@ -48968,7 +51545,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path44 = skillFilePath(dir, name);
+  const path47 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -48977,13 +51554,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path44);
+  const parsed = parseSkillMd(content, path47);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync18(dirname9(path44), { recursive: true });
-  writeFileSync20(path44, content, "utf8");
-  return { ok: true, path: path44 };
+  mkdirSync18(dirname9(path47), { recursive: true });
+  writeFileSync20(path47, content, "utf8");
+  return { ok: true, path: path47 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -49001,8 +51578,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join34(dir, name);
-  const path44 = skillFilePath(dir, name);
-  if (!existsSync42(path44) && !existsSync42(skillDir)) {
+  const path47 = skillFilePath(dir, name);
+  if (!existsSync42(path47) && !existsSync42(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -49013,7 +51590,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path44 };
+  return { ok: true, path: path47 };
 }
 
 // src/cli/generateSkillFromUrl.ts
@@ -49103,8 +51680,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 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";
+      const path47 = 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 = path47 && /^[a-z0-9]/.test(path47) ? path47 : "imported-skill";
     } catch {
       name = "imported-skill";
     }