zelari-code 1.48.1 → 1.49.0

package/dist/cli/main.bundled.js

@@ -1473,27 +1473,27 @@ function readStore() {
   }
   return { providers: {} };
 }
-function writeStore(store4) {
+function writeStore(store6) {
   const file2 = getKeyStorePath();
   mkdirSync2(path3.dirname(file2), { recursive: true });
-  writeFileSync2(file2, JSON.stringify(store4, null, 2), { encoding: "utf-8", mode: 384 });
+  writeFileSync2(file2, JSON.stringify(store6, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function setApiKey(providerId, key) {
-  const store4 = readStore();
-  store4.providers[providerId] = { apiKey: key };
-  writeStore(store4);
+  const store6 = readStore();
+  store6.providers[providerId] = { apiKey: key };
+  writeStore(store6);
 }
 function clearApiKey(providerId) {
-  const store4 = readStore();
-  delete store4.providers[providerId];
-  writeStore(store4);
+  const store6 = readStore();
+  delete store6.providers[providerId];
+  writeStore(store6);
 }
 function getStoredApiKey(providerId) {
-  const store4 = readStore();
-  return store4.providers[providerId]?.apiKey ?? null;
+  const store6 = readStore();
+  return store6.providers[providerId]?.apiKey ?? null;
 }
 function setOAuthToken(providerId, token) {
-  const store4 = readStore();
+  const store6 = readStore();
   const entry = { apiKey: token.apiKey };
   if (typeof token.expiresAt === "number" && Number.isFinite(token.expiresAt)) {
     entry.expiresAt = token.expiresAt;
@@ -1507,12 +1507,12 @@ function setOAuthToken(providerId, token) {
   if (typeof token.idToken === "string" && token.idToken.length > 0) {
     entry.idToken = token.idToken;
   }
-  store4.providers[providerId] = entry;
-  writeStore(store4);
+  store6.providers[providerId] = entry;
+  writeStore(store6);
 }
 function getOAuthToken(providerId) {
-  const store4 = readStore();
-  return store4.providers[providerId] ?? null;
+  const store6 = readStore();
+  return store6.providers[providerId] ?? null;
 }
 function resolveApiKey(providerId) {
   const spec = getProviderSpec(providerId);
@@ -1571,8 +1571,8 @@ async function forceRefreshOAuth(providerId, options = {}) {
 function readStoreDirect() {
   return readStore();
 }
-function writeStoreDirect(store4) {
-  writeStore(store4);
+function writeStoreDirect(store6) {
+  writeStore(store6);
 }
 function maskKey(key) {
   if (key.length <= 12) return "****";
@@ -1917,9 +1917,11 @@ var init_thinking = __esm({
 var providerConfig_exports = {};
 __export(providerConfig_exports, {
   clearCustomEndpoint: () => clearCustomEndpoint,
+  clearKrakenVerifier: () => clearKrakenVerifier,
   getActiveModel: () => getActiveModel,
   getActiveProvider: () => getActiveProvider,
   getCustomEndpoint: () => getCustomEndpoint,
+  getKrakenVerifierOverride: () => getKrakenVerifierOverride,
   getModelForProvider: () => getModelForProvider,
   getProviderConfig: () => getProviderConfig,
   getProviderConfigPath: () => getProviderConfigPath,
@@ -1927,6 +1929,7 @@ __export(providerConfig_exports, {
   loadProviderConfig: () => loadProviderConfig,
   setActiveProviderId: () => setActiveProviderId,
   setCustomEndpoint: () => setCustomEndpoint,
+  setKrakenVerifier: () => setKrakenVerifier,
   setModelForProvider: () => setModelForProvider,
   setThinkingForProvider: () => setThinkingForProvider
 });
@@ -1950,7 +1953,8 @@ function getProviderConfig() {
           activeProviderId: parsed.activeProviderId,
           modelByProvider: { ...DEFAULTS.modelByProvider, ...parsed.modelByProvider },
           thinkingByProvider: { ...DEFAULTS.thinkingByProvider, ...parsed.thinkingByProvider },
-          customEndpoints: mergeCustomEndpoints(parsed.customEndpoints)
+          customEndpoints: mergeCustomEndpoints(parsed.customEndpoints),
+          krakenVerifier: mergeKrakenVerifier(parsed.krakenVerifier)
         };
       }
     } catch {
@@ -2019,6 +2023,35 @@ function clearCustomEndpoint(id) {
   delete config2.customEndpoints[id];
   writeProviderConfig(config2);
 }
+function mergeKrakenVerifier(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const provider = typeof raw.provider === "string" ? raw.provider.trim() : "";
+  const model = typeof raw.model === "string" ? raw.model.trim() : "";
+  if (!provider || !model) return void 0;
+  if (!PROVIDERS.some((p3) => p3.id === provider)) return void 0;
+  return { provider, model };
+}
+function getKrakenVerifierOverride() {
+  return getProviderConfig().krakenVerifier;
+}
+function setKrakenVerifier(provider, model) {
+  const spec = PROVIDERS.find((p3) => p3.id === provider);
+  if (!spec) {
+    throw new Error(`Unknown provider id: "${provider}". Available: ${PROVIDERS.map((p3) => p3.id).join(", ")}`);
+  }
+  if (!model || model.trim().length === 0) {
+    throw new Error("Verifier model cannot be empty. Use clearKrakenVerifier() to inherit.");
+  }
+  const config2 = getProviderConfig();
+  config2.krakenVerifier = { provider, model: model.trim() };
+  writeProviderConfig(config2);
+}
+function clearKrakenVerifier() {
+  const config2 = getProviderConfig();
+  if (!config2.krakenVerifier) return;
+  delete config2.krakenVerifier;
+  writeProviderConfig(config2);
+}
 function setActiveProviderId(id) {
   const spec = PROVIDERS.find((p3) => p3.id === id);
   if (!spec) {
@@ -20258,7 +20291,7 @@ function getBasePromptModules(mode = "council") {
 function getPromptModule(type) {
   return getBasePromptModules("council").find((m) => m.type === type);
 }
-var CODING_CAPABLE_IDENTITY, COUNCIL_IDENTITY, BEHAVIOR_AGENT, BEHAVIOR_COUNCIL, SAFETY, CONTEXT_SHARING_COUNCIL, OUTPUT_FORMATTING, NATIVE_TOOL_PROTOCOL_MODULE, CODING_PRACTICES_MODULE, TURN_COMPLETION_MODULE, CLARIFICATION_PROTOCOL_MODULE, PROMPT_MODULES, KRAKEN_IDENTITY_MODULE, KRAKEN_LEAD_PLAYBOOK_MODULE, SINGLE_AGENT_IDENTITY_MODULE;
+var CODING_CAPABLE_IDENTITY, COUNCIL_IDENTITY, BEHAVIOR_AGENT, BEHAVIOR_COUNCIL, SAFETY, CONTEXT_SHARING_COUNCIL, OUTPUT_FORMATTING, NATIVE_TOOL_PROTOCOL_MODULE, CODING_PRACTICES_MODULE, TURN_COMPLETION_MODULE, CLARIFICATION_PROTOCOL_MODULE, PROMPT_MODULES, KRAKEN_IDENTITY_MODULE, KRAKEN_LEAD_PLAYBOOK_MODULE, KRAKEN_SELECTION_PLAYBOOK_MODULE, SINGLE_AGENT_IDENTITY_MODULE;
 var init_promptModules = __esm({
   "packages/core/dist/agents/promptModules.js"() {
     "use strict";
@@ -20456,6 +20489,32 @@ Rules:
       priority: 25,
       content: "# Kraken Lead Playbook (super-agent)\n\nYou are the **parent brain**. Sub-agents spawned with task are tentacles: they cannot see this chat and cannot nest further task calls.\n\n## Default workflow (non-trivial work)\n1. **Orient** - list/read key files; optionally task explore (parallel OK for disjoint questions).\n2. **Decompose** - todo_write with concrete slices and acceptance criteria.\n3. **Implement** - one slice at a time via tools or task agent=general for a bounded unit.\n4. **Verify** - after meaningful writes, run checks yourself (bash / typecheck / tests) or task agent=verify. Do not claim done without on-disk evidence.\n5. **Integrate** - summarize files touched + how to verify; if more remains, checkpoint and ask.\n\n## When to spawn task\n- **explore**: unfamiliar area, multi-file search, map call sites (prefer parallel explores).\n- **general**: isolated implement slice with clear path scope (serial writers unless worktree isolation is on).\n- **verify**: post-implement gate (tests/typecheck/smoke).\n\n## Task contracts (required quality)\nEvery task prompt must be self-contained and include:\n- **Goal** (one sentence)\n- **Scope** (paths / symbols allowed; what is out of scope)\n- **Acceptance** (how the parent will know it succeeded)\n- **Constraints** (no drive-by refactors; match existing style)\n\nOptional tool fields: scope (path allowlist hint), acceptance (checklist). Prefer them when available.\n\n## Caps and discipline\n- Prefer at most 4 explore and 2 general spawns per user turn unless the user asks for more.\n- Do not expand scope beyond the user request.\n- Parallel: many explore OK; general writers stay serial unless ZELARI_KRAKEN_WORKTREE=1.\n- Nested task from children is disabled - you are the only orchestrator.\n- Cheap thoroughness defaults: explore=quick|medium; deep only when stuck.\n- Model routing: explore/verify may use ZELARI_KRAKEN_SUB_MODEL (cheaper); general stays on parent model unless ZELARI_KRAKEN_GENERAL_MODEL is set.\n- After every successful task general, spawn task verify (or run tests yourself) before claiming done - the tool appends a verify-hint footer.\n- Opt-in isolation: ZELARI_KRAKEN_WORKTREE=1 runs general tentacles in a git worktree under .zelari/worktrees/ (KEEP=1 to retain branch for manual merge).\n- Progress bus: tentacle spawns log to .zelari/radio/<session>.jsonl - slash command /kraken shows status.\n\n## Done means verified\nNever end with status theater. Either tools ran and files changed, or you stop with a short report and ask whether to continue."
     };
+    KRAKEN_SELECTION_PLAYBOOK_MODULE = {
+      type: "behavior-rules",
+      title: "Kraken Verified Selection (alpha)",
+      // priority 26 = right after the lead playbook (25); +1000 via custom modules.
+      priority: 26,
+      content: [
+        "# Kraken Verified Selection (alpha)",
+        "",
+        "You can explore competing hypotheses before committing to one implementation path.",
+        "The runtime registers candidates, preserves their evidence verbatim, and judges them via the kraken_select tool.",
+        "",
+        "## When to explore candidates",
+        "- **Simple task** (rename, typo fix, small requested edit, single obvious change): go DIRECT. No candidates, no kraken_select.",
+        "- **Ambiguous task** (two or more plausible root causes or designs): spawn 2 candidates.",
+        "- **High uncertainty** (intermittent bug, race condition, architecture decision with trade-offs): spawn up to 3 candidates.",
+        "",
+        "## Rules",
+        '- Spawn candidates with the task tool using purpose="candidate" - explore-only tentacles; they never write.',
+        "- Each candidate must test a DIFFERENT normalized hypothesis. If two candidates would test the same theory, keep one.",
+        "- Wait for all candidate reports, then call kraken_select exactly once.",
+        "- If the verdict is needs_more_evidence: run at most one more targeted explore, then either re-select or proceed with the best-grounded candidate.",
+        "- Implement ONLY the selected path. Never blend multiple candidates.",
+        "- If the verdict includes required checks: in PLAN fold them into the final plan verification section; in BUILD pass them as the Acceptance criteria of your verify tentacle.",
+        "- A degraded, timed-out, or inconclusive observation is never proof of absence."
+      ].join("\n")
+    };
     SINGLE_AGENT_IDENTITY_MODULE = KRAKEN_IDENTITY_MODULE;
   }
 });
@@ -21014,6 +21073,7 @@ __export(skills_exports, {
   CODING_SKILL_CATALOG: () => CODING_SKILL_CATALOG,
   KRAKEN_IDENTITY_MODULE: () => KRAKEN_IDENTITY_MODULE,
   KRAKEN_LEAD_PLAYBOOK_MODULE: () => KRAKEN_LEAD_PLAYBOOK_MODULE,
+  KRAKEN_SELECTION_PLAYBOOK_MODULE: () => KRAKEN_SELECTION_PLAYBOOK_MODULE,
   LANGUAGE_POLICY_MODULE_TYPE: () => LANGUAGE_POLICY_MODULE_TYPE,
   NATIVE_TOOL_PROTOCOL_MODULE: () => NATIVE_TOOL_PROTOCOL_MODULE,
   SINGLE_AGENT_IDENTITY_MODULE: () => SINGLE_AGENT_IDENTITY_MODULE,
@@ -21260,6 +21320,12 @@ function isBrainTaskSnapshotEvent(e) {
 function isBrainContextMetricsEvent(e) {
   return e.type === "context_metrics";
 }
+function isBrainKrakenProgressEvent(e) {
+  return e.type === "kraken_progress";
+}
+function isBrainKrakenMetricsEvent(e) {
+  return e.type === "kraken_metrics";
+}
 function createBrainEvent(type, sessionId2, data) {
   return {
     type,
@@ -26972,6 +27038,7 @@ __export(council_exports, {
   IMPLEMENTATION_WRITE_REQUIREMENTS: () => IMPLEMENTATION_WRITE_REQUIREMENTS,
   KRAKEN_IDENTITY_MODULE: () => KRAKEN_IDENTITY_MODULE,
   KRAKEN_LEAD_PLAYBOOK_MODULE: () => KRAKEN_LEAD_PLAYBOOK_MODULE,
+  KRAKEN_SELECTION_PLAYBOOK_MODULE: () => KRAKEN_SELECTION_PLAYBOOK_MODULE,
   LAYOUT_MOTION_PROPS: () => LAYOUT_MOTION_PROPS,
   LESSONS_FILE: () => LESSONS_FILE,
   MAX_DELIVERY_ATTEMPTS: () => MAX_DELIVERY_ATTEMPTS,
@@ -28211,6 +28278,7 @@ __export(dist_exports, {
   IMPLEMENTATION_WRITE_REQUIREMENTS: () => IMPLEMENTATION_WRITE_REQUIREMENTS,
   KRAKEN_IDENTITY_MODULE: () => KRAKEN_IDENTITY_MODULE,
   KRAKEN_LEAD_PLAYBOOK_MODULE: () => KRAKEN_LEAD_PLAYBOOK_MODULE,
+  KRAKEN_SELECTION_PLAYBOOK_MODULE: () => KRAKEN_SELECTION_PLAYBOOK_MODULE,
   LANGUAGE_POLICY_MODULE_TYPE: () => LANGUAGE_POLICY_MODULE_TYPE,
   LAYOUT_MOTION_PROPS: () => LAYOUT_MOTION_PROPS,
   LESSONS_FILE: () => LESSONS_FILE,
@@ -28335,6 +28403,8 @@ __export(dist_exports, {
   isBrainContextMetricsEvent: () => isBrainContextMetricsEvent,
   isBrainCouncilModeEvent: () => isBrainCouncilModeEvent,
   isBrainErrorEvent: () => isBrainErrorEvent,
+  isBrainKrakenMetricsEvent: () => isBrainKrakenMetricsEvent,
+  isBrainKrakenProgressEvent: () => isBrainKrakenProgressEvent,
   isBrainMemberCostEvent: () => isBrainMemberCostEvent,
   isBrainMessageDeltaEvent: () => isBrainMessageDeltaEvent,
   isBrainMessageEndEvent: () => isBrainMessageEndEvent,
@@ -31155,6 +31225,362 @@ var init_krakenWorktree = __esm({
   }
 });
 
+// src/cli/kraken/candidateRegistry.ts
+function isKrakenSelectionEnabled() {
+  return process.env.ZELARI_KRAKEN_SELECTION === "1";
+}
+function store2() {
+  const g = globalThis;
+  if (!g.__zelariKrakenCandidates) g.__zelariKrakenCandidates = [];
+  return g.__zelariKrakenCandidates;
+}
+function resetKrakenCandidates() {
+  const g = globalThis;
+  g.__zelariKrakenCandidates = [];
+  g.__zelariKrakenSelection = null;
+  g.__zelariKrakenCheckResults = null;
+}
+function setKrakenSelection(verdict) {
+  const g = globalThis;
+  g.__zelariKrakenSelection = verdict;
+}
+function getKrakenSelection() {
+  const g = globalThis;
+  return g.__zelariKrakenSelection ?? null;
+}
+function krakenRequiredChecks() {
+  const verdict = getKrakenSelection();
+  if (!verdict || verdict.status !== "selected") return [];
+  return verdict.requiredChecks;
+}
+function setKrakenCheckResults(results) {
+  const g = globalThis;
+  g.__zelariKrakenCheckResults = results;
+}
+function getKrakenCheckResults() {
+  const g = globalThis;
+  const results = g.__zelariKrakenCheckResults;
+  return results ? [...results] : null;
+}
+function krakenChecksPassed() {
+  const results = getKrakenCheckResults();
+  if (!results) return void 0;
+  return results.filter((r) => r.status === "pass").length;
+}
+function krakenCandidates() {
+  return [...store2()];
+}
+function reserveCandidateSlot() {
+  const n = store2().length;
+  if (n >= KRAKEN_CANDIDATE_CAP) {
+    return {
+      error: `task: candidate cap reached (${KRAKEN_CANDIDATE_CAP}). Compare the existing candidates instead of spawning more.`
+    };
+  }
+  return { index: n + 1 };
+}
+function parseCandidateReport(raw) {
+  const open = raw.lastIndexOf(REPORT_OPEN);
+  const close = raw.lastIndexOf(REPORT_CLOSE);
+  if (open === -1 || close === -1 || close < open) {
+    return { ok: false, error: "missing report block" };
+  }
+  const body = raw.slice(open + REPORT_OPEN.length, close).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (err) {
+    return {
+      ok: false,
+      error: `invalid JSON (${err instanceof Error ? err.message : String(err)})`
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { ok: false, error: "report is not a JSON object" };
+  }
+  const obj = parsed;
+  const evidence = Array.isArray(obj.evidence) ? obj.evidence.filter((e) => typeof e === "object" && e !== null).map((e) => ({
+    claim: typeof e.claim === "string" ? e.claim : "",
+    basis: typeof e.basis === "string" ? e.basis : "",
+    degraded: e.degraded === true
+  })).filter((e) => e.claim.trim().length > 0) : [];
+  const risks = Array.isArray(obj.risks) ? obj.risks.filter((r) => typeof r === "string" && r.trim().length > 0) : [];
+  return {
+    ok: true,
+    report: {
+      hypothesis: typeof obj.hypothesis === "string" ? obj.hypothesis.trim() : "",
+      evidence,
+      risks,
+      hasDegradedEvidence: evidence.some((e) => e.degraded)
+    }
+  };
+}
+function registerCandidate(entry) {
+  const withIndex = { ...entry, index: entry.index ?? store2().length + 1 };
+  store2().push(withIndex);
+  return withIndex;
+}
+function candidateInstructions(index, cap3 = KRAKEN_CANDIDATE_CAP) {
+  return CANDIDATE_INSTRUCTIONS.replaceAll("{index}", String(index)).replaceAll("{cap}", String(cap3));
+}
+var KRAKEN_CANDIDATE_CAP, REPORT_OPEN, REPORT_CLOSE, CANDIDATE_INSTRUCTIONS;
+var init_candidateRegistry = __esm({
+  "src/cli/kraken/candidateRegistry.ts"() {
+    "use strict";
+    KRAKEN_CANDIDATE_CAP = 3;
+    REPORT_OPEN = "<candidate-report>";
+    REPORT_CLOSE = "</candidate-report>";
+    CANDIDATE_INSTRUCTIONS = [
+      "You are CANDIDATE #{index} of at most {cap}: one independent hypothesis",
+      "about the task, researched in parallel with other candidates.",
+      "DIVERSITY: focus on ONE hypothesis and pursue it honestly \u2014 do not try to",
+      "cover every angle. A narrower, well-evidenced hypothesis beats a broad guess.",
+      "OBSERVATION INTEGRITY: mark degraded or inconclusive observations explicitly",
+      "(timeout, zero files walked, unavailable backend) \u2014 degraded is NOT proof",
+      "of absence.",
+      "END your final message with EXACTLY this block (valid JSON, no prose after):",
+      "<candidate-report>",
+      "{",
+      '  "hypothesis": "one-sentence hypothesis you investigated",',
+      '  "evidence": [',
+      '    { "claim": "what you found", "basis": "tool + file:line or command", "degraded": false }',
+      "  ],",
+      '  "risks": ["open questions / weaknesses"]',
+      "}",
+      "</candidate-report>"
+    ].join("\n");
+  }
+});
+
+// src/cli/kraken/verifyReport.ts
+function normalize(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function extractVerifyReportBlocks(raw) {
+  const blocks = [];
+  let cursor = 0;
+  for (; ; ) {
+    const open = raw.indexOf(OPEN, cursor);
+    if (open === -1) break;
+    const close = raw.indexOf(CLOSE, open + OPEN.length);
+    if (close === -1) break;
+    const block = { check: "", status: "" };
+    for (const line of raw.slice(open + OPEN.length, close).split(/\r?\n/)) {
+      const m = /^(check|status|note)\s*:\s*(.*)$/i.exec(line.trim());
+      if (!m) continue;
+      const value = m[2].trim();
+      const key = m[1].toLowerCase();
+      if (key === "check" && !block.check) block.check = value;
+      else if (key === "status" && !block.status) block.status = value;
+      else if (key === "note" && block.note === void 0) block.note = value;
+    }
+    if (block.check) blocks.push(block);
+    cursor = close + CLOSE.length;
+  }
+  return blocks;
+}
+function parseVerifyReport(raw, requiredChecks) {
+  const byCriterion = /* @__PURE__ */ new Map();
+  for (const block of extractVerifyReportBlocks(raw)) {
+    byCriterion.set(normalize(block.check), block);
+  }
+  const keys = [...byCriterion.keys()];
+  return requiredChecks.map((check2) => {
+    const norm = normalize(check2);
+    let block = byCriterion.get(norm) ?? null;
+    if (!block) {
+      for (const key of keys) {
+        if (key.length >= 8 && (key.includes(norm) || norm.includes(key))) {
+          block = byCriterion.get(key) ?? null;
+          break;
+        }
+      }
+    }
+    if (!block) {
+      return {
+        check: check2,
+        status: "unknown",
+        note: "no verify-report block for this check"
+      };
+    }
+    const status = VALID_STATUSES.has(block.status) ? block.status : "unknown";
+    return { check: check2, status, ...block.note ? { note: block.note } : {} };
+  });
+}
+function allUnknownCheckResults(requiredChecks, reason) {
+  return requiredChecks.map((check2) => ({
+    check: check2,
+    status: "unknown",
+    note: reason
+  }));
+}
+var OPEN, CLOSE, VALID_STATUSES;
+var init_verifyReport = __esm({
+  "src/cli/kraken/verifyReport.ts"() {
+    "use strict";
+    OPEN = "<verify-report>";
+    CLOSE = "</verify-report>";
+    VALID_STATUSES = /* @__PURE__ */ new Set(["pass", "fail", "unknown"]);
+  }
+});
+
+// src/cli/kraken/completionGate.ts
+function normalize2(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function classifyKrakenChecks(requiredChecks, results) {
+  const byCriterion = /* @__PURE__ */ new Map();
+  for (const result of results ?? []) {
+    byCriterion.set(normalize2(result.check), result);
+  }
+  const keys = [...byCriterion.keys()];
+  const out = { passed: [], failed: [], unknown: [] };
+  for (const check2 of requiredChecks) {
+    const norm = normalize2(check2);
+    let result = byCriterion.get(norm) ?? null;
+    if (!result) {
+      for (const key of keys) {
+        if (key.length >= 8 && (key.includes(norm) || norm.includes(key))) {
+          result = byCriterion.get(key) ?? null;
+          break;
+        }
+      }
+    }
+    if (!result || result.status === "unknown") out.unknown.push(check2);
+    else if (result.status === "pass") out.passed.push(check2);
+    else out.failed.push(check2);
+  }
+  return out;
+}
+function evaluateKrakenCompletionGate(mode) {
+  try {
+    if (mode !== "build") return OPEN_GATE;
+    const checks = krakenRequiredChecks();
+    if (checks.length === 0) return OPEN_GATE;
+    const classification = classifyKrakenChecks(checks, getKrakenCheckResults());
+    return {
+      blocked: classification.failed.length > 0 || classification.unknown.length > 0,
+      selectionUsed: true,
+      total: checks.length,
+      passed: classification.passed.length,
+      failedChecks: classification.failed,
+      unknownChecks: classification.unknown
+    };
+  } catch {
+    return OPEN_GATE;
+  }
+}
+function buildKrakenRepairPrompt(gate) {
+  const lines = [
+    `The BUILD turn is ending, but the required checks from kraken_select are not all satisfied (passed ${gate.passed}/${gate.total}).`,
+    ""
+  ];
+  if (gate.failedChecks.length > 0) {
+    lines.push("FAILED checks (evidence contradicts them):");
+    for (const check2 of gate.failedChecks) lines.push(`- ${check2}`);
+    lines.push("");
+  }
+  if (gate.unknownChecks.length > 0) {
+    lines.push(
+      "UNKNOWN checks (never conclusively verified \u2014 a degraded or missing observation is NOT proof):"
+    );
+    for (const check2 of gate.unknownChecks) lines.push(`- ${check2}`);
+    lines.push("");
+  }
+  lines.push(
+    "Recover this turn:",
+    "1. The approach selection is settled \u2014 do NOT call kraken_select again.",
+    "2. Fix each failing check directly with focused edits.",
+    "3. Make each unknown check conclusively verifiable (run the real command, read the real output).",
+    "4. Spawn a `task verify` tentacle whose Acceptance lists ALL required checks; its conclusion must contain one <verify-report> block per check with an explicit status.",
+    "5. Only end the turn when every check reports status: pass \u2014 an unverified assumption is not a pass."
+  );
+  return lines.join("\n");
+}
+var OPEN_GATE;
+var init_completionGate = __esm({
+  "src/cli/kraken/completionGate.ts"() {
+    "use strict";
+    init_candidateRegistry();
+    OPEN_GATE = {
+      blocked: false,
+      selectionUsed: false,
+      total: 0,
+      passed: 0,
+      failedChecks: [],
+      unknownChecks: []
+    };
+  }
+});
+
+// src/cli/kraken/metrics.ts
+function store3() {
+  const g = globalThis;
+  g.__zelariKrakenTurnMetrics ??= {
+    candidateTokens: 0,
+    selectionRecorded: false,
+    selectionFallback: false,
+    repairTriggered: false,
+    repairSucceeded: false
+  };
+  return g.__zelariKrakenTurnMetrics;
+}
+function resetKrakenTurnMetrics() {
+  const g = globalThis;
+  g.__zelariKrakenTurnMetrics = void 0;
+}
+function recordCandidateTokens(totalTokens) {
+  if (!Number.isFinite(totalTokens) || totalTokens <= 0) return;
+  store3().candidateTokens += Math.round(totalTokens);
+}
+function recordSelectionOutcome(outcome) {
+  const s = store3();
+  s.selectionRecorded = true;
+  s.selectionLatencyMs = Math.max(0, Math.round(outcome.latencyMs));
+  if (typeof outcome.tokens === "number" && Number.isFinite(outcome.tokens) && outcome.tokens > 0) {
+    s.selectionTokens = Math.round(outcome.tokens);
+  }
+  s.selectionFallback = outcome.degraded;
+  s.selectionFallbackReason = outcome.fallbackReason;
+}
+function markRepairTriggered() {
+  store3().repairTriggered = true;
+}
+function markRepairSucceeded() {
+  if (store3().repairTriggered) store3().repairSucceeded = true;
+}
+function collectKrakenTurnMetrics() {
+  const s = store3();
+  const verdict = getKrakenSelection();
+  const candidates = krakenCandidates();
+  if (!verdict && candidates.length === 0 && !s.selectionRecorded && !s.repairTriggered) {
+    return null;
+  }
+  const classification = classifyKrakenChecks(krakenRequiredChecks(), getKrakenCheckResults());
+  return {
+    selectionUsed: verdict !== null,
+    candidateCount: candidates.length,
+    candidateTokens: s.candidateTokens,
+    ...s.selectionTokens !== void 0 ? { selectionTokens: s.selectionTokens } : {},
+    ...s.selectionLatencyMs !== void 0 ? { selectionLatencyMs: s.selectionLatencyMs } : {},
+    selectionFallback: s.selectionFallback,
+    ...s.selectionFallbackReason !== void 0 ? { selectionFallbackReason: s.selectionFallbackReason } : {},
+    needsMoreEvidence: verdict?.status === "needs_more_evidence",
+    verificationPass: classification.passed.length,
+    verificationFail: classification.failed.length,
+    verificationUnknown: classification.unknown.length,
+    repairTriggered: s.repairTriggered,
+    repairSucceeded: s.repairSucceeded
+  };
+}
+var init_metrics2 = __esm({
+  "src/cli/kraken/metrics.ts"() {
+    "use strict";
+    init_candidateRegistry();
+    init_completionGate();
+  }
+});
+
 // src/cli/tools/taskTool.ts
 function resetTaskSpawnCount() {
   const g = globalThis;
@@ -31184,6 +31610,21 @@ function buildTaskUserPrompt(args) {
   }
   return parts.join("\n");
 }
+function withKrakenRequiredChecks(agent, acceptance) {
+  if (agent !== "verify") return acceptance;
+  const required2 = krakenRequiredChecks();
+  if (required2.length === 0) return acceptance;
+  const seen = new Set((acceptance ?? []).map((a) => a.trim().toLowerCase()));
+  const merged = [...acceptance ?? []];
+  for (const check2 of required2) {
+    const key = check2.trim().toLowerCase();
+    if (!seen.has(key)) {
+      seen.add(key);
+      merged.push(check2);
+    }
+  }
+  return merged;
+}
 function systemPromptForAgent(agent) {
   if (agent === "general") return GENERAL_PROMPT;
   if (agent === "verify") return VERIFY_PROMPT;
@@ -31209,6 +31650,7 @@ async function runSubAgent(harness, opts = {}) {
   let current = "";
   let lastCompleted = "";
   let error51;
+  let usage;
   if (signal?.aborted) return { result: "", aborted: true };
   for await (const ev of harness.run()) {
     if (signal?.aborted) {
@@ -31227,6 +31669,16 @@ async function runSubAgent(harness, opts = {}) {
         break;
       case "message_end":
         if (current.trim()) lastCompleted = current;
+        if (ev.usage) {
+          usage = usage ? {
+            promptTokens: usage.promptTokens + ev.usage.promptTokens,
+            completionTokens: usage.completionTokens + ev.usage.completionTokens,
+            totalTokens: usage.totalTokens + ev.usage.totalTokens,
+            ...(usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0) > 0 ? {
+              cachedPromptTokens: (usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0)
+            } : {}
+          } : ev.usage;
+        }
         current = "";
         break;
       case "error":
@@ -31237,7 +31689,7 @@ async function runSubAgent(harness, opts = {}) {
     }
   }
   const result = (lastCompleted || current).trim();
-  return { result, ...error51 ? { error: error51 } : {} };
+  return { result, ...error51 ? { error: error51 } : {}, ...usage ? { usage } : {} };
 }
 async function runTentacle(opts) {
   const { deps, args, agent, thoroughness, parentCwd, sessionId: sessionId2 } = opts;
@@ -31312,7 +31764,7 @@ async function runTentacle(opts) {
   const userContent = buildTaskUserPrompt({
     prompt: args.prompt,
     scope: args.scope,
-    acceptance: args.acceptance
+    acceptance: withKrakenRequiredChecks(agent, args.acceptance)
   });
   const maxToolCalls = maxToolCallsForThoroughness(thoroughness, agent);
   const runCwd = sub.cwd || effectiveCwd;
@@ -31347,7 +31799,7 @@ async function runTentacle(opts) {
       error: `task: failed to start sub-agent \u2014 ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const { result, error: error51, aborted: aborted2 } = await runSubAgent(harness, {
+  const { result, error: error51, aborted: aborted2, usage } = await runSubAgent(harness, {
     ...opts.signal ? { signal: opts.signal } : {}
   });
   const durationMs = Date.now() - started;
@@ -31448,19 +31900,50 @@ ${verifyHintForGeneral(args.acceptance)}`;
     model: sub.model,
     result,
     footer,
+    ...usage ? { usage } : {},
     worktreePath: worktree?.path ?? null,
     worktreeHandle: worktree
   };
 }
-function createTaskTool(deps) {
+function createTaskTool(deps, policy = {}) {
+  const allowedAgents = policy.allowedAgents ?? ["explore", "general", "verify"];
+  const restricted = policy.allowedAgents !== void 0 && !(policy.allowedAgents.includes("explore") && policy.allowedAgents.includes("general") && policy.allowedAgents.includes("verify"));
+  const inputSchema2 = restricted ? TaskArgsSchema.extend({
+    agent: external_exports.enum(allowedAgents).optional().describe(
+      `Sub-agent type. In this mode ONLY ${allowedAgents.join("|")} is allowed (plan-safe read-only tentacles).`
+    )
+  }) : TaskArgsSchema;
   return {
     name: "task",
-    description: "Delegate a focused sub-task to an isolated sub-agent with its own context; returns only a concise conclusion (keeps parent context lean).\n- agent=explore (default): read-only research/search\n- agent=general: can edit files for one bounded unit of work\n- agent=verify: read + bash to run tests/checks\nProvide a fully self-contained `prompt` (sub-agent cannot see this conversation). Optional scope[] + acceptance[] contracts. After general, follow up with verify.",
+    description: "Delegate a focused sub-task to an isolated sub-agent with its own context; returns only a concise conclusion (keeps parent context lean).\n- agent=explore (default): read-only research/search\n- agent=general: can edit files for one bounded unit of work\n- agent=verify: read + bash to run tests/checks\nProvide a fully self-contained `prompt` (sub-agent cannot see this conversation). Optional scope[] + acceptance[] contracts. After general, follow up with verify." + (restricted ? `
+RESTRICTED in this mode: only agent=${allowedAgents.join("|")} is allowed.` : ""),
     permissions: ["read", "network", "write", "execute"],
     timeoutMs: 3e5,
-    inputSchema: TaskArgsSchema,
+    inputSchema: inputSchema2,
     execute: async (args, ctx) => {
       const agent = args.agent ?? "explore";
+      let candidateSlot = 0;
+      if (!allowedAgents.includes(agent)) {
+        return typedErr(
+          `task: agent=${agent} is not allowed in this mode. Allowed: ${allowedAgents.join(", ")} (plan-safe read-only tentacles). Re-issue with an allowed agent kind.`
+        );
+      }
+      const isCandidate = args.purpose === "candidate";
+      if (isCandidate) {
+        if (!isKrakenSelectionEnabled()) {
+          return typedErr(
+            "task: purpose=candidate requires ZELARI_KRAKEN_SELECTION=1 (alpha feature). Spawn a plain explore tentacle instead."
+          );
+        }
+        if (agent !== "explore") {
+          return typedErr(
+            "task: purpose=candidate forces agent=explore (candidates are read-only in v1 \u2014 zero candidate implementations, ADR-0020)."
+          );
+        }
+        const slot = reserveCandidateSlot();
+        if ("error" in slot) return typedErr(slot.error);
+        candidateSlot = slot.index;
+      }
       const thoroughness = args.thoroughness ?? "medium";
       const sessionId2 = ctx.sessionId || "default";
       const parentCwd = ctx.cwd || process.cwd();
@@ -31483,8 +31966,51 @@ function createTaskTool(deps) {
         agent,
         thoroughness,
         parentCwd,
-        sessionId: sessionId2
+        sessionId: sessionId2,
+        // Fase 1 (ADR-0020): propagate the parent turn's cancellation signal
+        // so cancel/timeout unwinds the tentacle instead of letting it run on.
+        ...ctx.signal ? { signal: ctx.signal } : {},
+        ...isCandidate ? {
+          systemPromptOverride: systemPromptForAgent("explore") + "\n\n" + candidateInstructions(candidateSlot)
+        } : {}
       });
+      if (isCandidate) {
+        recordCandidateTokens(res.ok ? res.usage?.totalTokens ?? 0 : 0);
+        if (res.ok) {
+          const parsed = parseCandidateReport(res.result);
+          registerCandidate(
+            parsed.ok ? {
+              status: "ok",
+              index: candidateSlot,
+              description: args.description,
+              report: parsed.report,
+              raw: res.result
+            } : {
+              status: "malformed",
+              index: candidateSlot,
+              description: args.description,
+              error: parsed.error,
+              raw: res.result
+            }
+          );
+        } else {
+          registerCandidate({
+            status: "malformed",
+            index: candidateSlot,
+            description: args.description,
+            error: res.error,
+            raw: ""
+          });
+        }
+      }
+      if (agent === "verify") {
+        const required2 = krakenRequiredChecks();
+        if (required2.length > 0) {
+          setKrakenCheckResults(
+            res.ok ? parseVerifyReport(res.result, required2) : allUnknownCheckResults(required2, `verify tentacle failed: ${res.error}`)
+          );
+        }
+      }
       if (!res.ok) return typedErr(res.error);
       return typedOk({
         result: `[sub-agent:${res.agent}/${res.thoroughness} model=${res.model}]
@@ -31494,7 +32020,7 @@ ${res.result}${res.footer}`,
     }
   };
 }
-var EXPLORE_PROMPT, GENERAL_PROMPT, VERIFY_PROMPT, TaskArgsSchema;
+var EXPLORE_PROMPT, GENERAL_PROMPT, VERIFY_PROMPT, TaskArgsSchema, TaskPurposeSchema, TaskArgsWithPurposeSchema;
 var init_taskTool = __esm({
   "src/cli/tools/taskTool.ts"() {
     "use strict";
@@ -31503,6 +32029,9 @@ var init_taskTool = __esm({
     init_krakenRadio();
     init_krakenWorktree();
     init_krakenLive();
+    init_candidateRegistry();
+    init_verifyReport();
+    init_metrics2();
     EXPLORE_PROMPT = [
       "You are a focused EXPLORE tentacle of Kraken (parent super-agent).",
       "READ-ONLY tools only (read, list, grep, fetch). No edits, no shell.",
@@ -31528,7 +32057,16 @@ var init_taskTool = __esm({
       "You may read files and run test/build commands via bash. Prefer",
       "targeted checks over full suite when possible.",
       "Report: pass/fail, commands run, key output, and gaps vs Acceptance criteria.",
-      "If Acceptance criteria are listed, check each one explicitly."
+      "If Acceptance criteria are listed, check each one explicitly.",
+      "End your final message with ONE <verify-report> block per acceptance",
+      "criterion (required checks included), in this exact shape:",
+      "<verify-report>",
+      "check: <criterion text as given>",
+      "status: pass | fail | unknown",
+      "note: <one line of evidence (command + outcome)>",
+      "</verify-report>",
+      "Use status=unknown when you could NOT determine the outcome (degraded",
+      "tool, timeout, inconclusive evidence) \u2014 never guess pass."
     ].join("\n");
     TaskArgsSchema = external_exports.object({
       description: external_exports.string().min(1).describe("A 3-6 word label for the sub-task (for logs/UI)."),
@@ -31546,6 +32084,336 @@ var init_taskTool = __esm({
         "Optional acceptance checklist (contract). Appended to the prompt as Acceptance criteria."
       )
     });
+    TaskPurposeSchema = external_exports.enum(["candidate"]).optional().describe(
+      "Mark this explore tentacle as one CANDIDATE hypothesis (alpha: requires ZELARI_KRAKEN_SELECTION=1). Forces agent=explore, structured report."
+    );
+    TaskArgsWithPurposeSchema = TaskArgsSchema.extend({
+      purpose: TaskPurposeSchema
+    });
+  }
+});
+
+// src/cli/kraken/verifier.ts
+function resolveKrakenVerifier(parent, env = process.env, explicit) {
+  if (explicit?.provider?.trim() && explicit?.model?.trim()) {
+    return { provider: explicit.provider.trim(), model: explicit.model.trim() };
+  }
+  const envProvider = env.ZELARI_KRAKEN_SELECT_PROVIDER?.trim();
+  const envModel = env.ZELARI_KRAKEN_SELECT_MODEL?.trim();
+  if (envProvider && envModel) return { provider: envProvider, model: envModel };
+  if (envModel) return { provider: parent.provider, model: envModel };
+  return { provider: parent.provider, model: parent.model };
+}
+function renderCandidate(entry) {
+  if (entry.status === "malformed") {
+    return [
+      `## Candidate #${entry.index} \u2014 UNUSABLE (malformed report: ${entry.error})`,
+      "This candidate cannot win; it is listed for completeness."
+    ].join("\n");
+  }
+  const lines = [`## Candidate #${entry.index} \u2014 ${entry.report.hypothesis || "(no hypothesis stated)"}`];
+  if (entry.report.evidence.length === 0) {
+    lines.push("Evidence: NONE (unsupported hypothesis)");
+  } else {
+    lines.push("Evidence:");
+    for (const e of entry.report.evidence) {
+      const tag = e.degraded ? "DEGRADED \u2014 inconclusive, NOT proof of absence" : "OK";
+      lines.push(`- [${tag}] ${e.claim}${e.basis ? ` (basis: ${e.basis})` : ""}`);
+    }
+  }
+  if (entry.report.risks.length > 0) {
+    lines.push("Risks:");
+    for (const r of entry.report.risks) lines.push(`- ${r}`);
+  }
+  return lines.join("\n");
+}
+function buildSelectionPrompt(task, candidates) {
+  return [
+    "TASK",
+    task || "(the current user task \u2014 judge against the candidates below)",
+    "",
+    "CANDIDATES (read-only explorer reports):",
+    ...candidates.map(renderCandidate),
+    "",
+    "Decide which candidate is best supported by the evidence above."
+  ].join("\n");
+}
+function needsMoreEvidence(rationale, fallbackReason) {
+  return {
+    status: "needs_more_evidence",
+    winnerIndex: null,
+    rationale,
+    requiredChecks: [],
+    degraded: true,
+    ...fallbackReason ? { fallbackReason } : {},
+    verifier: null,
+    judgedBy: "deterministic"
+  };
+}
+function parseSelectionVerdict(raw, candidates) {
+  const open = raw.lastIndexOf(VERDICT_OPEN);
+  const close = raw.lastIndexOf(VERDICT_CLOSE);
+  if (open === -1 || close === -1 || close < open) {
+    return { ok: false, error: "missing verdict block" };
+  }
+  const body = raw.slice(open + VERDICT_OPEN.length, close).trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (err) {
+    return { ok: false, error: `invalid JSON (${err instanceof Error ? err.message : String(err)})` };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { ok: false, error: "verdict is not a JSON object" };
+  }
+  const obj = parsed;
+  const status = obj.status;
+  if (status !== "selected" && status !== "needs_more_evidence") {
+    return { ok: false, error: `invalid status (${String(status)})` };
+  }
+  const rationale = typeof obj.rationale === "string" ? obj.rationale.trim() : "";
+  const requiredChecks = (Array.isArray(obj.requiredChecks) ? obj.requiredChecks : []).filter((c) => typeof c === "string" && c.trim().length > 0).map((c) => c.trim()).slice(0, 5);
+  if (status === "needs_more_evidence") {
+    return {
+      ok: true,
+      verdict: {
+        status,
+        winnerIndex: null,
+        rationale: rationale || "Candidates are not sufficiently differentiated by evidence.",
+        requiredChecks,
+        degraded: false,
+        verifier: null,
+        judgedBy: "llm"
+      }
+    };
+  }
+  const winner = obj.winnerIndex;
+  if (typeof winner !== "number" || !Number.isInteger(winner)) {
+    return { ok: false, error: `selected without integer winnerIndex (${String(winner)})` };
+  }
+  const entry = candidates.find((c) => c.index === winner);
+  if (!entry || entry.status !== "ok") {
+    return { ok: false, error: `winnerIndex ${winner} does not point at a usable candidate` };
+  }
+  return {
+    ok: true,
+    verdict: {
+      status: "selected",
+      winnerIndex: winner,
+      rationale: rationale || "Selected by evidence comparison.",
+      requiredChecks,
+      degraded: false,
+      verifier: null,
+      judgedBy: "llm"
+    }
+  };
+}
+async function runKrakenSelection(opts) {
+  const okEntries = opts.candidates.filter(
+    (c) => c.status === "ok"
+  );
+  if (okEntries.length === 0) {
+    return needsMoreEvidence(
+      "No usable candidate reports this turn (all malformed). Proceed with your own judgment.",
+      "no usable candidates"
+    );
+  }
+  if (okEntries.length === 1) {
+    return {
+      status: "selected",
+      winnerIndex: okEntries[0].index,
+      rationale: "Single usable candidate this turn \u2014 selected without a comparison call.",
+      requiredChecks: [],
+      degraded: false,
+      verifier: null,
+      judgedBy: "deterministic"
+    };
+  }
+  const system = VERIFIER_SYSTEM_PROMPT;
+  const user = buildSelectionPrompt(opts.task, opts.candidates);
+  let raw;
+  try {
+    raw = await opts.callModel({ system, user, identity: opts.identity });
+  } catch (err) {
+    return needsMoreEvidence(
+      `Verifier call failed (${err instanceof Error ? err.message : String(err)}). Proceed with your own judgment.`,
+      "verifier call failed"
+    );
+  }
+  const parsed = parseSelectionVerdict(raw, opts.candidates);
+  if (!parsed.ok) {
+    return needsMoreEvidence(
+      `Verifier response unusable (${parsed.error}). Proceed with your own judgment.`,
+      `malformed verifier response: ${parsed.error}`
+    );
+  }
+  return { ...parsed.verdict, verifier: opts.identity };
+}
+var VERIFIER_SYSTEM_PROMPT, VERDICT_OPEN, VERDICT_CLOSE;
+var init_verifier = __esm({
+  "src/cli/kraken/verifier.ts"() {
+    "use strict";
+    VERIFIER_SYSTEM_PROMPT = [
+      "You are the Kraken selection verifier. You compare independent research",
+      "reports (candidates) about ONE task and decide which hypothesis is best",
+      "supported by OBSERVED EVIDENCE. You do not explore anything yourself \u2014",
+      "you judge what the candidates actually observed.",
+      "",
+      "RULES:",
+      "- Evidence decides. A specific observation (file:line, command output,",
+      "  test result) outweighs any amount of confident wording.",
+      "- An eloquent candidate with no observations must NOT beat a plainly",
+      "  worded candidate whose claims are grounded in evidence.",
+      "- Degraded observations (timeouts, empty searches, unavailable backends)",
+      "  are NOT proof of absence \u2014 never treat them as confirmation that",
+      "  something does not exist or cannot happen.",
+      "- A candidate CONTRADICTED by a concrete observation loses to one",
+      "  consistent with it. Weigh listed risks.",
+      "- If the leading candidates are equally (un)supported, answer",
+      "  needs_more_evidence \u2014 do not guess.",
+      "- requiredChecks: 0-5 concrete, runnable checks the implementation must",
+      "  pass to prove the winning hypothesis (test names, commands, behaviors).",
+      "",
+      "Answer with EXACTLY this block (valid JSON, no prose before/after):",
+      "<selection-verdict>",
+      "{",
+      '  "status": "selected" | "needs_more_evidence",',
+      '  "winnerIndex": <1-based index of the winning candidate, or null>,',
+      '  "rationale": "2-4 sentences grounded in the evidence",',
+      '  "requiredChecks": ["concrete check", "..."]',
+      "}",
+      "</selection-verdict>"
+    ].join("\n");
+    VERDICT_OPEN = "<selection-verdict>";
+    VERDICT_CLOSE = "</selection-verdict>";
+  }
+});
+
+// src/cli/tools/krakenSelectTool.ts
+async function collectProviderText(stream, params) {
+  let text = "";
+  let usage;
+  for await (const delta of stream(params)) {
+    if (delta.kind === "text") text += delta.delta;
+    else if (delta.kind === "usage") usage = delta.usage;
+    else if (delta.kind === "error") throw new Error(delta.message);
+    else if (delta.kind === "finish") break;
+  }
+  return { text, ...usage ? { usage } : {} };
+}
+function renderVerdict(verdict, candidateCount) {
+  const header = verdict.status === "selected" && verdict.winnerIndex !== null ? `kraken_select: SELECTED candidate #${verdict.winnerIndex}` : "kraken_select: NEEDS MORE EVIDENCE \u2014 no candidate clearly wins";
+  const lines = [header, `Rationale: ${verdict.rationale}`];
+  if (verdict.requiredChecks.length > 0) {
+    lines.push("Required checks (must pass before clean completion):");
+    verdict.requiredChecks.forEach((c, i) => lines.push(`  ${i + 1}. ${c}`));
+  }
+  if (verdict.degraded && verdict.fallbackReason) {
+    lines.push(
+      `NOTE (degraded): ${verdict.fallbackReason}. Proceed with your own judgment \u2014 the verifier could not decide.`
+    );
+  }
+  lines.push(`Candidates compared: ${candidateCount}.`);
+  return lines.join("\n");
+}
+function createKrakenSelectTool(deps) {
+  const timeoutMs = deps.timeoutMs ?? 12e4;
+  return {
+    name: "kraken_select",
+    description: "Compare the candidate research reports spawned this turn (task purpose=candidate) and select the hypothesis best supported by OBSERVED EVIDENCE. A dedicated verifier call (default: the current model) judges grounded vs unsupported claims; degraded observations are never treated as proof of absence. Returns the selected candidate, a rationale, and requiredChecks the implementation must pass. Call it ONCE per turn, after candidate tentacles finished and BEFORE implementing. If it reports needs_more_evidence, either spawn ONE more differentiated candidate or proceed with your own judgment.",
+    permissions: ["read", "network"],
+    timeoutMs: 3e5,
+    inputSchema: KrakenSelectArgsSchema,
+    execute: async (input, _ctx) => {
+      try {
+        const candidates = krakenCandidates();
+        if (candidates.length === 0) {
+          return typedOk({
+            result: "kraken_select: no candidates registered this turn \u2014 nothing to compare. Proceed directly (single-path execution)."
+          });
+        }
+        const parent = await deps.loadParentIdentity();
+        if (!parent) {
+          const verdict2 = {
+            status: "needs_more_evidence",
+            winnerIndex: null,
+            rationale: "Verifier unavailable (no provider identity for this run). Proceed with your own judgment.",
+            requiredChecks: [],
+            degraded: true,
+            fallbackReason: "parent identity unavailable",
+            verifier: null,
+            judgedBy: "deterministic"
+          };
+          setKrakenSelection(verdict2);
+          return typedOk({ result: renderVerdict(verdict2, candidates.length) });
+        }
+        const identity = resolveKrakenVerifier(
+          parent,
+          deps.env ?? process.env,
+          deps.loadVerifierOverride?.()
+        );
+        let judgingStartedAt = Date.now();
+        let judgingUsage;
+        let judgingLatencyMs = 0;
+        const verdict = await runKrakenSelection({
+          task: input.task ?? "",
+          candidates,
+          identity,
+          callModel: async ({ system, user, identity: id }) => {
+            const stream = await deps.loadStream(id.provider);
+            if (!stream) {
+              throw new Error(`no provider config for verifier "${id.provider}"`);
+            }
+            judgingStartedAt = Date.now();
+            try {
+              const { text: raw, usage } = await collectProviderText(stream, {
+                messages: [
+                  { role: "system", content: system },
+                  { role: "user", content: user }
+                ],
+                model: id.model,
+                provider: id.provider,
+                tools: [],
+                signal: AbortSignal.timeout(timeoutMs)
+              });
+              judgingUsage = usage;
+              if (raw.trim().length === 0) throw new Error("empty verifier response");
+              return raw;
+            } finally {
+              judgingLatencyMs = Date.now() - judgingStartedAt;
+            }
+          }
+        });
+        recordSelectionOutcome({
+          latencyMs: judgingLatencyMs,
+          ...judgingUsage ? { tokens: judgingUsage.totalTokens } : {},
+          degraded: verdict.degraded,
+          fallbackReason: verdict.fallbackReason
+        });
+        setKrakenSelection(verdict);
+        return typedOk({ result: renderVerdict(verdict, candidates.length) });
+      } catch (err) {
+        return typedErr(
+          `kraken_select: internal error \u2014 ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  };
+}
+var KrakenSelectArgsSchema;
+var init_krakenSelectTool = __esm({
+  "src/cli/tools/krakenSelectTool.ts"() {
+    "use strict";
+    init_zod();
+    init_metrics2();
+    init_toolTypes();
+    init_verifier();
+    init_candidateRegistry();
+    KrakenSelectArgsSchema = external_exports.object({
+      task: external_exports.string().optional().describe(
+        "The user task being solved, in one or two sentences. Used to judge which candidate hypothesis best serves it. Omit to judge against the candidates alone."
+      )
+    });
   }
 });
 
@@ -32270,13 +33138,13 @@ async function withPlanStore(projectRoot, fn) {
     return out;
   });
 }
-function nextPlanTaskId(store4) {
-  const maxExisting = store4.tasks.reduce((max, t) => {
+function nextPlanTaskId(store6) {
+  const maxExisting = store6.tasks.reduce((max, t) => {
     const m = /^t(\d+)$/.exec(t.id);
     return m ? Math.max(max, parseInt(m[1], 10)) : max;
   }, 0);
-  store4.counter = Math.max(store4.counter, maxExisting) + 1;
-  return `t${store4.counter}`;
+  store6.counter = Math.max(store6.counter, maxExisting) + 1;
+  return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
   const path56 = join15(rootDir, "plan-tasks", `${task.id}.md`);
@@ -32456,14 +33324,14 @@ function createPlanTaskTools(opts) {
     inputSchema: CreateSchema,
     execute: async (input) => {
       try {
-        const res = await withPlanStore(projectRoot, (store4) => {
-          if (store4.tasks.length >= PLAN_MAX_TASKS) {
+        const res = await withPlanStore(projectRoot, (store6) => {
+          if (store6.tasks.length >= PLAN_MAX_TASKS) {
             return typedErr(
-              `PLAN_TOO_MANY_TASKS: plan.json already holds ${store4.tasks.length} tasks (max ${PLAN_MAX_TASKS}).`
+              `PLAN_TOO_MANY_TASKS: plan.json already holds ${store6.tasks.length} tasks (max ${PLAN_MAX_TASKS}).`
             );
           }
           const now = (/* @__PURE__ */ new Date()).toISOString();
-          const id = nextPlanTaskId(store4);
+          const id = nextPlanTaskId(store6);
           const task = {
             id,
             title: input.title.trim().slice(0, PLAN_TITLE_MAX),
@@ -32477,8 +33345,8 @@ function createPlanTaskTools(opts) {
             createdAt: now,
             updatedAt: now
           };
-          store4.tasks.push(task);
-          writePlanTaskArtifact(store4.rootDir, task);
+          store6.tasks.push(task);
+          writePlanTaskArtifact(store6.rootDir, task);
           return typedOk({ id, task });
         });
         if (res.ok) {
@@ -32502,8 +33370,8 @@ function createPlanTaskTools(opts) {
     inputSchema: UpdateSchema,
     execute: async (input) => {
       try {
-        const res = await withPlanStore(projectRoot, (store4) => {
-          const task = store4.tasks.find((t) => t.id === input.id);
+        const res = await withPlanStore(projectRoot, (store6) => {
+          const task = store6.tasks.find((t) => t.id === input.id);
           if (!task) {
             return typedErr(
               `PLAN_TASK_NOT_FOUND: no task with id "${input.id}" in .zelari/plan.json (call task_list for current ids).`
@@ -32526,7 +33394,7 @@ ${input.appendNote}` : input.appendNote;
             task.notes = merged.slice(-PLAN_NOTES_MAX);
           }
           task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writePlanTaskArtifact(store4.rootDir, task);
+          writePlanTaskArtifact(store6.rootDir, task);
           return typedOk({ task });
         });
         if (res.ok) {
@@ -32551,21 +33419,21 @@ ${input.appendNote}` : input.appendNote;
     execute: async (input) => {
       try {
         let allPayloads = [];
-        const res = await withPlanStore(projectRoot, (store4) => {
-          allPayloads = store4.tasks.map(toTaskPayload);
-          const filtered = store4.tasks.filter(
+        const res = await withPlanStore(projectRoot, (store6) => {
+          allPayloads = store6.tasks.map(toTaskPayload);
+          const filtered = store6.tasks.filter(
             (t) => (input.status === void 0 || t.status === input.status) && (input.phaseId === void 0 || t.phaseId === input.phaseId)
           );
-          const done = store4.tasks.filter(
+          const done = store6.tasks.filter(
             (t) => t.status === "completed" || t.status === "cancelled"
           ).length;
           const formatted = filtered.length === 0 ? "(no matching workspace tasks)" : filtered.map(taskSummaryLine).join("\n");
           return typedOk({
             tasks: filtered,
-            total: store4.tasks.length,
+            total: store6.tasks.length,
             done,
             formatted: `${formatted}
-(done/total: ${done}/${store4.tasks.length})`
+(done/total: ${done}/${store6.tasks.length})`
           });
         });
         if (res.ok) {
@@ -35695,7 +36563,7 @@ import path31 from "node:path";
 function trustStorePath() {
   return _overrideStorePath ?? path31.join(homedir8(), ".zelari-code", "trust.json");
 }
-function normalize(p3) {
+function normalize3(p3) {
   const resolved = path31.resolve(p3);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
@@ -35709,11 +36577,11 @@ function readStore3() {
     return DEFAULT_STORE;
   }
 }
-function writeStore3(store4) {
+function writeStore3(store6) {
   const p3 = trustStorePath();
   try {
     mkdirSync14(path31.dirname(p3), { recursive: true });
-    writeFileSync16(p3, JSON.stringify(store4, null, 2), "utf8");
+    writeFileSync16(p3, JSON.stringify(store6, null, 2), "utf8");
   } catch (err) {
     throw new Error(
       `failed to persist trust store ${p3}: ${err instanceof Error ? err.message : String(err)}`
@@ -35732,26 +36600,26 @@ function isFolderTrusted(folderPath) {
   const env = envTrustedFolder();
   if (env === "all") return true;
   if (env === "none") return false;
-  if (env) return normalize(env) === normalize(folderPath);
-  const target = normalize(folderPath);
-  return readStore3().folders.some((f) => normalize(f.path) === target);
+  if (env) return normalize3(env) === normalize3(folderPath);
+  const target = normalize3(folderPath);
+  return readStore3().folders.some((f) => normalize3(f.path) === target);
 }
 function trustFolder(folderPath) {
-  const store4 = readStore3();
+  const store6 = readStore3();
   const normalized = path31.resolve(folderPath);
-  if (!store4.folders.some((f) => normalize(f.path) === normalize(normalized))) {
-    store4.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
-    writeStore3(store4);
+  if (!store6.folders.some((f) => normalize3(f.path) === normalize3(normalized))) {
+    store6.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    writeStore3(store6);
   }
   return { ok: true, path: normalized };
 }
 function untrustFolder(folderPath) {
-  const store4 = readStore3();
-  const target = normalize(folderPath);
-  const before = store4.folders.length;
-  store4.folders = store4.folders.filter((f) => normalize(f.path) !== target);
-  if (store4.folders.length === before) return { ok: true, removed: false };
-  writeStore3(store4);
+  const store6 = readStore3();
+  const target = normalize3(folderPath);
+  const before = store6.folders.length;
+  store6.folders = store6.folders.filter((f) => normalize3(f.path) !== target);
+  if (store6.folders.length === before) return { ok: true, removed: false };
+  writeStore3(store6);
   return { ok: true, removed: true };
 }
 function listTrustedFolders() {
@@ -35906,19 +36774,19 @@ function applyTruncation(result, toolName) {
 function evictOldest() {
   let oldestKey = null;
   let oldestTs = Infinity;
-  for (const [key, entry] of store2) {
+  for (const [key, entry] of store4) {
     if (entry.ts < oldestTs) {
       oldestTs = entry.ts;
       oldestKey = key;
     }
   }
-  if (oldestKey) store2.delete(oldestKey);
+  if (oldestKey) store4.delete(oldestKey);
 }
 function cacheGet(key, now) {
-  const entry = store2.get(key);
+  const entry = store4.get(key);
   if (!entry) return null;
   if (entry.expiresAt !== void 0 && entry.expiresAt <= now) {
-    store2.delete(key);
+    store4.delete(key);
     return null;
   }
   return cloneResult(entry.result) ?? entry.result;
@@ -35928,8 +36796,8 @@ function cachePut(key, result, now, ttlMs) {
   if (resultBytes(result) > TOOL_CACHE_MAX_BYTES) return;
   const cloned = cloneResult(result);
   if (!cloned) return;
-  if (store2.size >= TOOL_CACHE_MAX_ENTRIES && !store2.has(key)) evictOldest();
-  store2.set(key, {
+  if (store4.size >= TOOL_CACHE_MAX_ENTRIES && !store4.has(key)) evictOldest();
+  store4.set(key, {
     result: cloned,
     ts: now,
     ...ttlMs !== void 0 ? { expiresAt: now + ttlMs } : {}
@@ -35973,7 +36841,7 @@ function withResultCache(tool, options = {}) {
     }
   };
 }
-var TOOL_CACHE_MAX_ENTRIES, TOOL_CACHE_MAX_BYTES, TOOL_CACHE_DEFAULT_TTL_MS, store2;
+var TOOL_CACHE_MAX_ENTRIES, TOOL_CACHE_MAX_BYTES, TOOL_CACHE_DEFAULT_TTL_MS, store4;
 var init_toolResultCache = __esm({
   "src/cli/toolResultCache.ts"() {
     "use strict";
@@ -35981,7 +36849,7 @@ var init_toolResultCache = __esm({
     TOOL_CACHE_MAX_ENTRIES = 200;
     TOOL_CACHE_MAX_BYTES = 256 * 1024;
     TOOL_CACHE_DEFAULT_TTL_MS = 5 * 60 * 1e3;
-    store2 = /* @__PURE__ */ new Map();
+    store4 = /* @__PURE__ */ new Map();
   }
 });
 
@@ -36252,11 +37120,20 @@ function createBuiltinToolRegistry(options = {}) {
       });
     }
   }
-  const enableTask = options.enableTask !== false && !readOnly && !verifyMode && profile === "full" && !options.planMode;
+  const enableTask = options.enableTask !== false && options.readOnly !== true && !verifyMode && profile === "full" && (!options.planMode || options.planExploreTask !== false);
   if (enableTask) {
-    const taskTool = createTaskTool({
-      createSubAgentContext: createKrakenSubAgentContextFactory({ root, audit, sessionId: sessionId2 })
-    });
+    const taskTool = createTaskTool(
+      {
+        createSubAgentContext: createKrakenSubAgentContextFactory({
+          root,
+          audit,
+          sessionId: sessionId2,
+          ...options.subAgentProvider ? { provider: options.subAgentProvider } : {},
+          ...options.subAgentModel ? { model: options.subAgentModel } : {}
+        })
+      },
+      options.planMode === true ? { allowedAgents: ["explore"] } : void 0
+    );
     registry4.register(withPerm(taskTool));
     tools.push({
       name: taskTool.name,
@@ -36264,6 +37141,31 @@ function createBuiltinToolRegistry(options = {}) {
       permissions: taskTool.permissions ?? []
     });
   }
+  if (options.krakenSelect === true && enableTask) {
+    const selectTool = createKrakenSelectTool({
+      loadParentIdentity: async () => {
+        const cfg = options.subAgentProvider ? await providerConfigFor(options.subAgentProvider) : await providerFromEnv();
+        if (!cfg) return null;
+        return {
+          provider: cfg.providerId,
+          model: options.subAgentModel || cfg.model
+        };
+      },
+      loadStream: async (provider) => {
+        const cfg = await providerConfigFor(provider);
+        return cfg ? buildProviderStream(cfg) : null;
+      },
+      // Fase 9 (ADR-0020): persisted verifier override (provider.json
+      // `krakenVerifier`). undefined = inherit the EXACT parent model.
+      loadVerifierOverride: () => getKrakenVerifierOverride()
+    });
+    registry4.register(withPerm(selectTool));
+    tools.push({
+      name: selectTool.name,
+      description: selectTool.description,
+      permissions: selectTool.permissions ?? []
+    });
+  }
   if (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) {
@@ -36546,6 +37448,7 @@ var init_toolRegistry = __esm({
     init_auditLogger();
     init_engine();
     init_taskTool();
+    init_krakenSelectTool();
     init_askUser();
     init_skillTool();
     init_todoTools();
@@ -36562,6 +37465,7 @@ var init_toolRegistry = __esm({
     init_worldModel();
     init_openai_compatible();
     init_resolveStream();
+    init_providerConfig();
     init_toolPermissions();
     init_lifecycleHooks();
     init_toolResultCache();
@@ -36626,10 +37530,10 @@ function isStateEnabled(env = process.env) {
 }
 async function getStateStore(projectRoot, env = process.env) {
   if (!isStateEnabled(env)) return new NoopDurableStateStore();
-  const store4 = new FileDurableStateStore();
+  const store6 = new FileDurableStateStore();
   try {
-    await store4.init(projectRoot);
-    return store4;
+    await store6.init(projectRoot);
+    return store6;
   } catch {
     return new NoopDurableStateStore();
   }
@@ -37278,24 +38182,24 @@ var init_historyCompaction = __esm({
 
 // src/cli/budget/requestSnapshotStore.ts
 function recordRequestSnapshot(sessionId2, snapshot) {
-  store3.set(sessionId2, { snapshot });
+  store5.set(sessionId2, { snapshot });
 }
 function recordRequestUsage(sessionId2, usage) {
-  const entry = store3.get(sessionId2);
+  const entry = store5.get(sessionId2);
   if (!entry) return;
   entry.usage = usage;
 }
 function getRequestSnapshotWithUsage(sessionId2) {
-  return store3.get(sessionId2) ?? null;
+  return store5.get(sessionId2) ?? null;
 }
 function clearAllRequestSnapshots() {
-  store3.clear();
+  store5.clear();
 }
-var store3;
+var store5;
 var init_requestSnapshotStore = __esm({
   "src/cli/budget/requestSnapshotStore.ts"() {
     "use strict";
-    store3 = /* @__PURE__ */ new Map();
+    store5 = /* @__PURE__ */ new Map();
   }
 });
 
@@ -38442,8 +39346,8 @@ async function loadDurableContext(projectRoot, opts) {
     return cache2.text;
   }
   try {
-    const store4 = await getStateStore(projectRoot, env);
-    const text = await store4.materializeContext(void 0, opts?.maxChars);
+    const store6 = await getStateStore(projectRoot, env);
+    const text = await store6.materializeContext(void 0, opts?.maxChars);
     cache2 = { text: text || "", at: now, projectRoot };
     return cache2.text;
   } catch {
@@ -41251,7 +42155,7 @@ __export(commitHelpers_exports, {
 });
 async function tryStateCommit(args) {
   try {
-    const store4 = args.store ?? await getStateStore(args.projectRoot, args.env);
+    const store6 = args.store ?? await getStateStore(args.projectRoot, args.env);
     let workspaceCheckpointId = args.workspaceCheckpointId;
     if (!workspaceCheckpointId && args.withCheckpoint && (args.env ?? process.env).ZELARI_CHECKPOINT !== "0") {
       const cp = await createCheckpoint(
@@ -41260,7 +42164,7 @@ async function tryStateCommit(args) {
       );
       if (cp.ok) workspaceCheckpointId = cp.value.id;
     }
-    const meta3 = await store4.commit({
+    const meta3 = await store6.commit({
       mode: args.mode,
       label: args.label,
       layer: args.layer,
@@ -46010,6 +46914,9 @@ function parseSetConfigFlags(argv) {
   let endpoint;
   let thinking;
   let endpointClear = false;
+  let verifierProvider;
+  let verifierModel;
+  let verifierClear = false;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--provider") {
@@ -46026,12 +46933,20 @@ function parseSetConfigFlags(argv) {
       i++;
     } else if (arg === "--endpoint-clear") {
       endpointClear = true;
+    } else if (arg === "--verifier-provider") {
+      verifierProvider = argv[i + 1];
+      i++;
+    } else if (arg === "--verifier-model") {
+      verifierModel = argv[i + 1];
+      i++;
+    } else if (arg === "--verifier-clear") {
+      verifierClear = true;
     }
   }
-  if (!provider && !model && !endpoint && !endpointClear && !thinking) {
+  if (!provider && !model && !endpoint && !endpointClear && !thinking && !verifierProvider && !verifierModel && !verifierClear) {
     return {
       request: null,
-      error: "--set-config requires --provider, --model, --endpoint, --thinking, and/or --endpoint-clear"
+      error: "--set-config requires --provider, --model, --endpoint, --thinking, --verifier-provider + --verifier-model, --verifier-clear, and/or --endpoint-clear"
     };
   }
   if (provider !== void 0 && provider.trim().length === 0) {
@@ -46043,6 +46958,18 @@ function parseSetConfigFlags(argv) {
   if (endpoint !== void 0 && endpoint.trim().length === 0) {
     return { request: null, error: "--endpoint cannot be empty" };
   }
+  if (verifierClear && (verifierProvider || verifierModel)) {
+    return { request: null, error: "--verifier-clear conflicts with --verifier-provider/--verifier-model" };
+  }
+  if (verifierProvider !== void 0 && verifierModel === void 0 || verifierProvider === void 0 && verifierModel !== void 0) {
+    return { request: null, error: "--verifier-provider and --verifier-model must be used together" };
+  }
+  if (verifierProvider !== void 0 && verifierProvider.trim().length === 0) {
+    return { request: null, error: "--verifier-provider cannot be empty" };
+  }
+  if (verifierModel !== void 0 && verifierModel.trim().length === 0) {
+    return { request: null, error: "--verifier-model cannot be empty" };
+  }
   if (endpoint && endpointClear) {
     return { request: null, error: "--endpoint and --endpoint-clear conflict" };
   }
@@ -46055,7 +46982,10 @@ function parseSetConfigFlags(argv) {
       model: model?.trim(),
       endpoint: endpoint?.trim(),
       endpointClear: endpointClear || void 0,
-      thinking: thinking?.trim().toLowerCase()
+      thinking: thinking?.trim().toLowerCase(),
+      verifierProvider: verifierProvider?.trim(),
+      verifierModel: verifierModel?.trim(),
+      verifierClear: verifierClear || void 0
     }
   };
 }
@@ -46144,6 +47074,7 @@ function buildDesktopConfigSnapshot() {
     activeProviderId: config2.activeProviderId,
     modelByProvider: { ...config2.modelByProvider },
     providers,
+    krakenVerifier: config2.krakenVerifier ?? null,
     cliVersion: getCurrentVersion(),
     configPaths: {
       provider: getProviderConfigPath(),
@@ -46182,11 +47113,25 @@ function applySetConfig(req) {
     if (req.thinking) {
       setThinkingForProvider(targetProvider, parseThinkingSpec(req.thinking));
     }
+    if (req.verifierClear) {
+      clearKrakenVerifier();
+    }
+    if (req.verifierProvider && req.verifierModel) {
+      const existsV = PROVIDERS.some((p3) => p3.id === req.verifierProvider);
+      if (!existsV) {
+        return {
+          ok: false,
+          error: `unknown verifier provider '${req.verifierProvider}'. Available: ${PROVIDERS.map((p3) => p3.id).join(", ")}`
+        };
+      }
+      setKrakenVerifier(req.verifierProvider, req.verifierModel);
+    }
     const after = getProviderConfig();
+    const vf = after.krakenVerifier;
     const ep = getCustomEndpoint(after.activeProviderId);
     return {
       ok: true,
-      message: `activeProvider=${after.activeProviderId} model=${after.modelByProvider[after.activeProviderId]}` + (ep ? ` endpoint=${ep}` : "")
+      message: `activeProvider=${after.activeProviderId} model=${after.modelByProvider[after.activeProviderId]}` + (ep ? ` endpoint=${ep}` : "") + (vf ? ` verifier=${vf.provider}/${vf.model}` : " verifier=inherit")
     };
   } catch (err) {
     return {
@@ -51290,7 +52235,180 @@ init_shellResolver();
 init_keyStore();
 init_providerConfig();
 init_toolRegistry();
+
+// src/cli/kraken/turnRuntime.ts
+init_events2();
+var WRITE_TOOLS3 = /* @__PURE__ */ new Set([
+  "write_file",
+  "edit_file",
+  "apply_diff"
+]);
+var KrakenTurnRuntime = class {
+  mode;
+  sessionId;
+  onProgress;
+  now;
+  loadCheckTotal;
+  loadChecksPassed;
+  phase = "understanding";
+  phaseEnteredAt;
+  tentacles = 0;
+  exploreTentacles = 0;
+  verifyTentacles = 0;
+  writes = 0;
+  inFlightTentacles = 0;
+  /** Required checks registered via kraken_select (Fase 6). */
+  checkTotal;
+  /** Required checks explicitly PASSED (Fase 7; undefined until first report). */
+  checksPassed;
+  /** toolCallId → toolName (end events omit the name). */
+  pendingTools = /* @__PURE__ */ new Map();
+  /** toolCallIds of VERIFY tentacles (Fase 7 refresh trigger). */
+  pendingVerifyIds = /* @__PURE__ */ new Set();
+  started = false;
+  constructor(opts) {
+    this.mode = opts.mode;
+    this.sessionId = opts.sessionId;
+    this.onProgress = opts.onProgress;
+    this.now = opts.now ?? Date.now;
+    this.loadCheckTotal = opts.loadCheckTotal;
+    this.loadChecksPassed = opts.loadChecksPassed;
+    this.phaseEnteredAt = this.now();
+  }
+  /** Start the turn: emits the initial `understanding` event. */
+  beginTurn() {
+    this.started = true;
+    this.emit();
+  }
+  /**
+   * Reset the phase machine for a recovery pass of the SAME turn (headless
+   * BUILD write-retry). Counters are kept — they describe the whole turn.
+   *
+   * Fase 8 (ADR-0020): `beginPass(true)` marks an automatic REPAIR pass
+   * (completion gate) and projects `repairing` instead of restarting at
+   * `understanding`, so the UI shows the fix loop rather than a fresh turn.
+   */
+  beginPass(repair = false) {
+    this.transition(repair ? "repairing" : "understanding");
+  }
+  /**
+   * Terminal transition. `completed` is only projected on a clean finish —
+   * cancellations and errors are already carried by the `agent_end` event.
+   */
+  finish(reason) {
+    if (reason === "completed") this.transition("completed");
+  }
+  /** Feed one parent-turn BrainEvent. Never throws. */
+  observe(event) {
+    try {
+      if (event.type === "tool_execution_start") {
+        if (event.toolCallId && event.toolName) {
+          this.pendingTools.set(event.toolCallId, event.toolName);
+        }
+        if (event.toolName === "kraken_select") {
+          this.transition("selecting");
+          return;
+        }
+        if (event.toolName === "task") {
+          this.tentacles++;
+          this.inFlightTentacles++;
+          const agent = typeof event.args?.agent === "string" ? event.args.agent : "explore";
+          if (agent === "verify") {
+            this.verifyTentacles++;
+            if (event.toolCallId) this.pendingVerifyIds.add(event.toolCallId);
+          } else this.exploreTentacles++;
+          this.transition(agent === "verify" ? "verifying" : "exploring");
+        }
+        return;
+      }
+      if (event.type === "tool_execution_end") {
+        const name = this.pendingTools.get(event.toolCallId);
+        this.pendingTools.delete(event.toolCallId);
+        if (name === "task") {
+          const wasVerify = event.toolCallId ? this.pendingVerifyIds.delete(event.toolCallId) : false;
+          this.inFlightTentacles = Math.max(0, this.inFlightTentacles - 1);
+          let checksChanged = false;
+          if (wasVerify && this.loadChecksPassed) {
+            const passed = this.loadChecksPassed();
+            if (passed !== void 0 && passed !== this.checksPassed) {
+              this.checksPassed = passed;
+              checksChanged = true;
+            }
+          }
+          if (this.inFlightTentacles === 0) {
+            if (this.mode === "plan") this.transition("planning");
+            else if (this.writes > 0) this.transition("implementing");
+            else if (checksChanged) this.emit();
+          } else if (checksChanged) {
+            this.emit();
+          }
+          return;
+        }
+        if (name === "kraken_select") {
+          const total = this.loadCheckTotal?.() ?? 0;
+          if (total > 0 && total !== this.checkTotal) {
+            this.checkTotal = total;
+            this.emit();
+          }
+          return;
+        }
+        if (name && WRITE_TOOLS3.has(name) && !event.isError) {
+          this.writes++;
+          if (this.mode === "build") this.transition("implementing");
+        }
+        return;
+      }
+    } catch {
+    }
+  }
+  /** Current progress payload (counters + phase). */
+  snapshot() {
+    return {
+      phase: this.phase,
+      mode: this.mode,
+      tentacles: this.tentacles,
+      exploreTentacles: this.exploreTentacles,
+      verifyTentacles: this.verifyTentacles,
+      writes: this.writes,
+      phaseEnteredAt: this.phaseEnteredAt,
+      ...this.checkTotal !== void 0 ? { checkTotal: this.checkTotal } : {},
+      ...this.checksPassed !== void 0 ? { checksPassed: this.checksPassed } : {}
+    };
+  }
+  transition(next) {
+    if (this.phase === next) return;
+    this.phase = next;
+    this.phaseEnteredAt = this.now();
+    this.emit();
+  }
+  emit() {
+    if (!this.started) return;
+    try {
+      this.onProgress(
+        createBrainEvent("kraken_progress", this.sessionId, {
+          progress: this.snapshot()
+        })
+      );
+    } catch {
+    }
+  }
+};
+
+// src/cli/hooks/useChatTurn.ts
 init_taskTool();
+init_candidateRegistry();
+init_metrics2();
+
+// src/cli/kraken/selectionPlaybook.ts
+init_skills2();
+init_candidateRegistry();
+function krakenSelectionPlaybook(include) {
+  if (!include || !isKrakenSelectionEnabled()) return [];
+  return [KRAKEN_SELECTION_PLAYBOOK_MODULE];
+}
+
+// src/cli/hooks/useChatTurn.ts
+init_completionGate();
 
 // src/cli/hooks/permissionPicker.ts
 init_toolPermissions();
@@ -51645,6 +52763,8 @@ function useChatTurn(params) {
   const dispatchPrompt = useCallback2(
     async (userText, opts) => {
       resetTaskSpawnCount();
+      resetKrakenCandidates();
+      resetKrakenTurnMetrics();
       let envConfig;
       let harness;
       let historySeedLen = 0;
@@ -51728,10 +52848,30 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
         }) : void 0;
         const { registry: toolRegistry } = createBuiltinToolRegistry({
           planMode: workPhase === "plan",
+          // Fase 1 (ADR-0020): anchor tentacles to THIS turn's resolved
+          // provider/model so the TUI selection governs sub-agents too.
+          ...envConfig ? {
+            subAgentProvider: envConfig.providerId,
+            subAgentModel: envConfig.model,
+            // Fase 4 (ADR-0020): kraken_select rides the same alpha
+            // flag as candidate spawning (default off = unchanged).
+            krakenSelect: isKrakenSelectionEnabled()
+          } : {},
           onAskUser,
           onPermissionAsk,
           permissionPolicy: defaultPermissionPolicy()
         });
+        const progressRuntime = new KrakenTurnRuntime({
+          mode: workPhase === "plan" ? "plan" : "build",
+          sessionId: sessionId2,
+          loadCheckTotal: () => krakenRequiredChecks().length,
+          loadChecksPassed: () => krakenChecksPassed(),
+          onProgress: (ev) => {
+            if (writerRef.current) void writerRef.current.append(ev);
+            if (sessionId2) ingestLiveEvent(sessionId2, ev);
+          }
+        });
+        progressRuntime.beginTurn();
         const baseProviderStream = localCliProvider ?? buildProviderStream(envConfig);
         let providerStream;
         if (localCliProvider) {
@@ -51922,6 +53062,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
               customPromptModules: [
                 KRAKEN_IDENTITY_MODULE,
                 KRAKEN_LEAD_PLAYBOOK_MODULE,
+                ...krakenSelectionPlaybook(true),
                 languageModule
               ],
               agentSkillConfigs: []
@@ -51990,6 +53131,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
         harnessRef.current = harness2;
         setQueueCount(harness2.queueLength);
         let assistantContent = "";
+        let krakenRepairEnqueued = false;
         let streamContent = "";
         const streamScrub = createStreamScrubber(16);
         const toolNameById = /* @__PURE__ */ new Map();
@@ -51998,6 +53140,29 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
         let realUsage = null;
         try {
           for await (const event of harness2.run()) {
+            progressRuntime.observe(event);
+            if (event.type === "agent_end") {
+              let krakenSuppressFinish = false;
+              if (event.reason === "completed" && !krakenRepairEnqueued && isKrakenSelectionEnabled() && workPhase === "build") {
+                const krakenGate = evaluateKrakenCompletionGate("build");
+                if (krakenGate.blocked) {
+                  krakenRepairEnqueued = true;
+                  markRepairTriggered();
+                  harness2.enqueue(buildKrakenRepairPrompt(krakenGate));
+                  appendSystem(
+                    setMessages,
+                    `[kraken] required checks unresolved (${krakenGate.passed}/${krakenGate.total} passed) \u2014 automatic repair pass`,
+                    Date.now()
+                  );
+                  progressRuntime.beginPass(true);
+                  krakenSuppressFinish = true;
+                }
+              }
+              if (event.reason === "completed" && krakenRepairEnqueued && !evaluateKrakenCompletionGate("build").blocked) {
+                markRepairSucceeded();
+              }
+              if (!krakenSuppressFinish) progressRuntime.finish(event.reason);
+            }
             if (event.type === "message_end") {
               if (event.usage) realUsage = event.usage;
               if (event.usage) {
@@ -52170,6 +53335,14 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
               }
             }
           }
+          const turnMetrics = collectKrakenTurnMetrics();
+          if (turnMetrics) {
+            const metricsEvent = createBrainEvent("kraken_metrics", sessionId2, {
+              metrics: turnMetrics
+            });
+            if (writerRef.current) void writerRef.current.append(metricsEvent);
+            if (sessionId2) ingestLiveEvent(sessionId2, metricsEvent);
+          }
           turnSucceeded = true;
         } finally {
           flushStreaming();
@@ -54167,12 +55340,12 @@ init_fileStateStore();
 async function restoreDurableState(opts) {
   const restoreTree = opts.restoreTree !== false;
   try {
-    const store4 = opts.store ?? await getStateStore(opts.projectRoot);
+    const store6 = opts.store ?? await getStateStore(opts.projectRoot);
     let meta3;
     if (opts.commitId) {
-      meta3 = await store4.setHead(opts.commitId);
+      meta3 = await store6.setHead(opts.commitId);
     } else {
-      meta3 = await store4.head();
+      meta3 = await store6.head();
       if (!meta3) {
         return {
           ok: false,
@@ -54225,8 +55398,8 @@ function ago2(ms) {
   return `${Math.round(s / 3600)}h ago`;
 }
 async function handleStateStatus(ctx) {
-  const store4 = await getStateStore(ctx.cwd);
-  const head = await store4.head();
+  const store6 = await getStateStore(ctx.cwd);
+  const head = await store6.head();
   if (!head) {
     appendSystem(
       ctx.setMessages,
@@ -54234,9 +55407,9 @@ async function handleStateStatus(ctx) {
     );
     return;
   }
-  const discoveries = await store4.loadDiscoveries(head.id);
+  const discoveries = await store6.loadDiscoveries(head.id);
   const reusable = discoveries.filter((d) => d.reusable).length;
-  const recent = await store4.list(8);
+  const recent = await store6.list(8);
   const lines = recent.map((c, i) => {
     const ver2 = c.verification.ran ? c.verification.ok ? "ok" : "fail" : "n/a";
     return `  ${i === 0 ? "\u2192" : " "} ${c.id}  ${ago2(c.createdAt)}  ${c.label}  ver=${ver2}` + (c.layer ? `  [${c.layer}]` : "") + (c.stablePromptHash ? `  hash=${c.stablePromptHash.slice(0, 8)}` : "");
@@ -54255,9 +55428,9 @@ async function handleStateStatus(ctx) {
   );
 }
 async function handleStateCommit(ctx, label) {
-  const store4 = await getStateStore(ctx.cwd);
+  const store6 = await getStateStore(ctx.cwd);
   try {
-    const meta3 = await store4.commit({
+    const meta3 = await store6.commit({
       mode: "agent",
       label: label?.trim() || "manual state commit",
       layer: "manual",
@@ -54284,8 +55457,8 @@ async function handleStateCommit(ctx, label) {
   }
 }
 async function handleStateShow(ctx, id) {
-  const store4 = await getStateStore(ctx.cwd);
-  const meta3 = id ? await store4.get(id) : await store4.head();
+  const store6 = await getStateStore(ctx.cwd);
+  const meta3 = id ? await store6.get(id) : await store6.head();
   if (!meta3) {
     appendSystem(
       ctx.setMessages,
@@ -54293,7 +55466,7 @@ async function handleStateShow(ctx, id) {
     );
     return;
   }
-  const text = await store4.materializeContext(meta3.id, 6e3);
+  const text = await store6.materializeContext(meta3.id, 6e3);
   appendSystem(ctx.setMessages, `[state] show ${meta3.id}
 ${text}`);
 }
@@ -55803,14 +56976,14 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
 }
 function handleCouncilFeedback(ctx, memberId, score, note) {
   try {
-    const store4 = new FeedbackStore();
-    const entry = store4.record({
+    const store6 = new FeedbackStore();
+    const entry = store6.record({
       memberId,
       score,
       ...note ? { note } : {},
       ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
     });
-    const stats = store4.getStats(memberId);
+    const stats = store6.getStats(memberId);
     appendSystem(
       ctx.setMessages,
       `[council-feedback] ${memberId} rated ${entry.score}/5 \u2014 running avg ${stats.avg.toFixed(2)} over ${stats.count} rating(s).`
@@ -57502,9 +58675,13 @@ function emitEvent(event) {
 // src/cli/runHeadless.ts
 init_harness();
 init_dist();
+init_events2();
 init_conversationContext();
 init_council();
 init_toolRegistry();
+init_candidateRegistry();
+init_metrics2();
+init_completionGate();
 init_claudeProvider();
 init_skills2();
 init_envNumber();
@@ -57861,8 +59038,18 @@ async function registerHeadlessMcp(toolRegistry, opts) {
 }
 async function runHeadlessSingle(opts, provider, model, providerStream) {
   const sessionId2 = crypto.randomUUID();
+  resetKrakenCandidates();
+  resetKrakenTurnMetrics();
   const { registry: toolRegistry } = createBuiltinToolRegistry({
     planMode: planModeFromOpts(opts),
+    // Fase 1 (ADR-0020): anchor tentacles to the provider/model THIS run
+    // resolved (--provider/--model opts or Desktop's selector), mirroring
+    // what the kraken-graph path already does for its executor.
+    subAgentProvider: provider,
+    subAgentModel: model,
+    // Fase 4 (ADR-0020): kraken_select on the parent registry for kraken
+    // runs with the alpha selection flag on (default off = unchanged).
+    krakenSelect: opts.mode === "kraken" && isKrakenSelectionEnabled(),
     // ADR-0018 3b: upgrade plan-task domain events to first-class NDJSON
     // BrainEvents. Rust envelopes every stdout line with runId/conversationId,
     // so task events ride the same multiplexed channel as the rest.
@@ -57971,6 +59158,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
           customPromptModules: [
             KRAKEN_IDENTITY_MODULE,
             KRAKEN_LEAD_PLAYBOOK_MODULE,
+            ...krakenSelectionPlaybook(opts.mode === "kraken"),
             {
               type: "language-policy",
               title: "Response Language",
@@ -58035,6 +59223,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     const scrub = createStreamScrubber2();
     try {
       for await (const event of harness.run()) {
+        progressRuntime.observe(event);
         if (event.type === "message_start") {
           scrub.reset();
         }
@@ -58112,6 +59301,16 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       messages: harness.getMessages()
     };
   }
+  const progressRuntime = new KrakenTurnRuntime({
+    mode: planModeFromOpts(opts) ? "plan" : "build",
+    sessionId: sessionId2,
+    loadCheckTotal: () => krakenRequiredChecks().length,
+    loadChecksPassed: () => krakenChecksPassed(),
+    onProgress: (ev) => {
+      if (opts.output === "json") emitEvent(ev);
+    }
+  });
+  progressRuntime.beginTurn();
   const initialMessages = [
     ...systemMessages,
     ...historySeed,
@@ -58148,6 +59347,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       ...retryMessages,
       { role: "user", content: retryPrompt }
     ];
+    progressRuntime.beginPass();
     const retry = await runSinglePass(withSystem, `${sessionId2}-write-retry`);
     pass = {
       ...retry,
@@ -58156,6 +59356,42 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       emittedWrites: pass.emittedWrites + retry.emittedWrites
     };
   }
+  if (pass.finalReason === "completed" && pass.exitCode === 0 && opts.mode === "kraken" && isKrakenSelectionEnabled() && !planModeFromOpts(opts)) {
+    const gate = evaluateKrakenCompletionGate("build");
+    if (gate.blocked) {
+      const repairPrompt = buildKrakenRepairPrompt(gate);
+      if (opts.output === "json") {
+        emitEvent({
+          type: "log",
+          message: `[headless] Kraken BUILD: ${gate.failedChecks.length} failed / ${gate.unknownChecks.length} unknown required checks \u2014 forcing repair pass`
+        });
+      } else {
+        process.stderr.write(
+          "[zelari-code --headless] Kraken BUILD: required checks unresolved \u2014 forcing repair pass\n"
+        );
+      }
+      const withSystem = [
+        ...systemMessages,
+        ...pass.messages.filter((m) => m.role !== "system"),
+        { role: "user", content: repairPrompt }
+      ];
+      progressRuntime.beginPass(true);
+      markRepairTriggered();
+      const repair = await runSinglePass(withSystem, `${sessionId2}-check-repair`);
+      pass = {
+        ...repair,
+        textBuffer: [...pass.textBuffer, ...repair.textBuffer],
+        successfulWrites: pass.successfulWrites + repair.successfulWrites,
+        emittedWrites: pass.emittedWrites + repair.emittedWrites
+      };
+      if (!evaluateKrakenCompletionGate("build").blocked) markRepairSucceeded();
+    }
+  }
+  progressRuntime.finish(pass.finalReason);
+  const turnMetrics = collectKrakenTurnMetrics();
+  if (turnMetrics && opts.output === "json") {
+    emitEvent(createBrainEvent("kraken_metrics", sessionId2, { metrics: turnMetrics }));
+  }
   if (opts.output === "plain" && pass.textBuffer.length > 0) {
     process.stdout.write(pass.textBuffer.join(""));
   }