zelari-code 1.29.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;
   }
 });
@@ -25074,6 +25210,14 @@ function canRunParallel(a, b) {
   }
   return false;
 }
+function selectParallelWave(candidates) {
+  const wave = [];
+  for (const node of candidates) {
+    if (wave.every((w) => canRunParallel(w, node)))
+      wave.push(node);
+  }
+  return wave;
+}
 var READ_ONLY_KINDS, WRITER_KINDS;
 var init_conflict = __esm({
   "packages/core/dist/kraken/conflict.js"() {
@@ -25083,6 +25227,168 @@ 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 : "";
@@ -25103,6 +25409,55 @@ function parseVerifyVerdict(text) {
   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)
@@ -25114,11 +25469,537 @@ 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"() {
@@ -25126,10 +26007,254 @@ var init_kraken = __esm({
     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";
@@ -25773,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;
   }
@@ -25791,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
@@ -25821,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}
 `);
@@ -25836,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();
@@ -26770,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,
@@ -28765,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 {
   }
 }
@@ -28808,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"
@@ -28826,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"
@@ -28989,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");
@@ -29076,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");
@@ -29591,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;
@@ -29641,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) {
@@ -29690,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";
@@ -29698,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,
@@ -29747,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,
@@ -29762,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,
@@ -29771,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,
@@ -29782,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,
@@ -29795,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,
@@ -29805,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));
@@ -29824,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 {
@@ -30072,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();
@@ -31425,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) + `
@@ -31469,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();
@@ -31523,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(
@@ -31541,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.`);
   }
@@ -31932,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) {
@@ -32031,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 {
@@ -32197,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,
@@ -32214,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) {
@@ -32418,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",
@@ -32444,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.`;
       });
     }
@@ -32526,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.`;
       });
     }
@@ -32694,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 {
@@ -32731,7 +33863,7 @@ var init_toolRegistry2 = __esm({
   "src/cli/workspace/toolRegistry.ts"() {
     "use strict";
     init_zod();
-    init_registry();
+    init_registry2();
     init_toolTypes();
     init_stubs();
   }
@@ -33077,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;
@@ -33096,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) {
@@ -33132,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) {
@@ -33143,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"() {
@@ -33310,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();
@@ -33319,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
@@ -33503,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;
   }
@@ -33588,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 = "";
@@ -34121,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 = {
@@ -34157,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,
@@ -35376,6 +36508,7 @@ __export(planner_exports, {
   KRAKEN_PLANNER_SYSTEM_PROMPT: () => KRAKEN_PLANNER_SYSTEM_PROMPT,
   PlannerTransportError: () => PlannerTransportError,
   buildGraphFromPlan: () => buildGraphFromPlan,
+  buildPlannerSystemPrompt: () => buildPlannerSystemPrompt,
   buildPlannerUserPrompt: () => buildPlannerUserPrompt,
   extractJsonObject: () => extractJsonObject,
   planTaskGraph: () => planTaskGraph,
@@ -35399,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);
@@ -35824,7 +36966,7 @@ async function planTaskGraph(opts) {
   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")) {
@@ -35850,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_PLANNER_WORKSPACE_CHARS, DEFAULT_LLM_TIMEOUT_MS, PlannerTransportError, DEFAULT_LLM_MAX_TOKENS, DEFAULT_MAX_RETRIES, KRAKEN_PLANNER_SYSTEM_PROMPT, PlannedNodeSchema, PlannedGraphSchema, MAX_VERIFY_TASK_PROMPT_CHARS;
+var 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";
@@ -35875,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.",
@@ -35887,7 +37033,7 @@ 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 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.',
@@ -35896,7 +37042,36 @@ var init_planner = __esm({
       '- 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. 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.'
+      '- "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"),
@@ -36033,6 +37208,126 @@ 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, {
@@ -36130,14 +37425,14 @@ function buildUpstreamContext(graph, node) {
     if (!dep || dep.status !== "done") continue;
     const raw = (dep.result ?? "").trim();
     if (!raw) continue;
-    const cap2 = Math.min(MAX_UPSTREAM_CHARS_PER_DEP, budget);
-    if (cap2 <= 0) {
+    const cap3 = Math.min(MAX_UPSTREAM_CHARS_PER_DEP, budget);
+    if (cap3 <= 0) {
       omitted.push(dep.label);
       continue;
     }
-    const body = raw.length > cap2 ? `${raw.slice(0, cap2)}
-\u2026 [truncated ${raw.length}\u2192${cap2} chars]` : raw;
-    budget -= Math.min(raw.length, cap2);
+    const 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}`);
@@ -36443,7 +37738,7 @@ var init_executor = __esm({
         }
         const isRework = this.reworks.has(node.id);
         const usesWorktree = (node.kind === "general" || node.kind === "fix") && !isRework;
-        const agent = node.kind === "fix" ? "general" : node.kind;
+        const 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();
@@ -36745,6 +38040,7 @@ ${upstream}` : node.prompt,
         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,
@@ -36939,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
+        });
+      }
     };
   }
 });
@@ -37327,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();
@@ -37351,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
@@ -37388,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 {
@@ -37406,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];
@@ -37475,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();
@@ -37544,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
@@ -37575,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,
@@ -37587,7 +38918,7 @@ function resolveMention(token, cwd) {
       };
     }
   }
-  if (isAbsolute(token) && !underRoot(abs, cwd)) {
+  if (isAbsolute2(token) && !underRoot(abs, cwd)) {
     return {
       raw: token,
       path: token,
@@ -37715,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 {
@@ -37731,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 };
@@ -37745,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 {
   }
 }
@@ -38022,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");
 }
@@ -38039,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) => ({
@@ -38082,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 };
@@ -38116,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()];
@@ -38176,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";
@@ -38245,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 = {
@@ -38503,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",
@@ -38517,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) => ({
@@ -38539,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(),
@@ -38557,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 {
@@ -38604,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);
@@ -38669,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);
@@ -38781,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"));
@@ -38793,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 {
@@ -38811,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;
@@ -38827,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}
@@ -38855,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,
@@ -38895,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}
@@ -38916,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);
@@ -38993,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 });
@@ -39092,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,
@@ -39332,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`;
@@ -39522,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;
@@ -39545,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
@@ -44957,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,
@@ -45571,6 +46916,508 @@ ${digest}
   }
 }
 
+// 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;
@@ -45714,7 +47561,7 @@ ${output}`.toLowerCase();
 }
 
 // src/cli/slashHandlers/plugins.ts
-init_registry2();
+init_registry3();
 
 // src/cli/plugins/installer.ts
 init_cmdline();
@@ -45868,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}
@@ -45894,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);
@@ -45937,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;
@@ -45988,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(),
@@ -46014,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;
@@ -46095,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 {
@@ -46122,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}`);
@@ -46135,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)";
@@ -46195,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)}`);
@@ -46555,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 [];
   }
@@ -46681,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);
@@ -46697,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);
@@ -47121,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));
@@ -47704,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__";
@@ -48144,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;
@@ -48237,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) {
@@ -48264,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 } : {}
     }
   };
 }
@@ -48335,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 {
@@ -48443,11 +50314,39 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   };
   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,
@@ -48455,6 +50354,22 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
       ...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: {
@@ -49330,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;
@@ -49630,7 +51545,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path44 = skillFilePath(dir, name);
+  const path47 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -49639,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();
@@ -49663,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 {
@@ -49675,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
@@ -49765,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";
     }