zelari-code 2.33.1 → 2.34.1

package/dist/cli/main.bundled.js

@@ -28372,6 +28372,136 @@ var init_textLoopDetect = __esm({
   }
 });
 
+// packages/core/dist/agents/council/outputCleaning.js
+function extractBalancedJsonObject(s) {
+  const start = s.indexOf("{");
+  if (start < 0)
+    return null;
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (inString) {
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{")
+      depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0)
+        return s.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+function parseClarificationRequest(text) {
+  const start = text.indexOf(QUESTION_MARKER);
+  if (start < 0)
+    return null;
+  const rest = text.slice(start + QUESTION_MARKER.length);
+  const end = rest.indexOf(QUESTION_END_MARKER);
+  const block = end >= 0 ? rest.slice(0, end) : rest;
+  const cleaned = block.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+  const jsonText = extractBalancedJsonObject(cleaned) ?? (() => {
+    const objStart = cleaned.indexOf("{");
+    const objEnd = cleaned.lastIndexOf("}");
+    return objStart >= 0 && objEnd > objStart ? cleaned.slice(objStart, objEnd + 1) : cleaned;
+  })();
+  try {
+    const parsed = JSON.parse(jsonText);
+    if (typeof parsed.question !== "string" || !parsed.question.trim())
+      return null;
+    return {
+      question: parsed.question.trim(),
+      choices: Array.isArray(parsed.choices) ? parsed.choices.filter((c) => typeof c === "string" && c.trim().length > 0).map((c) => c.trim()) : void 0,
+      context: typeof parsed.context === "string" ? parsed.context.trim() : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function hasInteractiveClarification(text) {
+  const c = parseClarificationRequest(text);
+  return !!(c && c.choices && c.choices.length >= 2);
+}
+function stripQuestionBlocks(text) {
+  let out = "";
+  let rest = text;
+  while (true) {
+    const start = rest.indexOf(QUESTION_MARKER);
+    if (start < 0) {
+      out += rest;
+      break;
+    }
+    out += rest.slice(0, start);
+    const afterMarker = rest.slice(start + QUESTION_MARKER.length);
+    const trimmed = afterMarker.replace(/^\s+/, "");
+    if (!trimmed.startsWith("{")) {
+      out += QUESTION_MARKER;
+      rest = afterMarker;
+      continue;
+    }
+    const endIdx = afterMarker.indexOf(QUESTION_END_MARKER);
+    if (endIdx >= 0) {
+      rest = afterMarker.slice(endIdx + QUESTION_END_MARKER.length);
+      continue;
+    }
+    const json3 = extractBalancedJsonObject(trimmed);
+    if (json3) {
+      const jsonAt = afterMarker.indexOf(json3);
+      rest = afterMarker.slice(jsonAt + json3.length);
+      continue;
+    }
+    break;
+  }
+  return out.replace(/\n{3,}/g, "\n\n").trim();
+}
+function parseThinking(text) {
+  const complete = text.match(/<think(?:ing)?>([\s\S]*?)<\/think(?:ing)?>/i);
+  if (complete)
+    return complete[1].trim();
+  const open2 = text.match(/<think(?:ing)?>([\s\S]*)$/i);
+  return open2 ? open2[1].trim() : "";
+}
+function cleanAgentContent(text, opts = {}) {
+  const stripQuestion = opts.stripQuestion !== false;
+  const stripThink = opts.stripThink !== false;
+  let out = text;
+  if (stripThink) {
+    out = out.replace(/<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/gi, "").replace(/<think(?:ing)?>[\s\S]*$/gi, "").replace(/<\/think(?:ing)?>/gi, "");
+  }
+  out = out.replace(/<minimax:tool_call>[\s\S]*?<\/minimax:tool_call>/gi, "").replace(/<\/?minimax:tool_call>/gi, "").replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, "").replace(/<\/?tool_call>/gi, "").replace(/<function_call>[\s\S]*?<\/function_call>/gi, "").replace(/<\/?function_call>/gi, "").replace(/<invoke\b[^>]*>[\s\S]*?<\/invoke>/gi, "").replace(/<\/invoke>/gi, "").replace(/<parameter\b[^>]*>[\s\S]*?<\/parameter>/gi, "").replace(/<\/parameter>/gi, "").replace(/\]\s*<\]\s*minimax\s*\[>\s*\[?<invoke\b[^>]*>[\s\S]*?<\/invoke>/gi, "").replace(/<minimax:tool_call>[\s\S]*$/gi, "").replace(/<tool_call>[\s\S]*$/gi, "").replace(/<function_call>[\s\S]*$/gi, "").replace(/<invoke\b[^>]*>[\s\S]*$/gi, "").replace(/\]\s*<\]\s*minimax\s*\[>[\s\S]*$/gi, "").replace(/^\s*\]\s*<\]\s*minimax\s*\[>.*$/gim, "").replace(/^\s*<\/?(?:tool_call|function_call|invoke|parameter|minimax:tool_call)\b[^>]*>\s*$/gim, "");
+  if (stripQuestion) {
+    out = stripQuestionBlocks(out);
+  }
+  out = out.replace(/\n{3,}/g, "\n\n").trim();
+  return scrubProprietaryLeak(out);
+}
+var QUESTION_MARKER, QUESTION_END_MARKER;
+var init_outputCleaning = __esm({
+  "packages/core/dist/agents/council/outputCleaning.js"() {
+    "use strict";
+    init_secrecyPolicy();
+    QUESTION_MARKER = "---QUESTION---";
+    QUESTION_END_MARKER = "---END---";
+  }
+});
+
 // packages/core/dist/core/AgentHarness.js
 function gateAdvice(hardLimit) {
   return hardLimit ? "Finalize now with the evidence already collected; no further tool calls will run this turn." : "Prioritize verification/repair actions (test, typecheck, build, read failures) or finalize honestly.";
@@ -28668,6 +28798,7 @@ var init_AgentHarness = __esm({
     init_requestSnapshot();
     init_textLoopDetect();
     init_ObserverBus();
+    init_outputCleaning();
     init_textLoopDetect();
     TOOL_CALL_TRUNCATED_RECOVERY_MARKER = "[harness] Previous tool call was truncated";
     TOOL_CALL_TRUNCATED_RECOVERY_USER = `${TOOL_CALL_TRUNCATED_RECOVERY_MARKER} by the provider before completion (finish_reason=tool_calls but no complete tool_call arrived). Retry with a shorter payload or split the work into smaller tool calls.`;
@@ -29562,7 +29693,7 @@ ${cached2}`
                 }
                 pendingNativeTools.length = 0;
               }
-              const clarificationPause = /---QUESTION---/.test(turnText) && /"choices"\s*:\s*\[/.test(turnText);
+              const clarificationPause = hasInteractiveClarification(turnText);
               if (clarificationPause) {
                 finishRef.value = "stop";
                 finishRef.clarificationRequested = true;
@@ -30994,31 +31125,6 @@ You are the sole implementer this run. Advisors already analyzed \u2014 implemen
   }
 });
 
-// packages/core/dist/council/modeBanners.js
-function councilModeBanner(runMode, opts) {
-  if (runMode === "design-phase")
-    return DESIGN_PHASE_MODE_BANNER;
-  if (opts?.isImplementer === true)
-    return IMPLEMENTATION_IMPLEMENTER_BANNER;
-  if (opts?.isImplementer === false)
-    return IMPLEMENTATION_ADVISOR_BANNER;
-  return IMPLEMENTATION_MODE_BANNER;
-}
-var DESIGN_PHASE_MODE_BANNER, IMPLEMENTATION_MODE_BANNER, IMPLEMENTATION_IMPLEMENTER_BANNER, IMPLEMENTATION_ADVISOR_BANNER;
-var init_modeBanners = __esm({
-  "packages/core/dist/council/modeBanners.js"() {
-    "use strict";
-    DESIGN_PHASE_MODE_BANNER = `COUNCIL RUN MODE: design-phase.
-Workspace tool emissions described in your role prompt are MANDATORY in this run \u2014 prose alone does not count as a deliverable. Persist artifacts via the workspace tools listed in your AVAILABLE TOOLS section.`;
-    IMPLEMENTATION_MODE_BANNER = `COUNCIL RUN MODE: implementation.
-Prefer write_file, edit_file, and bash for code changes. Design-phase mandatory workspace blocks in your role prompt are INACTIVE \u2014 .zelari/docs and draft plans are hypotheses, not product law. Ground work in the real source tree. Only call workspace tools when they add durable project value.`;
-    IMPLEMENTATION_IMPLEMENTER_BANNER = `COUNCIL RUN MODE: implementation \u2014 you are the IMPLEMENTER.
-You are the only member that writes code this run. Implement the solution with write_file / edit_file and verify with bash. Reconcile specialists' analysis and Minosse's critique into working, verified changes. Design vault (.zelari/docs, draft plans) is HYPOTHESIS only \u2014 product truth is the source tree. Design-phase mandatory workspace blocks are INACTIVE.`;
-    IMPLEMENTATION_ADVISOR_BANNER = `COUNCIL RUN MODE: implementation \u2014 you are an ADVISOR.
-Do NOT write or edit project files (not via write_file/edit_file, and not via bash) \u2014 Lucifero is the sole implementer. Inspect the real codebase (read_file, grep_content, list_files). Treat prior design prose and .zelari/docs as hypotheses. Flag contradictions with package.json / the tree. Design-phase mandatory workspace blocks are INACTIVE.`;
-  }
-});
-
 // packages/core/dist/council/runMode.js
 function resolveCouncilRunMode(input) {
   if (input.forceMode) {
@@ -31880,54 +31986,6 @@ var init_microGate = __esm({
   }
 });
 
-// packages/core/dist/council/verification/completion.js
-function isVerifyToolCheckSkipped() {
-  return process.env.ZELARI_VERIFY_SKIP_TOOL === "1";
-}
-function checkImplementationCompletion(emittedToolNames) {
-  if (isVerifyToolCheckSkipped()) {
-    return { ok: true, missing: [] };
-  }
-  let lastWriteIdx = -1;
-  for (let i = 0; i < emittedToolNames.length; i++) {
-    if (WRITE_TOOLS.has(emittedToolNames[i])) {
-      lastWriteIdx = i;
-    }
-  }
-  if (lastWriteIdx === -1) {
-    return { ok: true, missing: [] };
-  }
-  const afterWrite = emittedToolNames.slice(lastWriteIdx + 1);
-  if (afterWrite.some((t) => VERIFY_TOOLS.has(t))) {
-    return { ok: true, missing: [] };
-  }
-  return {
-    ok: false,
-    missing: ["grep_content"],
-    reason: "No grep_content or bash after last write_file/edit_file"
-  };
-}
-function resolveVerifyRetryTool(executableTools) {
-  if (!executableTools)
-    return "grep_content";
-  if (executableTools.has("grep_content"))
-    return "grep_content";
-  if (executableTools.has("bash"))
-    return "bash";
-  return null;
-}
-function buildImplementationVerifyRetryPrompt(toolName) {
-  return `You wrote files but did not run ${toolName} or bash to verify them. Call ${toolName} NOW on your changed HTML (search @keyframes, transition, classList.add). No prose.`;
-}
-var WRITE_TOOLS, VERIFY_TOOLS;
-var init_completion = __esm({
-  "packages/core/dist/council/verification/completion.js"() {
-    "use strict";
-    WRITE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file"]);
-    VERIFY_TOOLS = /* @__PURE__ */ new Set(["grep_content", "bash"]);
-  }
-});
-
 // packages/core/dist/council/scope/extractTaskScope.js
 function normalizePath(p3) {
   return p3.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -32178,13 +32236,13 @@ ${hints.map((h) => `- ${h}`).join("\n")}
 ` : "") + `Use read_file then edit_file on the listed files. No verification table \u2014 tool calls only.`;
 }
 function countEmittedWriteTools(emittedToolNames) {
-  return emittedToolNames.filter((t) => WRITE_TOOLS2.has(t)).length;
+  return emittedToolNames.filter((t) => WRITE_TOOLS.has(t)).length;
 }
-var WRITE_TOOLS2, IMPLEMENTATION_WRITE_REQUIREMENTS;
+var WRITE_TOOLS, IMPLEMENTATION_WRITE_REQUIREMENTS;
 var init_implementationDelivery = __esm({
   "packages/core/dist/council/verification/implementationDelivery.js"() {
     "use strict";
-    WRITE_TOOLS2 = /* @__PURE__ */ new Set(["write_file", "edit_file"]);
+    WRITE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file"]);
     IMPLEMENTATION_WRITE_REQUIREMENTS = [
       { name: "write_file", min: 1 },
       { name: "edit_file", min: 1 }
@@ -32192,6 +32250,191 @@ var init_implementationDelivery = __esm({
   }
 });
 
+// packages/core/dist/agents/council/types.js
+var NON_RETRY_AGENTS;
+var init_types7 = __esm({
+  "packages/core/dist/agents/council/types.js"() {
+    "use strict";
+    NON_RETRY_AGENTS = /* @__PURE__ */ new Set([]);
+  }
+});
+
+// packages/core/dist/agents/council/cancel.js
+function isCouncilCancelled(signal) {
+  return signal?.aborted === true;
+}
+function bindHarnessAbort(harness, signal) {
+  if (!signal)
+    return () => void 0;
+  if (signal.aborted) {
+    harness.cancel();
+    return () => void 0;
+  }
+  const onAbort = () => {
+    harness.cancel();
+  };
+  signal.addEventListener("abort", onAbort);
+  return () => {
+    signal.removeEventListener("abort", onAbort);
+  };
+}
+async function* runHarnessWithAbort(harness, signal) {
+  const unbind = bindHarnessAbort(harness, signal);
+  try {
+    yield* harness.run();
+  } finally {
+    unbind();
+  }
+}
+var init_cancel = __esm({
+  "packages/core/dist/agents/council/cancel.js"() {
+    "use strict";
+  }
+});
+
+// packages/core/dist/council/modeBanners.js
+function councilModeBanner(runMode, opts) {
+  if (runMode === "design-phase")
+    return DESIGN_PHASE_MODE_BANNER;
+  if (opts?.isImplementer === true)
+    return IMPLEMENTATION_IMPLEMENTER_BANNER;
+  if (opts?.isImplementer === false)
+    return IMPLEMENTATION_ADVISOR_BANNER;
+  return IMPLEMENTATION_MODE_BANNER;
+}
+var DESIGN_PHASE_MODE_BANNER, IMPLEMENTATION_MODE_BANNER, IMPLEMENTATION_IMPLEMENTER_BANNER, IMPLEMENTATION_ADVISOR_BANNER;
+var init_modeBanners = __esm({
+  "packages/core/dist/council/modeBanners.js"() {
+    "use strict";
+    DESIGN_PHASE_MODE_BANNER = `COUNCIL RUN MODE: design-phase.
+Workspace tool emissions described in your role prompt are MANDATORY in this run \u2014 prose alone does not count as a deliverable. Persist artifacts via the workspace tools listed in your AVAILABLE TOOLS section.`;
+    IMPLEMENTATION_MODE_BANNER = `COUNCIL RUN MODE: implementation.
+Prefer write_file, edit_file, and bash for code changes. Design-phase mandatory workspace blocks in your role prompt are INACTIVE \u2014 .zelari/docs and draft plans are hypotheses, not product law. Ground work in the real source tree. Only call workspace tools when they add durable project value.`;
+    IMPLEMENTATION_IMPLEMENTER_BANNER = `COUNCIL RUN MODE: implementation \u2014 you are the IMPLEMENTER.
+You are the only member that writes code this run. Implement the solution with write_file / edit_file and verify with bash. Reconcile specialists' analysis and Minosse's critique into working, verified changes. Design vault (.zelari/docs, draft plans) is HYPOTHESIS only \u2014 product truth is the source tree. Design-phase mandatory workspace blocks are INACTIVE.`;
+    IMPLEMENTATION_ADVISOR_BANNER = `COUNCIL RUN MODE: implementation \u2014 you are an ADVISOR.
+Do NOT write or edit project files (not via write_file/edit_file, and not via bash) \u2014 Lucifero is the sole implementer. Inspect the real codebase (read_file, grep_content, list_files). Treat prior design prose and .zelari/docs as hypotheses. Flag contradictions with package.json / the tree. Design-phase mandatory workspace blocks are INACTIVE.`;
+  }
+});
+
+// packages/core/dist/agents/council/memberMessages.js
+function restrictImplementationWrites(toolNames, opts) {
+  if (opts.runMode !== "implementation" || opts.isImplementer)
+    return toolNames;
+  return toolNames.filter((t) => !MUTATING_PROJECT_TOOLS.includes(t));
+}
+function buildAgentMessages(agent, userMessage, ragContext, workspaceContext, priorOutputs, aiConfig, executableTools, runMode = "implementation", languageModule) {
+  const allToolNames = computeAgentTools(agent, aiConfig);
+  const toolNames = executableTools ? allToolNames.filter((n) => executableTools.has(n)) : allToolNames;
+  const mergedAiConfig = languageModule ? {
+    enabledSkills: aiConfig?.enabledSkills ?? [],
+    enabledTools: aiConfig?.enabledTools ?? [],
+    agentSkillConfigs: aiConfig?.agentSkillConfigs ?? [],
+    customSkills: aiConfig?.customSkills,
+    customPromptModules: [
+      ...aiConfig?.customPromptModules ?? [],
+      languageModule
+    ]
+  } : aiConfig;
+  const modeAwareAgent = {
+    ...agent,
+    systemPrompt: resolveRoleSystemPrompt(agent, runMode)
+  };
+  const split = buildSystemPromptSplit(modeAwareAgent, {
+    tools: getAllTools(),
+    toolNames,
+    aiConfig: mergedAiConfig,
+    workspaceContext,
+    ragContext,
+    mode: "council",
+    includeWorkspaceInPrompt: true
+  });
+  const messages = [
+    { role: "system", content: split.stable }
+  ];
+  if (split.volatile.trim()) {
+    messages.push({ role: "system", content: split.volatile });
+  }
+  messages.push({ role: "system", content: councilModeBanner(runMode, { isImplementer: agent.id === "lucifer" }) }, { role: "system", content: "IMPORTANT: Before making any tool calls or expensive operations, check if the information already exists in the shared context from previous agents. Avoid redundant work." });
+  if (priorOutputs.length > 0) {
+    const MAX_PRIOR_CHARS = 2800;
+    const summary = priorOutputs.map((o) => {
+      const body = o.content.length > MAX_PRIOR_CHARS ? `${o.content.slice(0, MAX_PRIOR_CHARS)}
+\u2026 [truncated ${o.content.length}\u2192${MAX_PRIOR_CHARS} chars; treat as hypothesis]` : o.content;
+      return `[${o.name} - ${o.role}]: ${body}`;
+    }).join("\n\n");
+    messages.push({
+      role: "user",
+      content: `Previous council members have said (hypotheses \u2014 prefer product files on disk if they conflict):
+${summary}
+
+Original user request: ${userMessage}`
+    });
+  } else {
+    messages.push({ role: "user", content: userMessage });
+  }
+  return messages;
+}
+var MUTATING_PROJECT_TOOLS;
+var init_memberMessages = __esm({
+  "packages/core/dist/agents/council/memberMessages.js"() {
+    "use strict";
+    init_roles();
+    init_systemPromptBuilder();
+    init_tools();
+    init_modeBanners();
+    MUTATING_PROJECT_TOOLS = ["write_file", "edit_file"];
+  }
+});
+
+// packages/core/dist/council/verification/completion.js
+function isVerifyToolCheckSkipped() {
+  return process.env.ZELARI_VERIFY_SKIP_TOOL === "1";
+}
+function checkImplementationCompletion(emittedToolNames) {
+  if (isVerifyToolCheckSkipped()) {
+    return { ok: true, missing: [] };
+  }
+  let lastWriteIdx = -1;
+  for (let i = 0; i < emittedToolNames.length; i++) {
+    if (WRITE_TOOLS2.has(emittedToolNames[i])) {
+      lastWriteIdx = i;
+    }
+  }
+  if (lastWriteIdx === -1) {
+    return { ok: true, missing: [] };
+  }
+  const afterWrite = emittedToolNames.slice(lastWriteIdx + 1);
+  if (afterWrite.some((t) => VERIFY_TOOLS.has(t))) {
+    return { ok: true, missing: [] };
+  }
+  return {
+    ok: false,
+    missing: ["grep_content"],
+    reason: "No grep_content or bash after last write_file/edit_file"
+  };
+}
+function resolveVerifyRetryTool(executableTools) {
+  if (!executableTools)
+    return "grep_content";
+  if (executableTools.has("grep_content"))
+    return "grep_content";
+  if (executableTools.has("bash"))
+    return "bash";
+  return null;
+}
+function buildImplementationVerifyRetryPrompt(toolName) {
+  return `You wrote files but did not run ${toolName} or bash to verify them. Call ${toolName} NOW on your changed HTML (search @keyframes, transition, classList.add). No prose.`;
+}
+var WRITE_TOOLS2, VERIFY_TOOLS;
+var init_completion = __esm({
+  "packages/core/dist/council/verification/completion.js"() {
+    "use strict";
+    WRITE_TOOLS2 = /* @__PURE__ */ new Set(["write_file", "edit_file"]);
+    VERIFY_TOOLS = /* @__PURE__ */ new Set(["grep_content", "bash"]);
+  }
+});
+
 // packages/core/dist/council/verification/inlineJsAutofix.js
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
 import { join as join7 } from "node:path";
@@ -32272,153 +32515,518 @@ var init_inlineJsAutofix = __esm({
   }
 });
 
-// packages/core/dist/agents/councilApi.js
-import { existsSync as existsSync12 } from "node:fs";
-import { join as join8 } from "node:path";
-function extractBalancedJsonObject(s) {
-  const start = s.indexOf("{");
-  if (start < 0)
-    return null;
-  let depth = 0;
-  let inString = false;
-  let escape = false;
-  for (let i = start; i < s.length; i++) {
-    const ch = s[i];
-    if (inString) {
-      if (escape) {
-        escape = false;
-        continue;
-      }
-      if (ch === "\\") {
-        escape = true;
-        continue;
-      }
-      if (ch === '"')
-        inString = false;
-      continue;
+// packages/core/dist/agents/council/toolEmission.js
+function checkMemberToolEmissions(_memberId, emittedToolNames, requirements) {
+  if (requirements.length === 0) {
+    return { ok: true, missing: [] };
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const name of emittedToolNames) {
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  const missing = [];
+  for (const req of requirements) {
+    const got = counts.get(req.name) ?? 0;
+    if (got < req.min) {
+      missing.push(`${req.name} (got ${got}, need >= ${req.min})`);
     }
-    if (ch === '"') {
-      inString = true;
-      continue;
+  }
+  return { ok: missing.length === 0, missing };
+}
+function checkMemberToolEmissionSets(memberId, emittedToolNames, sets) {
+  if (sets.length === 0) {
+    return { ok: true, missing: [] };
+  }
+  const results = sets.map((set2) => checkMemberToolEmissions(memberId, emittedToolNames, set2));
+  if (results.some((r) => r.ok)) {
+    return { ok: true, missing: [] };
+  }
+  return results[0];
+}
+function enforceDesignPhaseToolEmissions(memberId, emittedToolNames) {
+  const sets = DESIGN_PHASE_REQUIREMENT_SETS[memberId];
+  if (!sets || sets.length === 0) {
+    return { ok: true, missing: [] };
+  }
+  const result = checkMemberToolEmissionSets(memberId, emittedToolNames, sets);
+  if (!result.ok) {
+    console.warn(`[council] member "${memberId}" did not emit required tools: ${result.missing.join(", ")}. The downstream .zelari/ deliverable may be incomplete. (A forced retry turn scoped to the missing tools follows; the deterministic complete-design fallback covers any remaining gap.)`);
+  }
+  return result;
+}
+var DESIGN_PHASE_REQUIREMENT_SETS, DESIGN_PHASE_REQUIREMENTS;
+var init_toolEmission = __esm({
+  "packages/core/dist/agents/council/toolEmission.js"() {
+    "use strict";
+    DESIGN_PHASE_REQUIREMENT_SETS = {
+      nettun: [
+        [{ name: "createPlan", min: 1 }],
+        [
+          { name: "createPhase", min: 3 },
+          { name: "createTask", min: 6 },
+          { name: "createMilestone", min: 1 }
+        ]
+      ],
+      geryon: [
+        [{ name: "createDocument", min: 3 }]
+      ],
+      pluton: [
+        [{ name: "createDocument", min: 1 }]
+      ],
+      minos: [
+        [{ name: "createDocument", min: 1 }]
+      ],
+      lucifer: [
+        [{ name: "createDocument", min: 1 }]
+      ]
+    };
+    DESIGN_PHASE_REQUIREMENTS = Object.fromEntries(Object.entries(DESIGN_PHASE_REQUIREMENT_SETS).map(([id3, sets]) => [id3, sets[0]]));
+  }
+});
+
+// packages/core/dist/agents/council/retryTurn.js
+function shouldRetryMember(missingToolNames, attemptsSoFar) {
+  if (missingToolNames.length === 0)
+    return false;
+  if (attemptsSoFar >= MAX_RETRY_PER_MEMBER)
+    return false;
+  return true;
+}
+function buildRetryPrompt(missingToolNames) {
+  const names = missingToolNames.join(", ");
+  return `You did not emit the required workspace tools: ${names}. Call ${names} NOW with concrete arguments. No prose. No search.`;
+}
+async function* runRetryTurnForMember(args) {
+  if (isCouncilCancelled(args.signal))
+    return [];
+  const executableMissing = args.executableTools ? args.missingToolNames.filter((n) => args.executableTools.has(n)) : args.missingToolNames;
+  if (executableMissing.length === 0) {
+    return [];
+  }
+  const retryToolNames = executableMissing;
+  const retryToolSpecs = getProviderTools(retryToolNames).map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    parameters: t.function.parameters
+  }));
+  const baseMessages = buildAgentMessages(args.agent, args.userMessage, args.ragContext, args.workspaceContext, args.priorOutputs, args.aiConfig, args.executableTools, args.runMode ?? "implementation", args.languageModule);
+  const retryMessages = [
+    ...baseMessages,
+    {
+      role: "user",
+      content: args.retryPrompt ?? buildRetryPrompt(executableMissing)
     }
-    if (ch === "{")
-      depth++;
-    else if (ch === "}") {
-      depth--;
-      if (depth === 0)
-        return s.slice(start, i + 1);
+  ];
+  const maxToolCalls = args.minPerTool !== void 0 ? Object.entries(args.minPerTool).filter(([name]) => executableMissing.includes(name)).reduce((sum, [, min]) => sum + min, 0) : retryToolNames.length;
+  const retryHarness = new AgentHarness({
+    model: args.effectiveModel,
+    provider: args.effectiveProvider,
+    sessionId: args.sessionId,
+    messages: retryMessages,
+    tools: retryToolSpecs,
+    eventBus: args.eventBus,
+    toolRegistry: args.toolRegistry,
+    // Budget the retry so the model can satisfy every requirement in
+    // ONE tool_calls turn. For createTask min:12 this needs 12 calls.
+    maxToolCallsPerTurn: maxToolCalls,
+    memberId: args.agent.id,
+    memberName: args.agent.name,
+    providerStream: (params) => args.providerStream(params)
+  });
+  const retryEmitted = [];
+  for await (const event of runHarnessWithAbort(retryHarness, args.signal)) {
+    if (event.type === "tool_execution_start") {
+      retryEmitted.push(event.toolName);
     }
+    yield event;
   }
-  return null;
+  return retryEmitted;
 }
-function parseClarificationRequest(text) {
-  const start = text.indexOf(QUESTION_MARKER);
-  if (start < 0)
-    return null;
-  const rest = text.slice(start + QUESTION_MARKER.length);
-  const end = rest.indexOf(QUESTION_END_MARKER);
-  const block = end >= 0 ? rest.slice(0, end) : rest;
-  const cleaned = block.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-  const jsonText = extractBalancedJsonObject(cleaned) ?? (() => {
-    const objStart = cleaned.indexOf("{");
-    const objEnd = cleaned.lastIndexOf("}");
-    return objStart >= 0 && objEnd > objStart ? cleaned.slice(objStart, objEnd + 1) : cleaned;
-  })();
+async function* applyRetryIfMissing(args) {
+  if (isCouncilCancelled(args.config.signal))
+    return;
+  if (args.check.ok)
+    return;
+  const missingToolNames = args.check.missing.map((m) => m.split(" ")[0]);
+  if (!shouldRetryMember(missingToolNames, 0))
+    return;
+  console.warn(`[council] ${args.agent.id} retrying missing tools: ${missingToolNames.join(", ")}`);
+  const minPerTool = {};
+  if (args.requirements) {
+    for (const req of args.requirements) {
+      if (missingToolNames.includes(req.name)) {
+        minPerTool[req.name] = req.min;
+      }
+    }
+  }
   try {
-    const parsed = JSON.parse(jsonText);
-    if (typeof parsed.question !== "string" || !parsed.question.trim())
-      return null;
-    return {
-      question: parsed.question.trim(),
-      choices: Array.isArray(parsed.choices) ? parsed.choices.filter((c) => typeof c === "string" && c.trim().length > 0).map((c) => c.trim()) : void 0,
-      context: typeof parsed.context === "string" ? parsed.context.trim() : void 0
-    };
-  } catch {
-    return null;
+    const retryGenerator = runRetryTurnForMember({
+      agent: args.agent,
+      missingToolNames,
+      minPerTool,
+      executableTools: args.executableNames,
+      userMessage: args.userMessage,
+      ragContext: args.config.ragContext,
+      workspaceContext: args.config.workspaceContext,
+      priorOutputs: args.agentOutputs,
+      aiConfig: args.config.aiConfig,
+      sessionId: args.sessionId,
+      effectiveModel: args.effectiveModel,
+      effectiveProvider: args.effectiveProvider,
+      eventBus: args.config.eventBus,
+      toolRegistry: args.config.tools,
+      providerStream: args.config.providerStream,
+      runMode: args.config.runMode,
+      languageModule: args.languageModule,
+      signal: args.config.signal
+    });
+    for await (const event of retryGenerator) {
+      if (event.type === "tool_execution_start") {
+        args.onToolCall();
+        args.emittedToolNames.push(event.toolName);
+      }
+      yield event;
+    }
+  } catch (retryErr) {
+    console.error(`[council] ${args.agent.id} retry failed:`, retryErr);
   }
+  enforceDesignPhaseToolEmissions(args.agent.id, args.emittedToolNames);
 }
-function hasInteractiveClarification(text) {
-  const c = parseClarificationRequest(text);
-  return !!(c && c.choices && c.choices.length >= 2);
+var MAX_RETRY_PER_MEMBER;
+var init_retryTurn = __esm({
+  "packages/core/dist/agents/council/retryTurn.js"() {
+    "use strict";
+    init_AgentHarness();
+    init_cancel();
+    init_toolSchemas();
+    init_memberMessages();
+    init_toolEmission();
+    MAX_RETRY_PER_MEMBER = 1;
+  }
+});
+
+// packages/core/dist/agents/council/chairmanDelivery.js
+async function* applyCompletionRetry(args) {
+  if (isCouncilCancelled(args.config.signal))
+    return;
+  const check2 = checkImplementationCompletion(args.emittedToolNames);
+  if (check2.ok)
+    return;
+  const retryTool = resolveVerifyRetryTool(args.executableNames);
+  if (!retryTool) {
+    console.warn("[council] implementation verify retry skipped \u2014 no grep_content/bash in registry");
+    return;
+  }
+  if (!shouldRetryMember([retryTool], 0))
+    return;
+  console.warn(`[council] ${args.agent.id} retrying missing verify tool: ${retryTool}`);
+  try {
+    const retryGenerator = runRetryTurnForMember({
+      agent: args.agent,
+      missingToolNames: [retryTool],
+      executableTools: args.executableNames,
+      userMessage: args.userMessage,
+      ragContext: args.config.ragContext,
+      workspaceContext: args.config.workspaceContext,
+      priorOutputs: args.agentOutputs,
+      aiConfig: args.config.aiConfig,
+      sessionId: args.sessionId,
+      effectiveModel: args.effectiveModel,
+      effectiveProvider: args.effectiveProvider,
+      eventBus: args.config.eventBus,
+      toolRegistry: args.config.tools,
+      providerStream: args.config.providerStream,
+      runMode: args.config.runMode,
+      retryPrompt: buildImplementationVerifyRetryPrompt(retryTool),
+      languageModule: args.languageModule,
+      signal: args.config.signal
+    });
+    for await (const event of retryGenerator) {
+      if (event.type === "tool_execution_start") {
+        args.onToolCall();
+        args.emittedToolNames.push(event.toolName);
+      }
+      yield event;
+    }
+  } catch (retryErr) {
+    console.error(`[council] ${args.agent.id} verify retry failed:`, retryErr);
+  }
+  const after = checkImplementationCompletion(args.emittedToolNames);
+  if (!after.ok) {
+    console.warn(`[council] ${args.agent.id} still missing verify after retry: ${after.reason}`);
+  }
 }
-function parseThinking(text) {
-  const complete = text.match(/<think(?:ing)?>([\s\S]*?)<\/think(?:ing)?>/i);
-  if (complete)
-    return complete[1].trim();
-  const open2 = text.match(/<think(?:ing)?>([\s\S]*)$/i);
-  return open2 ? open2[1].trim() : "";
+function buildMotionFixPrompt(violations) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const file2 = v.file || "index.html";
+    const loc = v.line ? `${file2}:L${v.line}` : file2;
+    const list = byFile.get(file2) ?? [];
+    list.push(`  - ${loc}: ${v.message}`);
+    byFile.set(file2, list);
+  }
+  const blocks = Array.from(byFile.values()).map((lines) => lines.join("\n")).join("\n");
+  return `Deterministic verification found ${violations.length} motion violation(s) in the file(s) you just edited. Fix ONLY these \u2014 do not add features, do not rewrite sections, do not touch anything else:
+${blocks}
+
+Rules: animate ONLY transform and opacity. Replace any box-shadow / background / background-position / filter / color / border-color / width / height / grid-template-rows used in @keyframes or transitions with transform/opacity equivalents (e.g. render a glow via a pseudo-element that scales and fades). For every classList.add('x') in the script, add a matching '.x' CSS rule. Use read_file to see the exact lines, then edit_file. When the listed items are fixed, stop \u2014 no summary.`;
 }
-function cleanAgentContent(text, opts = {}) {
-  const stripQuestion = opts.stripQuestion !== false;
-  const stripThink = opts.stripThink !== false;
-  let out = text;
-  if (stripThink) {
-    out = out.replace(/<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/gi, "").replace(/<think(?:ing)?>[\s\S]*$/gi, "").replace(/<\/think(?:ing)?>/gi, "");
+async function* applyImplementationWriteRetry(args) {
+  if (isCouncilCancelled(args.config.signal))
+    return;
+  if (args.check.ok)
+    return;
+  if (!shouldRetryMember(["write_file"], 0))
+    return;
+  const statusMsg = `[council] ${args.chairman.id} implementation write retry: ${args.check.missing.join(", ")}`;
+  args.onCouncilStatus?.(statusMsg);
+  console.warn(statusMsg);
+  try {
+    const retryGenerator = runRetryTurnForMember({
+      agent: args.chairman,
+      missingToolNames: ["read_file", "write_file", "edit_file"],
+      minPerTool: { read_file: 3, edit_file: 8, write_file: 1 },
+      executableTools: args.executableNames,
+      userMessage: args.userMessage,
+      ragContext: args.config.ragContext,
+      workspaceContext: args.config.workspaceContext,
+      priorOutputs: args.agentOutputs,
+      aiConfig: args.config.aiConfig,
+      sessionId: args.sessionId,
+      effectiveModel: args.effectiveModel,
+      effectiveProvider: args.effectiveProvider,
+      eventBus: args.config.eventBus,
+      toolRegistry: args.config.tools,
+      providerStream: args.config.providerStream,
+      runMode: "implementation",
+      retryPrompt: buildImplementationWriteRetryPrompt(args.userMessage),
+      languageModule: args.languageModule,
+      signal: args.config.signal
+    });
+    for await (const event of retryGenerator) {
+      if (event.type === "tool_execution_start")
+        args.onToolCall?.();
+      if (event.type === "tool_execution_end" && !event.isError && typeof event.result === "string") {
+        try {
+          const parsed = JSON.parse(event.result);
+          if ((parsed.bytesWritten ?? 0) > 0 || (parsed.occurrencesReplaced ?? 0) > 0) {
+            args.onSuccessfulWrite?.();
+          }
+        } catch {
+          if (event.result.includes("bytesWritten") || event.result.includes("occurrencesReplaced")) {
+            args.onSuccessfulWrite?.();
+          }
+        }
+      }
+      yield event;
+    }
+  } catch (retryErr) {
+    console.error(`[council] ${args.chairman.id} implementation write retry failed:`, retryErr);
   }
-  out = out.replace(/<minimax:tool_call>[\s\S]*?<\/minimax:tool_call>/gi, "").replace(/<\/?minimax:tool_call>/gi, "").replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, "").replace(/<\/?tool_call>/gi, "").replace(/<function_call>[\s\S]*?<\/function_call>/gi, "").replace(/<\/?function_call>/gi, "").replace(/<invoke\b[^>]*>[\s\S]*?<\/invoke>/gi, "").replace(/<\/invoke>/gi, "").replace(/<parameter\b[^>]*>[\s\S]*?<\/parameter>/gi, "").replace(/<\/parameter>/gi, "").replace(/\]\s*<\]\s*minimax\s*\[>\s*\[?<invoke\b[^>]*>[\s\S]*?<\/invoke>/gi, "").replace(/<minimax:tool_call>[\s\S]*$/gi, "").replace(/<tool_call>[\s\S]*$/gi, "").replace(/<function_call>[\s\S]*$/gi, "").replace(/<invoke\b[^>]*>[\s\S]*$/gi, "").replace(/\]\s*<\]\s*minimax\s*\[>[\s\S]*$/gi, "").replace(/^\s*\]\s*<\]\s*minimax\s*\[>.*$/gim, "").replace(/^\s*<\/?(?:tool_call|function_call|invoke|parameter|minimax:tool_call)\b[^>]*>\s*$/gim, "");
-  if (stripQuestion) {
-    out = out.replace(/---QUESTION---[\s\S]*?---END---/g, "").replace(/---QUESTION---[\s\S]*$/g, "");
+}
+async function* runChairmanDeliveryLoop(args) {
+  const maxAttempts = args.maxAttempts ?? MAX_DELIVERY_ATTEMPTS;
+  const zelariRoot = `${args.projectRoot}/.zelari`;
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    if (isCouncilCancelled(args.config.signal))
+      return false;
+    const report = runImplementationVerification({
+      projectRoot: args.projectRoot,
+      zelariRoot
+    });
+    const blocking = filterDeliveryBlockingFails(report.results);
+    if (blocking.length === 0)
+      return true;
+    if (blocking.some((b) => b.id === "inline-js.budget")) {
+      const jsFix = applyInlineJsAutofix(args.projectRoot, report);
+      if (jsFix.applied) {
+        args.onCouncilStatus?.(`[council] ${args.chairman.id} inline-js autofix: ${jsFix.fixes.join("; ")}`);
+        const afterJs = runImplementationVerification({
+          projectRoot: args.projectRoot,
+          zelariRoot
+        });
+        if (filterDeliveryBlockingFails(afterJs.results).length === 0)
+          return true;
+      }
+    }
+    attempt++;
+    const statusMsg = `[council] ${args.chairman.id} delivery pass ${attempt}/${maxAttempts}: ${blocking.map((b) => b.id).join(", ")}`;
+    args.onCouncilStatus?.(statusMsg);
+    console.warn(statusMsg);
+    try {
+      const fixGenerator = runRetryTurnForMember({
+        agent: args.chairman,
+        missingToolNames: ["read_file", "edit_file"],
+        minPerTool: { read_file: 3, edit_file: 10 },
+        executableTools: args.executableNames,
+        userMessage: args.userMessage,
+        ragContext: args.config.ragContext,
+        workspaceContext: args.config.workspaceContext,
+        priorOutputs: args.agentOutputs,
+        aiConfig: args.config.aiConfig,
+        sessionId: args.sessionId,
+        effectiveModel: args.effectiveModel,
+        effectiveProvider: args.effectiveProvider,
+        eventBus: args.config.eventBus,
+        toolRegistry: args.config.tools,
+        providerStream: args.config.providerStream,
+        runMode: "implementation",
+        retryPrompt: buildDeliveryFixPrompt(blocking, args.userMessage),
+        languageModule: args.languageModule,
+        signal: args.config.signal
+      });
+      for await (const event of fixGenerator) {
+        if (event.type === "tool_execution_start")
+          args.onToolCall?.();
+        yield event;
+      }
+    } catch (deliveryErr) {
+      console.error(`[council] ${args.chairman.id} delivery pass ${attempt} failed:`, deliveryErr);
+      break;
+    }
+    for (const rel2 of args.changedFiles) {
+      for (const w of runChairmanMicroGate({ projectRoot: args.projectRoot, relPath: rel2, zelariRoot })) {
+        args.changedFiles.add(w.file ?? rel2);
+      }
+    }
+  }
+  const finalReport = runImplementationVerification({
+    projectRoot: args.projectRoot,
+    zelariRoot
+  });
+  return filterDeliveryBlockingFails(finalReport.results).length === 0;
+}
+var MAX_DELIVERY_ATTEMPTS;
+var init_chairmanDelivery = __esm({
+  "packages/core/dist/agents/council/chairmanDelivery.js"() {
+    "use strict";
+    init_microGate();
+    init_completion();
+    init_implementationDelivery();
+    init_runChecks();
+    init_inlineJsAutofix();
+    init_retryTurn();
+    init_cancel();
+    MAX_DELIVERY_ATTEMPTS = 2;
+  }
+});
+
+// packages/core/dist/agents/council/chairmanFixLoop.js
+async function* replayChairmanTextTools(args) {
+  const tools = parseTextToolCalls(args.synthesisText);
+  if (tools.length === 0)
+    return 0;
+  let applied = 0;
+  for (const tt of tools) {
+    if (tt.name !== "edit_file" && tt.name !== "write_file")
+      continue;
+    const normalized = normalizeTextToolArgs(tt.name, tt.args);
+    const toolCallId = `replay-${crypto.randomUUID().slice(0, 8)}`;
+    yield createBrainEvent("tool_execution_start", args.sessionId, {
+      toolCallId,
+      toolName: tt.name,
+      args: normalized,
+      ...args.memberId ? { memberId: args.memberId } : {}
+    });
+    const startMs = Date.now();
+    let resultStr = "";
+    let isError = false;
+    try {
+      const result = await args.toolRegistry.invoke(tt.name, normalized, {
+        cwd: args.projectRoot,
+        sessionId: args.sessionId
+      });
+      if (result.ok) {
+        const val = result.value;
+        if (tt.name === "edit_file" && val.occurrencesReplaced === 0) {
+          resultStr = `edit_file: no match for oldString (replay)`;
+          isError = true;
+        } else {
+          resultStr = typeof result.value === "string" ? result.value : JSON.stringify(result.value, null, 2);
+          applied += 1;
+        }
+      } else {
+        resultStr = result.error;
+        isError = true;
+      }
+    } catch (err) {
+      resultStr = err instanceof Error ? err.message : String(err);
+      isError = true;
+    }
+    yield createBrainEvent("tool_execution_end", args.sessionId, {
+      toolCallId,
+      result: resultStr,
+      isError,
+      durationMs: Date.now() - startMs
+    });
+  }
+  return applied;
+}
+async function* runChairmanFixLoop(args) {
+  const maxAttempts = args.maxAttempts ?? 3;
+  const zelariRoot = `${args.projectRoot}/.zelari`;
+  let current = Array.from(args.violations.values());
+  let attempt = 0;
+  while (current.length > 0 && attempt < maxAttempts) {
+    if (isCouncilCancelled(args.config.signal))
+      return;
+    attempt++;
+    try {
+      const fixGenerator = runRetryTurnForMember({
+        agent: args.chairman,
+        missingToolNames: ["read_file", "edit_file"],
+        minPerTool: { read_file: 2, edit_file: 8 },
+        executableTools: args.executableNames,
+        userMessage: args.userMessage,
+        ragContext: args.config.ragContext,
+        workspaceContext: args.config.workspaceContext,
+        priorOutputs: args.agentOutputs,
+        aiConfig: args.config.aiConfig,
+        sessionId: args.sessionId,
+        effectiveModel: args.effectiveModel,
+        effectiveProvider: args.effectiveProvider,
+        eventBus: args.config.eventBus,
+        toolRegistry: args.config.tools,
+        providerStream: args.config.providerStream,
+        runMode: "implementation",
+        retryPrompt: buildMotionFixPrompt(current),
+        languageModule: args.languageModule,
+        signal: args.config.signal
+      });
+      for await (const event of fixGenerator) {
+        if (event.type === "tool_execution_start")
+          args.onToolCall?.();
+        yield event;
+      }
+    } catch (fixErr) {
+      console.error(`[council] chairman fix pass ${attempt} failed:`, fixErr);
+      break;
+    }
+    const rescanned = /* @__PURE__ */ new Map();
+    for (const relPath of args.changedFiles) {
+      for (const w of runChairmanMicroGate({ projectRoot: args.projectRoot, relPath, zelariRoot })) {
+        rescanned.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
+      }
+    }
+    current = Array.from(rescanned.values());
   }
-  out = out.replace(/\n{3,}/g, "\n\n").trim();
-  return scrubProprietaryLeak(out);
-}
-function restrictImplementationWrites(toolNames, opts) {
-  if (opts.runMode !== "implementation" || opts.isImplementer)
-    return toolNames;
-  return toolNames.filter((t) => !MUTATING_PROJECT_TOOLS.includes(t));
 }
-function buildAgentMessages(agent, userMessage, ragContext, workspaceContext, priorOutputs, aiConfig, executableTools, runMode = "implementation", languageModule) {
-  const allToolNames = computeAgentTools(agent, aiConfig);
-  const toolNames = executableTools ? allToolNames.filter((n) => executableTools.has(n)) : allToolNames;
-  const mergedAiConfig = languageModule ? {
-    enabledSkills: aiConfig?.enabledSkills ?? [],
-    enabledTools: aiConfig?.enabledTools ?? [],
-    agentSkillConfigs: aiConfig?.agentSkillConfigs ?? [],
-    customSkills: aiConfig?.customSkills,
-    customPromptModules: [
-      ...aiConfig?.customPromptModules ?? [],
-      languageModule
-    ]
-  } : aiConfig;
-  const modeAwareAgent = {
-    ...agent,
-    systemPrompt: resolveRoleSystemPrompt(agent, runMode)
-  };
-  const split = buildSystemPromptSplit(modeAwareAgent, {
-    tools: getAllTools(),
-    toolNames,
-    aiConfig: mergedAiConfig,
-    workspaceContext,
-    ragContext,
-    mode: "council",
-    includeWorkspaceInPrompt: true
-  });
-  const messages = [
-    { role: "system", content: split.stable }
-  ];
-  if (split.volatile.trim()) {
-    messages.push({ role: "system", content: split.volatile });
+var init_chairmanFixLoop = __esm({
+  "packages/core/dist/agents/council/chairmanFixLoop.js"() {
+    "use strict";
+    init_AgentHarness();
+    init_events();
+    init_microGate();
+    init_chairmanDelivery();
+    init_retryTurn();
+    init_cancel();
   }
-  messages.push({ role: "system", content: councilModeBanner(runMode, { isImplementer: agent.id === "lucifer" }) }, { role: "system", content: "IMPORTANT: Before making any tool calls or expensive operations, check if the information already exists in the shared context from previous agents. Avoid redundant work." });
-  if (priorOutputs.length > 0) {
-    const MAX_PRIOR_CHARS = 2800;
-    const summary = priorOutputs.map((o) => {
-      const body = o.content.length > MAX_PRIOR_CHARS ? `${o.content.slice(0, MAX_PRIOR_CHARS)}
-\u2026 [truncated ${o.content.length}\u2192${MAX_PRIOR_CHARS} chars; treat as hypothesis]` : o.content;
-      return `[${o.name} - ${o.role}]: ${body}`;
-    }).join("\n\n");
-    messages.push({
-      role: "user",
-      content: `Previous council members have said (hypotheses \u2014 prefer product files on disk if they conflict):
-${summary}
+});
 
-Original user request: ${userMessage}`
-    });
-  } else {
-    messages.push({ role: "user", content: userMessage });
-  }
-  return messages;
-}
+// packages/core/dist/agents/councilApi.js
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join8 } from "node:path";
 async function* runCouncilPure(userMessage, config2, callbacks = {}) {
   const baseAgents = getCouncilAgents(config2.councilSize);
   const agents = swapMembers(baseAgents, config2.memberSwap ?? {});
@@ -32454,6 +33062,17 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
     model: config2.model,
     provider: config2.provider ?? "minimax"
   };
+  if (isCouncilCancelled(config2.signal)) {
+    yield {
+      type: "agent_end",
+      id: crypto.randomUUID(),
+      ts: Date.now(),
+      sessionId: sessionId2,
+      reason: "cancelled",
+      durationMs: 0
+    };
+    return;
+  }
   const emitMemberCost = (input) => {
     const usage = input.usage;
     const prompt = usage?.promptTokens ?? 0;
@@ -32483,6 +33102,8 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
   const oracle = agents.find((a) => a.id === "minos") ?? (config2.skipSpecialists ? getAgent("minos") : void 0);
   const chairman = agents.find((a) => a.id === "lucifer") ?? (config2.skipSpecialists ? getAgent("lucifer") : void 0);
   for (const agent of specialists) {
+    if (isCouncilCancelled(config2.signal))
+      break;
     if (completedIds.has(agent.id))
       continue;
     callbacks.onAgentStart?.(agent);
@@ -32528,7 +33149,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
     const emittedToolNames = [];
     const memberStart = Date.now();
     try {
-      for await (const event of harness.run()) {
+      for await (const event of runHarnessWithAbort(harness, config2.signal)) {
         yield event;
         if (event.type === "tool_execution_start") {
           toolCalls += 1;
@@ -32550,7 +33171,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
       fullText = `Error: ${err instanceof Error ? err.message : "Unknown"}`;
       errored = true;
     }
-    if (isDesignPhase && !errored && !NON_RETRY_AGENTS.has(agent.id)) {
+    if (isDesignPhase && !errored && !NON_RETRY_AGENTS.has(agent.id) && !isCouncilCancelled(config2.signal)) {
       const specialistCheck = enforceDesignPhaseToolEmissions(agent.id, emittedToolNames);
       yield* applyRetryIfMissing({
         agent,
@@ -32633,7 +33254,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
       }
     }
   }
-  if (oracle && !completedIds.has(oracle.id)) {
+  if (oracle && !completedIds.has(oracle.id) && !isCouncilCancelled(config2.signal)) {
     callbacks.onAgentStart?.(oracle);
     const override = config2.agentModels?.[oracle.id];
     const effectiveProvider = override?.providerId ?? config2.provider ?? "minimax";
@@ -32682,7 +33303,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
     const emittedToolNames = [];
     const memberStart = Date.now();
     try {
-      for await (const event of harness.run()) {
+      for await (const event of runHarnessWithAbort(harness, config2.signal)) {
         yield event;
         if (event.type === "tool_execution_start") {
           toolCalls += 1;
@@ -32704,7 +33325,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
       fullText = `Review error: ${err instanceof Error ? err.message : "Unknown"}`;
       errored = true;
     }
-    if (isDesignPhase && !errored) {
+    if (isDesignPhase && !errored && !isCouncilCancelled(config2.signal)) {
       const oracleCheck = enforceDesignPhaseToolEmissions(oracle.id, emittedToolNames);
       yield* applyRetryIfMissing({
         agent: oracle,
@@ -32764,7 +33385,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
     });
     agentOutputs.push({ name: oracle.name, role: oracle.role, content: cleaned });
   }
-  if (chairman && !completedIds.has(chairman.id)) {
+  if (chairman && !completedIds.has(chairman.id) && !isCouncilCancelled(config2.signal)) {
     callbacks.onSynthesisStart?.();
     callbacks.onAgentStart?.(chairman);
     const override = config2.agentModels?.[chairman.id];
@@ -32800,702 +33421,264 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
     });
     let fullText = "";
     let toolCalls = 0;
-    let usage = null;
-    let errored = false;
-    let lastErrorMessage = "";
-    const emittedToolNames = [];
-    const pendingChairmanWrites = /* @__PURE__ */ new Map();
-    let successfulWriteCount = 0;
-    const chairmanViolations = /* @__PURE__ */ new Map();
-    const changedTargetFiles = /* @__PURE__ */ new Set();
-    let chairmanProjectRoot = parseProjectRootFromWorkspaceContext(config2.workspaceContext ?? "");
-    const memberStart = Date.now();
-    try {
-      for await (const event of chairmanHarness.run()) {
-        yield event;
-        if (event.type === "tool_execution_start") {
-          toolCalls += 1;
-          emittedToolNames.push(event.toolName);
-          if (!isDesignPhase && (event.toolName === "write_file" || event.toolName === "edit_file") && typeof event.args.path === "string") {
-            pendingChairmanWrites.set(event.toolCallId, {
-              path: event.args.path,
-              toolName: event.toolName
-            });
-          }
-        }
-        if (!isDesignPhase && event.type === "tool_execution_end") {
-          const pending = pendingChairmanWrites.get(event.toolCallId);
-          if (pending) {
-            pendingChairmanWrites.delete(event.toolCallId);
-            if (!event.isError) {
-              let wrote = pending.toolName === "write_file";
-              if (pending.toolName === "edit_file" && typeof event.result === "string") {
-                try {
-                  const parsed = JSON.parse(event.result);
-                  wrote = (parsed.occurrencesReplaced ?? 0) > 0;
-                } catch {
-                  wrote = false;
-                }
-              }
-              if (wrote) {
-                successfulWriteCount += 1;
-                const projectRoot = parseProjectRootFromWorkspaceContext(config2.workspaceContext);
-                if (projectRoot) {
-                  chairmanProjectRoot = projectRoot;
-                  changedTargetFiles.add(pending.path);
-                  for (const w of runChairmanMicroGate({
-                    projectRoot,
-                    relPath: pending.path,
-                    zelariRoot: `${projectRoot}/.zelari`
-                  })) {
-                    chairmanViolations.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
-                  }
-                }
-              }
-            }
-          }
-        }
-        if (event.type === "message_end" && event.usage) {
-          usage = event.usage;
-        }
-        if (event.type === "message_delta") {
-          fullText += event.delta;
-          callbacks.onSynthesisChunk?.(event.delta);
-          callbacks.onAgentChunk?.(chairman, event.delta);
-        }
-        if (event.type === "error") {
-          if (event.severity !== "cancelled" && event.code !== "text_tools_parse_failed") {
-            errored = true;
-            lastErrorMessage = event.message;
-          }
-        }
-      }
-    } catch (err) {
-      console.error(`[council] chairman "${chairman.id}" failed:`, err);
-      errored = true;
-      lastErrorMessage = err instanceof Error ? err.message : String(err);
-    }
-    if (isDesignPhase && !errored) {
-      const chairmanCheck = enforceDesignPhaseToolEmissions(chairman.id, emittedToolNames);
-      yield* applyRetryIfMissing({
-        agent: chairman,
-        check: chairmanCheck,
-        requirements: DESIGN_PHASE_REQUIREMENTS[chairman.id],
-        emittedToolNames,
-        executableNames,
-        sessionId: sessionId2,
-        userMessage,
-        agentOutputs,
-        config: config2,
-        effectiveProvider,
-        effectiveModel,
-        onToolCall: () => {
-          toolCalls += 1;
-        },
-        languageModule: councilLanguageModule
-      });
-    } else if (isDesignPhase) {
-      enforceDesignPhaseToolEmissions(chairman.id, emittedToolNames);
-    } else if (!errored) {
-      if (chairmanProjectRoot) {
-        const zelariRoot = `${chairmanProjectRoot}/.zelari`;
-        const spec = loadNfrSpec(zelariRoot) ?? DEFAULT_NFR_SPEC;
-        for (const rel2 of spec.targets) {
-          if (!existsSync12(join8(chairmanProjectRoot, rel2)))
-            continue;
-          changedTargetFiles.add(rel2);
-          for (const w of runChairmanMicroGate({ projectRoot: chairmanProjectRoot, relPath: rel2, zelariRoot })) {
-            chairmanViolations.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
-          }
-        }
-      }
-      if (fullText.includes("---TOOLS---") && chairmanProjectRoot && config2.tools) {
-        const replayed = yield* replayChairmanTextTools({
-          synthesisText: fullText,
-          projectRoot: chairmanProjectRoot,
-          toolRegistry: config2.tools,
-          sessionId: sessionId2,
-          memberId: chairman.id
-        });
-        successfulWriteCount += replayed;
-        const zelariRootReplay = `${chairmanProjectRoot}/.zelari`;
-        const specReplay = loadNfrSpec(zelariRootReplay) ?? DEFAULT_NFR_SPEC;
-        for (const rel2 of specReplay.targets) {
-          if (!existsSync12(join8(chairmanProjectRoot, rel2)))
-            continue;
-          changedTargetFiles.add(rel2);
-          for (const w of runChairmanMicroGate({
-            projectRoot: chairmanProjectRoot,
-            relPath: rel2,
-            zelariRoot: zelariRootReplay
-          })) {
-            chairmanViolations.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
-          }
-        }
-      }
-      if (chairmanProjectRoot) {
-        const deliveryCheck = checkImplementationDelivery(successfulWriteCount, countEmittedWriteTools(emittedToolNames));
-        if (!deliveryCheck.ok) {
-          yield* applyImplementationWriteRetry({
-            chairman,
-            check: deliveryCheck,
-            sessionId: sessionId2,
-            userMessage,
-            agentOutputs,
-            config: config2,
-            effectiveProvider,
-            effectiveModel,
-            executableNames,
-            onToolCall: () => {
-              toolCalls += 1;
-            },
-            onSuccessfulWrite: () => {
-              successfulWriteCount += 1;
-            },
-            onCouncilStatus: callbacks.onCouncilStatus,
-            languageModule: councilLanguageModule
-          });
-        }
-      }
-      if (chairmanViolations.size > 0 && chairmanProjectRoot) {
-        yield* runChairmanFixLoop({
-          chairman,
-          violations: chairmanViolations,
-          changedFiles: changedTargetFiles,
-          projectRoot: chairmanProjectRoot,
-          executableNames,
-          sessionId: sessionId2,
-          userMessage,
-          agentOutputs,
-          config: config2,
-          effectiveProvider,
-          effectiveModel,
-          onToolCall: () => {
-            toolCalls += 1;
-          },
-          languageModule: councilLanguageModule
-        });
-      }
-      if (chairmanProjectRoot) {
-        yield* runChairmanDeliveryLoop({
-          chairman,
-          projectRoot: chairmanProjectRoot,
-          changedFiles: changedTargetFiles,
-          executableNames,
-          sessionId: sessionId2,
-          userMessage,
-          agentOutputs,
-          config: config2,
-          effectiveProvider,
-          effectiveModel,
-          onToolCall: () => {
-            toolCalls += 1;
-          },
-          onCouncilStatus: callbacks.onCouncilStatus,
-          languageModule: councilLanguageModule
-        });
-      }
-    }
-    const memberDuration = Date.now() - memberStart;
-    const finalSynthesis = errored && fullText.length === 0 ? `[Chairman synthesis failed: ${lastErrorMessage || "unknown error"}]` : fullText;
-    callbacks.onSynthesisDone?.(finalSynthesis, void 0, void 0);
-    emitMemberCost({
-      memberId: chairman.id,
-      name: chairman.name,
-      usage,
-      durationMs: memberDuration,
-      toolCalls,
-      errored
-    });
-    yield createBrainEvent("member_cost", sessionId2, {
-      cost: {
-        memberId: chairman.id,
-        name: chairman.name,
-        promptTokens: usage?.promptTokens ?? 0,
-        completionTokens: usage?.completionTokens ?? 0,
-        totalTokens: usage?.totalTokens ?? (usage?.promptTokens ?? 0) + (usage?.completionTokens ?? 0),
-        durationMs: memberDuration,
-        toolCalls,
-        errored
-      }
-    });
-  }
-  yield {
-    type: "agent_end",
-    id: crypto.randomUUID(),
-    ts: Date.now(),
-    sessionId: sessionId2,
-    reason: "completed",
-    durationMs: 0
-  };
-}
-async function* applyCompletionRetry(args) {
-  const check2 = checkImplementationCompletion(args.emittedToolNames);
-  if (check2.ok)
-    return;
-  const retryTool = resolveVerifyRetryTool(args.executableNames);
-  if (!retryTool) {
-    console.warn("[council] implementation verify retry skipped \u2014 no grep_content/bash in registry");
-    return;
-  }
-  if (!shouldRetryMember([retryTool], 0))
-    return;
-  console.warn(`[council] ${args.agent.id} retrying missing verify tool: ${retryTool}`);
-  try {
-    const retryGenerator = runRetryTurnForMember({
-      agent: args.agent,
-      missingToolNames: [retryTool],
-      executableTools: args.executableNames,
-      userMessage: args.userMessage,
-      ragContext: args.config.ragContext,
-      workspaceContext: args.config.workspaceContext,
-      priorOutputs: args.agentOutputs,
-      aiConfig: args.config.aiConfig,
-      sessionId: args.sessionId,
-      effectiveModel: args.effectiveModel,
-      effectiveProvider: args.effectiveProvider,
-      eventBus: args.config.eventBus,
-      toolRegistry: args.config.tools,
-      providerStream: args.config.providerStream,
-      runMode: args.config.runMode,
-      retryPrompt: buildImplementationVerifyRetryPrompt(retryTool),
-      languageModule: args.languageModule
-    });
-    for await (const event of retryGenerator) {
-      if (event.type === "tool_execution_start") {
-        args.onToolCall();
-        args.emittedToolNames.push(event.toolName);
-      }
-      yield event;
-    }
-  } catch (retryErr) {
-    console.error(`[council] ${args.agent.id} verify retry failed:`, retryErr);
-  }
-  const after = checkImplementationCompletion(args.emittedToolNames);
-  if (!after.ok) {
-    console.warn(`[council] ${args.agent.id} still missing verify after retry: ${after.reason}`);
-  }
-}
-function buildMotionFixPrompt(violations) {
-  const byFile = /* @__PURE__ */ new Map();
-  for (const v of violations) {
-    const file2 = v.file || "index.html";
-    const loc = v.line ? `${file2}:L${v.line}` : file2;
-    const list = byFile.get(file2) ?? [];
-    list.push(`  - ${loc}: ${v.message}`);
-    byFile.set(file2, list);
-  }
-  const blocks = Array.from(byFile.values()).map((lines) => lines.join("\n")).join("\n");
-  return `Deterministic verification found ${violations.length} motion violation(s) in the file(s) you just edited. Fix ONLY these \u2014 do not add features, do not rewrite sections, do not touch anything else:
-${blocks}
-
-Rules: animate ONLY transform and opacity. Replace any box-shadow / background / background-position / filter / color / border-color / width / height / grid-template-rows used in @keyframes or transitions with transform/opacity equivalents (e.g. render a glow via a pseudo-element that scales and fades). For every classList.add('x') in the script, add a matching '.x' CSS rule. Use read_file to see the exact lines, then edit_file. When the listed items are fixed, stop \u2014 no summary.`;
-}
-async function* applyImplementationWriteRetry(args) {
-  if (args.check.ok)
-    return;
-  if (!shouldRetryMember(["write_file"], 0))
-    return;
-  const statusMsg = `[council] ${args.chairman.id} implementation write retry: ${args.check.missing.join(", ")}`;
-  args.onCouncilStatus?.(statusMsg);
-  console.warn(statusMsg);
-  try {
-    const retryGenerator = runRetryTurnForMember({
-      agent: args.chairman,
-      missingToolNames: ["read_file", "write_file", "edit_file"],
-      minPerTool: { read_file: 3, edit_file: 8, write_file: 1 },
-      executableTools: args.executableNames,
-      userMessage: args.userMessage,
-      ragContext: args.config.ragContext,
-      workspaceContext: args.config.workspaceContext,
-      priorOutputs: args.agentOutputs,
-      aiConfig: args.config.aiConfig,
-      sessionId: args.sessionId,
-      effectiveModel: args.effectiveModel,
-      effectiveProvider: args.effectiveProvider,
-      eventBus: args.config.eventBus,
-      toolRegistry: args.config.tools,
-      providerStream: args.config.providerStream,
-      runMode: "implementation",
-      retryPrompt: buildImplementationWriteRetryPrompt(args.userMessage),
-      languageModule: args.languageModule
-    });
-    for await (const event of retryGenerator) {
-      if (event.type === "tool_execution_start")
-        args.onToolCall?.();
-      if (event.type === "tool_execution_end" && !event.isError && typeof event.result === "string") {
-        try {
-          const parsed = JSON.parse(event.result);
-          if ((parsed.bytesWritten ?? 0) > 0 || (parsed.occurrencesReplaced ?? 0) > 0) {
-            args.onSuccessfulWrite?.();
-          }
-        } catch {
-          if (event.result.includes("bytesWritten") || event.result.includes("occurrencesReplaced")) {
-            args.onSuccessfulWrite?.();
-          }
-        }
-      }
-      yield event;
-    }
-  } catch (retryErr) {
-    console.error(`[council] ${args.chairman.id} implementation write retry failed:`, retryErr);
-  }
-}
-async function* runChairmanDeliveryLoop(args) {
-  const maxAttempts = args.maxAttempts ?? MAX_DELIVERY_ATTEMPTS;
-  const zelariRoot = `${args.projectRoot}/.zelari`;
-  let attempt = 0;
-  while (attempt < maxAttempts) {
-    const report = runImplementationVerification({
-      projectRoot: args.projectRoot,
-      zelariRoot
-    });
-    const blocking = filterDeliveryBlockingFails(report.results);
-    if (blocking.length === 0)
-      return true;
-    if (blocking.some((b) => b.id === "inline-js.budget")) {
-      const jsFix = applyInlineJsAutofix(args.projectRoot, report);
-      if (jsFix.applied) {
-        args.onCouncilStatus?.(`[council] ${args.chairman.id} inline-js autofix: ${jsFix.fixes.join("; ")}`);
-        const afterJs = runImplementationVerification({
-          projectRoot: args.projectRoot,
-          zelariRoot
-        });
-        if (filterDeliveryBlockingFails(afterJs.results).length === 0)
-          return true;
-      }
-    }
-    attempt++;
-    const statusMsg = `[council] ${args.chairman.id} delivery pass ${attempt}/${maxAttempts}: ${blocking.map((b) => b.id).join(", ")}`;
-    args.onCouncilStatus?.(statusMsg);
-    console.warn(statusMsg);
-    try {
-      const fixGenerator = runRetryTurnForMember({
-        agent: args.chairman,
-        missingToolNames: ["read_file", "edit_file"],
-        minPerTool: { read_file: 3, edit_file: 10 },
-        executableTools: args.executableNames,
-        userMessage: args.userMessage,
-        ragContext: args.config.ragContext,
-        workspaceContext: args.config.workspaceContext,
-        priorOutputs: args.agentOutputs,
-        aiConfig: args.config.aiConfig,
-        sessionId: args.sessionId,
-        effectiveModel: args.effectiveModel,
-        effectiveProvider: args.effectiveProvider,
-        eventBus: args.config.eventBus,
-        toolRegistry: args.config.tools,
-        providerStream: args.config.providerStream,
-        runMode: "implementation",
-        retryPrompt: buildDeliveryFixPrompt(blocking, args.userMessage),
-        languageModule: args.languageModule
-      });
-      for await (const event of fixGenerator) {
-        if (event.type === "tool_execution_start")
-          args.onToolCall?.();
-        yield event;
-      }
-    } catch (deliveryErr) {
-      console.error(`[council] ${args.chairman.id} delivery pass ${attempt} failed:`, deliveryErr);
-      break;
-    }
-    for (const rel2 of args.changedFiles) {
-      for (const w of runChairmanMicroGate({ projectRoot: args.projectRoot, relPath: rel2, zelariRoot })) {
-        args.changedFiles.add(w.file ?? rel2);
-      }
-    }
-  }
-  const finalReport = runImplementationVerification({
-    projectRoot: args.projectRoot,
-    zelariRoot
-  });
-  return filterDeliveryBlockingFails(finalReport.results).length === 0;
-}
-async function* replayChairmanTextTools(args) {
-  const tools = parseTextToolCalls(args.synthesisText);
-  if (tools.length === 0)
-    return 0;
-  let applied = 0;
-  for (const tt of tools) {
-    if (tt.name !== "edit_file" && tt.name !== "write_file")
-      continue;
-    const normalized = normalizeTextToolArgs(tt.name, tt.args);
-    const toolCallId = `replay-${crypto.randomUUID().slice(0, 8)}`;
-    yield createBrainEvent("tool_execution_start", args.sessionId, {
-      toolCallId,
-      toolName: tt.name,
-      args: normalized,
-      ...args.memberId ? { memberId: args.memberId } : {}
-    });
-    const startMs = Date.now();
-    let resultStr = "";
-    let isError = false;
-    try {
-      const result = await args.toolRegistry.invoke(tt.name, normalized, {
-        cwd: args.projectRoot,
-        sessionId: args.sessionId
-      });
-      if (result.ok) {
-        const val = result.value;
-        if (tt.name === "edit_file" && val.occurrencesReplaced === 0) {
-          resultStr = `edit_file: no match for oldString (replay)`;
-          isError = true;
-        } else {
-          resultStr = typeof result.value === "string" ? result.value : JSON.stringify(result.value, null, 2);
-          applied += 1;
+    let usage = null;
+    let errored = false;
+    let lastErrorMessage = "";
+    const emittedToolNames = [];
+    const pendingChairmanWrites = /* @__PURE__ */ new Map();
+    let successfulWriteCount = 0;
+    const chairmanViolations = /* @__PURE__ */ new Map();
+    const changedTargetFiles = /* @__PURE__ */ new Set();
+    let chairmanProjectRoot = parseProjectRootFromWorkspaceContext(config2.workspaceContext ?? "");
+    const memberStart = Date.now();
+    try {
+      for await (const event of runHarnessWithAbort(chairmanHarness, config2.signal)) {
+        yield event;
+        if (event.type === "tool_execution_start") {
+          toolCalls += 1;
+          emittedToolNames.push(event.toolName);
+          if (!isDesignPhase && (event.toolName === "write_file" || event.toolName === "edit_file") && typeof event.args.path === "string") {
+            pendingChairmanWrites.set(event.toolCallId, {
+              path: event.args.path,
+              toolName: event.toolName
+            });
+          }
+        }
+        if (!isDesignPhase && event.type === "tool_execution_end") {
+          const pending = pendingChairmanWrites.get(event.toolCallId);
+          if (pending) {
+            pendingChairmanWrites.delete(event.toolCallId);
+            if (!event.isError) {
+              let wrote = pending.toolName === "write_file";
+              if (pending.toolName === "edit_file" && typeof event.result === "string") {
+                try {
+                  const parsed = JSON.parse(event.result);
+                  wrote = (parsed.occurrencesReplaced ?? 0) > 0;
+                } catch {
+                  wrote = false;
+                }
+              }
+              if (wrote) {
+                successfulWriteCount += 1;
+                const projectRoot = parseProjectRootFromWorkspaceContext(config2.workspaceContext);
+                if (projectRoot) {
+                  chairmanProjectRoot = projectRoot;
+                  changedTargetFiles.add(pending.path);
+                  for (const w of runChairmanMicroGate({
+                    projectRoot,
+                    relPath: pending.path,
+                    zelariRoot: `${projectRoot}/.zelari`
+                  })) {
+                    chairmanViolations.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (event.type === "message_end" && event.usage) {
+          usage = event.usage;
+        }
+        if (event.type === "message_delta") {
+          fullText += event.delta;
+          callbacks.onSynthesisChunk?.(event.delta);
+          callbacks.onAgentChunk?.(chairman, event.delta);
+        }
+        if (event.type === "error") {
+          if (event.severity !== "cancelled" && event.code !== "text_tools_parse_failed") {
+            errored = true;
+            lastErrorMessage = event.message;
+          }
         }
-      } else {
-        resultStr = result.error;
-        isError = true;
       }
     } catch (err) {
-      resultStr = err instanceof Error ? err.message : String(err);
-      isError = true;
+      console.error(`[council] chairman "${chairman.id}" failed:`, err);
+      errored = true;
+      lastErrorMessage = err instanceof Error ? err.message : String(err);
     }
-    yield createBrainEvent("tool_execution_end", args.sessionId, {
-      toolCallId,
-      result: resultStr,
-      isError,
-      durationMs: Date.now() - startMs
-    });
-  }
-  return applied;
-}
-async function* runChairmanFixLoop(args) {
-  const maxAttempts = args.maxAttempts ?? 3;
-  const zelariRoot = `${args.projectRoot}/.zelari`;
-  let current = Array.from(args.violations.values());
-  let attempt = 0;
-  while (current.length > 0 && attempt < maxAttempts) {
-    attempt++;
-    try {
-      const fixGenerator = runRetryTurnForMember({
-        agent: args.chairman,
-        missingToolNames: ["read_file", "edit_file"],
-        minPerTool: { read_file: 2, edit_file: 8 },
-        executableTools: args.executableNames,
-        userMessage: args.userMessage,
-        ragContext: args.config.ragContext,
-        workspaceContext: args.config.workspaceContext,
-        priorOutputs: args.agentOutputs,
-        aiConfig: args.config.aiConfig,
-        sessionId: args.sessionId,
-        effectiveModel: args.effectiveModel,
-        effectiveProvider: args.effectiveProvider,
-        eventBus: args.config.eventBus,
-        toolRegistry: args.config.tools,
-        providerStream: args.config.providerStream,
-        runMode: "implementation",
-        retryPrompt: buildMotionFixPrompt(current),
-        languageModule: args.languageModule
+    if (isDesignPhase && !errored && !isCouncilCancelled(config2.signal)) {
+      const chairmanCheck = enforceDesignPhaseToolEmissions(chairman.id, emittedToolNames);
+      yield* applyRetryIfMissing({
+        agent: chairman,
+        check: chairmanCheck,
+        requirements: DESIGN_PHASE_REQUIREMENTS[chairman.id],
+        emittedToolNames,
+        executableNames,
+        sessionId: sessionId2,
+        userMessage,
+        agentOutputs,
+        config: config2,
+        effectiveProvider,
+        effectiveModel,
+        onToolCall: () => {
+          toolCalls += 1;
+        },
+        languageModule: councilLanguageModule
       });
-      for await (const event of fixGenerator) {
-        if (event.type === "tool_execution_start")
-          args.onToolCall?.();
-        yield event;
+    } else if (isDesignPhase) {
+      enforceDesignPhaseToolEmissions(chairman.id, emittedToolNames);
+    } else if (!errored && !isCouncilCancelled(config2.signal)) {
+      if (chairmanProjectRoot) {
+        const zelariRoot = `${chairmanProjectRoot}/.zelari`;
+        const spec = loadNfrSpec(zelariRoot) ?? DEFAULT_NFR_SPEC;
+        for (const rel2 of spec.targets) {
+          if (!existsSync12(join8(chairmanProjectRoot, rel2)))
+            continue;
+          changedTargetFiles.add(rel2);
+          for (const w of runChairmanMicroGate({ projectRoot: chairmanProjectRoot, relPath: rel2, zelariRoot })) {
+            chairmanViolations.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
+          }
+        }
       }
-    } catch (fixErr) {
-      console.error(`[council] chairman fix pass ${attempt} failed:`, fixErr);
-      break;
-    }
-    const rescanned = /* @__PURE__ */ new Map();
-    for (const relPath of args.changedFiles) {
-      for (const w of runChairmanMicroGate({ projectRoot: args.projectRoot, relPath, zelariRoot })) {
-        rescanned.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
+      if (fullText.includes("---TOOLS---") && chairmanProjectRoot && config2.tools) {
+        const replayed = yield* replayChairmanTextTools({
+          synthesisText: fullText,
+          projectRoot: chairmanProjectRoot,
+          toolRegistry: config2.tools,
+          sessionId: sessionId2,
+          memberId: chairman.id
+        });
+        successfulWriteCount += replayed;
+        const zelariRootReplay = `${chairmanProjectRoot}/.zelari`;
+        const specReplay = loadNfrSpec(zelariRootReplay) ?? DEFAULT_NFR_SPEC;
+        for (const rel2 of specReplay.targets) {
+          if (!existsSync12(join8(chairmanProjectRoot, rel2)))
+            continue;
+          changedTargetFiles.add(rel2);
+          for (const w of runChairmanMicroGate({
+            projectRoot: chairmanProjectRoot,
+            relPath: rel2,
+            zelariRoot: zelariRootReplay
+          })) {
+            chairmanViolations.set(`${w.id}|${w.file}|${w.line ?? ""}`, w);
+          }
+        }
       }
-    }
-    current = Array.from(rescanned.values());
-  }
-}
-function checkMemberToolEmissions(_memberId, emittedToolNames, requirements) {
-  if (requirements.length === 0) {
-    return { ok: true, missing: [] };
-  }
-  const counts = /* @__PURE__ */ new Map();
-  for (const name of emittedToolNames) {
-    counts.set(name, (counts.get(name) ?? 0) + 1);
-  }
-  const missing = [];
-  for (const req of requirements) {
-    const got = counts.get(req.name) ?? 0;
-    if (got < req.min) {
-      missing.push(`${req.name} (got ${got}, need >= ${req.min})`);
-    }
-  }
-  return { ok: missing.length === 0, missing };
-}
-function checkMemberToolEmissionSets(memberId, emittedToolNames, sets) {
-  if (sets.length === 0) {
-    return { ok: true, missing: [] };
-  }
-  const results = sets.map((set2) => checkMemberToolEmissions(memberId, emittedToolNames, set2));
-  if (results.some((r) => r.ok)) {
-    return { ok: true, missing: [] };
-  }
-  return results[0];
-}
-function enforceDesignPhaseToolEmissions(memberId, emittedToolNames) {
-  const sets = DESIGN_PHASE_REQUIREMENT_SETS[memberId];
-  if (!sets || sets.length === 0) {
-    return { ok: true, missing: [] };
-  }
-  const result = checkMemberToolEmissionSets(memberId, emittedToolNames, sets);
-  if (!result.ok) {
-    console.warn(`[council] member "${memberId}" did not emit required tools: ${result.missing.join(", ")}. The downstream .zelari/ deliverable may be incomplete. (A forced retry turn scoped to the missing tools follows; the deterministic complete-design fallback covers any remaining gap.)`);
-  }
-  return result;
-}
-function shouldRetryMember(missingToolNames, attemptsSoFar) {
-  if (missingToolNames.length === 0)
-    return false;
-  if (attemptsSoFar >= MAX_RETRY_PER_MEMBER)
-    return false;
-  return true;
-}
-function buildRetryPrompt(missingToolNames) {
-  const names = missingToolNames.join(", ");
-  return `You did not emit the required workspace tools: ${names}. Call ${names} NOW with concrete arguments. No prose. No search.`;
-}
-async function* runRetryTurnForMember(args) {
-  const executableMissing = args.executableTools ? args.missingToolNames.filter((n) => args.executableTools.has(n)) : args.missingToolNames;
-  if (executableMissing.length === 0) {
-    return [];
-  }
-  const retryToolNames = executableMissing;
-  const retryToolSpecs = getProviderTools(retryToolNames).map((t) => ({
-    name: t.function.name,
-    description: t.function.description,
-    parameters: t.function.parameters
-  }));
-  const baseMessages = buildAgentMessages(args.agent, args.userMessage, args.ragContext, args.workspaceContext, args.priorOutputs, args.aiConfig, args.executableTools, args.runMode ?? "implementation", args.languageModule);
-  const retryMessages = [
-    ...baseMessages,
-    {
-      role: "user",
-      content: args.retryPrompt ?? buildRetryPrompt(executableMissing)
-    }
-  ];
-  const maxToolCalls = args.minPerTool !== void 0 ? Object.entries(args.minPerTool).filter(([name]) => executableMissing.includes(name)).reduce((sum, [, min]) => sum + min, 0) : retryToolNames.length;
-  const retryHarness = new AgentHarness({
-    model: args.effectiveModel,
-    provider: args.effectiveProvider,
-    sessionId: args.sessionId,
-    messages: retryMessages,
-    tools: retryToolSpecs,
-    eventBus: args.eventBus,
-    toolRegistry: args.toolRegistry,
-    // Budget the retry so the model can satisfy every requirement in
-    // ONE tool_calls turn. For createTask min:12 this needs 12 calls.
-    maxToolCallsPerTurn: maxToolCalls,
-    memberId: args.agent.id,
-    memberName: args.agent.name,
-    providerStream: (params) => args.providerStream(params)
-  });
-  const retryEmitted = [];
-  for await (const event of retryHarness.run()) {
-    if (event.type === "tool_execution_start") {
-      retryEmitted.push(event.toolName);
-    }
-    yield event;
-  }
-  return retryEmitted;
-}
-async function* applyRetryIfMissing(args) {
-  if (args.check.ok)
-    return;
-  const missingToolNames = args.check.missing.map((m) => m.split(" ")[0]);
-  if (!shouldRetryMember(missingToolNames, 0))
-    return;
-  console.warn(`[council] ${args.agent.id} retrying missing tools: ${missingToolNames.join(", ")}`);
-  const minPerTool = {};
-  if (args.requirements) {
-    for (const req of args.requirements) {
-      if (missingToolNames.includes(req.name)) {
-        minPerTool[req.name] = req.min;
+      if (chairmanProjectRoot) {
+        const deliveryCheck = checkImplementationDelivery(successfulWriteCount, countEmittedWriteTools(emittedToolNames));
+        if (!deliveryCheck.ok) {
+          yield* applyImplementationWriteRetry({
+            chairman,
+            check: deliveryCheck,
+            sessionId: sessionId2,
+            userMessage,
+            agentOutputs,
+            config: config2,
+            effectiveProvider,
+            effectiveModel,
+            executableNames,
+            onToolCall: () => {
+              toolCalls += 1;
+            },
+            onSuccessfulWrite: () => {
+              successfulWriteCount += 1;
+            },
+            onCouncilStatus: callbacks.onCouncilStatus,
+            languageModule: councilLanguageModule
+          });
+        }
+      }
+      if (chairmanViolations.size > 0 && chairmanProjectRoot) {
+        yield* runChairmanFixLoop({
+          chairman,
+          violations: chairmanViolations,
+          changedFiles: changedTargetFiles,
+          projectRoot: chairmanProjectRoot,
+          executableNames,
+          sessionId: sessionId2,
+          userMessage,
+          agentOutputs,
+          config: config2,
+          effectiveProvider,
+          effectiveModel,
+          onToolCall: () => {
+            toolCalls += 1;
+          },
+          languageModule: councilLanguageModule
+        });
+      }
+      if (chairmanProjectRoot) {
+        yield* runChairmanDeliveryLoop({
+          chairman,
+          projectRoot: chairmanProjectRoot,
+          changedFiles: changedTargetFiles,
+          executableNames,
+          sessionId: sessionId2,
+          userMessage,
+          agentOutputs,
+          config: config2,
+          effectiveProvider,
+          effectiveModel,
+          onToolCall: () => {
+            toolCalls += 1;
+          },
+          onCouncilStatus: callbacks.onCouncilStatus,
+          languageModule: councilLanguageModule
+        });
       }
     }
-  }
-  try {
-    const retryGenerator = runRetryTurnForMember({
-      agent: args.agent,
-      missingToolNames,
-      minPerTool,
-      executableTools: args.executableNames,
-      userMessage: args.userMessage,
-      ragContext: args.config.ragContext,
-      workspaceContext: args.config.workspaceContext,
-      priorOutputs: args.agentOutputs,
-      aiConfig: args.config.aiConfig,
-      sessionId: args.sessionId,
-      effectiveModel: args.effectiveModel,
-      effectiveProvider: args.effectiveProvider,
-      eventBus: args.config.eventBus,
-      toolRegistry: args.config.tools,
-      providerStream: args.config.providerStream,
-      runMode: args.config.runMode,
-      languageModule: args.languageModule
+    const memberDuration = Date.now() - memberStart;
+    const finalSynthesis = errored && fullText.length === 0 ? `[Chairman synthesis failed: ${lastErrorMessage || "unknown error"}]` : fullText;
+    callbacks.onSynthesisDone?.(finalSynthesis, void 0, void 0);
+    emitMemberCost({
+      memberId: chairman.id,
+      name: chairman.name,
+      usage,
+      durationMs: memberDuration,
+      toolCalls,
+      errored
     });
-    for await (const event of retryGenerator) {
-      if (event.type === "tool_execution_start") {
-        args.onToolCall();
-        args.emittedToolNames.push(event.toolName);
+    yield createBrainEvent("member_cost", sessionId2, {
+      cost: {
+        memberId: chairman.id,
+        name: chairman.name,
+        promptTokens: usage?.promptTokens ?? 0,
+        completionTokens: usage?.completionTokens ?? 0,
+        totalTokens: usage?.totalTokens ?? (usage?.promptTokens ?? 0) + (usage?.completionTokens ?? 0),
+        durationMs: memberDuration,
+        toolCalls,
+        errored
       }
-      yield event;
-    }
-  } catch (retryErr) {
-    console.error(`[council] ${args.agent.id} retry failed:`, retryErr);
+    });
   }
-  enforceDesignPhaseToolEmissions(args.agent.id, args.emittedToolNames);
+  yield {
+    type: "agent_end",
+    id: crypto.randomUUID(),
+    ts: Date.now(),
+    sessionId: sessionId2,
+    reason: isCouncilCancelled(config2.signal) ? "cancelled" : "completed",
+    durationMs: 0
+  };
 }
-var NON_RETRY_AGENTS, QUESTION_MARKER, QUESTION_END_MARKER, MUTATING_PROJECT_TOOLS, MAX_DELIVERY_ATTEMPTS, DESIGN_PHASE_REQUIREMENT_SETS, DESIGN_PHASE_REQUIREMENTS, MAX_RETRY_PER_MEMBER;
 var init_councilApi = __esm({
   "packages/core/dist/agents/councilApi.js"() {
     "use strict";
     init_roles();
     init_toolSchemas();
     init_systemPromptBuilder();
-    init_tools();
     init_languagePolicy();
-    init_secrecyPolicy();
     init_events();
     init_AgentHarness();
-    init_modeBanners();
     init_runMode();
     init_microGate();
-    init_completion();
     init_nfrSpecWarn();
     init_runChecks();
     init_implementationDelivery();
-    init_inlineJsAutofix();
-    NON_RETRY_AGENTS = /* @__PURE__ */ new Set([]);
-    QUESTION_MARKER = "---QUESTION---";
-    QUESTION_END_MARKER = "---END---";
-    MUTATING_PROJECT_TOOLS = ["write_file", "edit_file"];
-    MAX_DELIVERY_ATTEMPTS = 2;
-    DESIGN_PHASE_REQUIREMENT_SETS = {
-      nettun: [
-        [{ name: "createPlan", min: 1 }],
-        [
-          { name: "createPhase", min: 3 },
-          { name: "createTask", min: 6 },
-          { name: "createMilestone", min: 1 }
-        ]
-      ],
-      geryon: [
-        [{ name: "createDocument", min: 3 }]
-      ],
-      pluton: [
-        [{ name: "createDocument", min: 1 }]
-      ],
-      minos: [
-        [{ name: "createDocument", min: 1 }]
-      ],
-      lucifer: [
-        [{ name: "createDocument", min: 1 }]
-      ]
-    };
-    DESIGN_PHASE_REQUIREMENTS = Object.fromEntries(Object.entries(DESIGN_PHASE_REQUIREMENT_SETS).map(([id3, sets]) => [id3, sets[0]]));
-    MAX_RETRY_PER_MEMBER = 1;
+    init_types7();
+    init_cancel();
+    init_types7();
+    init_outputCleaning();
+    init_outputCleaning();
+    init_memberMessages();
+    init_memberMessages();
+    init_chairmanDelivery();
+    init_chairmanDelivery();
+    init_chairmanFixLoop();
+    init_chairmanFixLoop();
+    init_toolEmission();
+    init_toolEmission();
+    init_retryTurn();
+    init_retryTurn();
   }
 });
 
@@ -33632,7 +33815,7 @@ var init_missionBrief = __esm({
 });
 
 // packages/core/dist/council/verification/types.js
-var init_types7 = __esm({
+var init_types8 = __esm({
   "packages/core/dist/council/verification/types.js"() {
     "use strict";
   }
@@ -33836,7 +34019,7 @@ var init_autofix = __esm({
 var init_verification2 = __esm({
   "packages/core/dist/council/verification/index.js"() {
     "use strict";
-    init_types7();
+    init_types8();
     init_runChecks();
     init_honesty();
     init_parseCssMotion();
@@ -33854,7 +34037,7 @@ var init_verification2 = __esm({
 });
 
 // packages/core/dist/council/lessons/types.js
-var init_types8 = __esm({
+var init_types9 = __esm({
   "packages/core/dist/council/lessons/types.js"() {
     "use strict";
   }
@@ -34107,7 +34290,7 @@ var init_recallLessons = __esm({
 var init_lessons = __esm({
   "packages/core/dist/council/lessons/index.js"() {
     "use strict";
-    init_types8();
+    init_types9();
     init_io();
     init_isAnswerLeak();
     init_signatures();
@@ -34117,7 +34300,7 @@ var init_lessons = __esm({
 });
 
 // packages/core/dist/council/completion/types.js
-var init_types9 = __esm({
+var init_types10 = __esm({
   "packages/core/dist/council/completion/types.js"() {
     "use strict";
   }
@@ -34198,7 +34381,7 @@ var init_buildCompletion = __esm({
 var init_completion2 = __esm({
   "packages/core/dist/council/completion/index.js"() {
     "use strict";
-    init_types9();
+    init_types10();
     init_buildCompletion();
   }
 });
@@ -34489,6 +34672,7 @@ __export(council_exports, {
   shouldRetryMember: () => shouldRetryMember,
   slugify: () => slugify2,
   stripClarificationProtocol: () => stripClarificationProtocol,
+  stripQuestionBlocks: () => stripQuestionBlocks,
   swapMembers: () => swapMembers,
   systemMessagesFromSplit: () => systemMessagesFromSplit,
   taskMatchesNfrKeywords: () => taskMatchesNfrKeywords,
@@ -34521,7 +34705,7 @@ var init_council = __esm({
 
 // packages/core/dist/memory/types.js
 var MEMORY_SCHEMA_VERSION, MEMORY_KINDS, MEMORY_STATUSES, MEMORY_RELATIONS, MEMORY_VISIBILITIES;
-var init_types10 = __esm({
+var init_types11 = __esm({
   "packages/core/dist/memory/types.js"() {
     "use strict";
     MEMORY_SCHEMA_VERSION = 1;
@@ -34572,7 +34756,7 @@ var init_schemas3 = __esm({
   "packages/core/dist/memory/schemas.js"() {
     "use strict";
     init_zod();
-    init_types10();
+    init_types11();
     isoDate = external_exports.string().datetime({ offset: true });
     unit = external_exports.number().finite().min(0).max(1);
     metadata = external_exports.record(external_exports.string(), external_exports.unknown()).refine((value) => {
@@ -35864,7 +36048,7 @@ var init_noop = __esm({
 var init_memory = __esm({
   "packages/core/dist/memory/index.js"() {
     "use strict";
-    init_types10();
+    init_types11();
     init_schemas3();
     init_scoring();
     init_policies();
@@ -36586,7 +36770,7 @@ var init_personas = __esm({
 
 // packages/core/dist/kraken/runtime/types.js
 var PlanError;
-var init_types11 = __esm({
+var init_types12 = __esm({
   "packages/core/dist/kraken/runtime/types.js"() {
     "use strict";
     PlanError = class extends Error {
@@ -36684,7 +36868,7 @@ var MAX_BUNDLE_BYTES, FORBIDDEN_TOKENS;
 var init_sandbox = __esm({
   "packages/core/dist/kraken/runtime/sandbox.js"() {
     "use strict";
-    init_types11();
+    init_types12();
     MAX_BUNDLE_BYTES = 256 * 1024;
     FORBIDDEN_TOKENS = [
       /\bprocess\b/,
@@ -36747,7 +36931,7 @@ var init_runner = __esm({
     "use strict";
     init_verdict();
     init_personas();
-    init_types11();
+    init_types12();
     DEFAULT_MAX_TENTACLES = 200;
     DEFAULT_PLAN_TIMEOUT_MS = 30 * 6e4;
     ScriptRunner = class {
@@ -36931,7 +37115,7 @@ var init_runner = __esm({
 var init_runtime2 = __esm({
   "packages/core/dist/kraken/runtime/index.js"() {
     "use strict";
-    init_types11();
+    init_types12();
     init_sandbox();
     init_runner();
   }
@@ -38031,7 +38215,7 @@ var CORE_VERSION;
 var init_version = __esm({
   "packages/core/dist/version.js"() {
     "use strict";
-    CORE_VERSION = "2.33.1";
+    CORE_VERSION = "2.34.1";
   }
 });
 
@@ -38543,6 +38727,7 @@ __export(dist_exports, {
   strictBuildGate: () => strictBuildGate,
   stripAnsi: () => stripAnsi,
   stripClarificationProtocol: () => stripClarificationProtocol,
+  stripQuestionBlocks: () => stripQuestionBlocks,
   swapMembers: () => swapMembers,
   systemMessagesFromSplit: () => systemMessagesFromSplit,
   taskMatchesNfrKeywords: () => taskMatchesNfrKeywords,
@@ -44033,6 +44218,7 @@ __export(krakenModel_exports, {
   inferModelFamily: () => inferModelFamily,
   isCheapModelId: () => isCheapModelId,
   isKrakenAutoModelEnabled: () => isKrakenAutoModelEnabled,
+  isUnknownModelError: () => isUnknownModelError,
   parseQualifiedModelRef: () => parseQualifiedModelRef,
   pickCheapModel: () => pickCheapModel,
   pickDifferentFamily: () => pickDifferentFamily,
@@ -44144,6 +44330,12 @@ function resolveKrakenSubModel(agent, parentModel, env = process.env, opts = {})
   }
   return parentModel;
 }
+function isUnknownModelError(message) {
+  if (!message) return false;
+  const m = message.toLowerCase();
+  if (!/model/.test(m)) return false;
+  return /http\s*404/.test(m) || /not-found/.test(m) || /not_found/.test(m) || /does not exist/.test(m) || /unknown model/.test(m) || /model_not_found/.test(m);
+}
 function resolveKrakenPlannerModel(parentModel, env = process.env) {
   const specific = env.ZELARI_KRAKEN_PLANNER_MODEL?.trim();
   if (specific) return specific;
@@ -45943,6 +46135,12 @@ ${failed.error ?? "unknown error"}`,
 // src/cli/tools/taskTool.ts
 import { existsSync as existsSync26 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
+function permissionsForTaskAgent(agent) {
+  const kind2 = agent ?? "explore";
+  if (kind2 === "general") return ["read", "write", "execute", "network"];
+  if (kind2 === "verify") return ["read", "execute", "network"];
+  return ["read"];
+}
 function resetTaskSpawnCount() {
   const g = globalThis;
   g.__zelariTaskSpawnCount = 0;
@@ -46009,6 +46207,27 @@ ${findings || "(the reviewer reported FAIL without detail)"}`;
 async function runAutoVerifyAfterGeneral(opts) {
   const g = globalThis;
   g.__zelariGeneralVerifyDebt = { description: opts.original.description };
+  const emitVerifyPhase = (detail2, ok) => {
+    const agentId = opts.general.agentId;
+    if (agentId) {
+      opts.deps.onTentacleEvent?.({
+        type: "agent_status",
+        agentId,
+        status: "running",
+        message: detail2,
+        id: randomUUID4(),
+        sessionId: opts.sessionId,
+        ts: Date.now()
+      });
+    }
+    appendKrakenRadio(opts.parentCwd, opts.sessionId, {
+      kind: "progress",
+      agent: "verify",
+      description: `verify: ${opts.original.description}`,
+      detail: detail2,
+      ...ok === void 0 ? {} : { ok }
+    });
+  };
   const inheritedCwd = opts.general.worktreePath && existsSync26(opts.general.worktreePath) ? opts.general.worktreePath : void 0;
   const runVerify = (label) => runTentacle({
     deps: opts.deps,
@@ -46025,6 +46244,7 @@ async function runAutoVerifyAfterGeneral(opts) {
     sessionId: opts.sessionId,
     ...opts.signal ? { signal: opts.signal } : {}
   });
+  emitVerifyPhase("verifying\u2026");
   let verify = await runVerify(`verify: ${opts.original.description}`);
   let verdict = verify.ok ? parseVerifyVerdict(verify.result).verdict : "unknown";
   let findings = verify.ok ? parseVerifyVerdict(verify.result).findings : "";
@@ -46072,10 +46292,15 @@ async function runAutoVerifyAfterGeneral(opts) {
   }
   if (verdict === "pass") {
     g.__zelariGeneralVerifyDebt = null;
+    emitVerifyPhase("verify PASS", true);
     return `
 
 [kraken:auto-verify] verify PASS \u2014 general\u21D2verify obligation satisfied.`;
   }
+  emitVerifyPhase(
+    verdict === "fail" ? "verify FAIL" : verify.ok ? "verify unknown" : "verify failed",
+    verdict === "fail" || !verify.ok ? false : void 0
+  );
   const detail = verdict === "fail" ? `verify FAIL unresolved (rework budget spent): ${findings || "no findings reported"}` : verify.ok ? "verify produced no parseable VERDICT \u2014 unverified" : `verify tentacle failed: ${verify.error}`;
   g.__zelariGeneralVerifyDebt = { description: opts.original.description, detail };
   appendKrakenRadio(opts.parentCwd, opts.sessionId, {
@@ -46231,6 +46456,11 @@ async function runSubAgent(harness, opts = {}) {
     signal?.removeEventListener("abort", onAbort);
   }
 }
+function shortWorktreeCaption(p3) {
+  const parts = p3.split(/[\\/]/).filter(Boolean);
+  const short2 = parts.length > 2 ? `.../${parts.slice(-2).join("/")}` : p3;
+  return short2.length > 50 ? `...${short2.slice(-47)}` : short2;
+}
 async function runTentacle(opts) {
   const { deps, args, agent, thoroughness, parentCwd, sessionId: sessionId2 } = opts;
   const started = Date.now();
@@ -46327,6 +46557,18 @@ async function runTentacle(opts) {
     ts: Date.now()
   });
   emitActivity({ type: "agent_status", agentId: liveId, status: "running", ts: Date.now() });
+  const emitPhase = (message) => {
+    emitActivity({ type: "agent_status", agentId: liveId, status: "running", message, ts: Date.now() });
+    appendKrakenRadio(parentCwd, sessionId2, {
+      kind: "progress",
+      agent,
+      thoroughness,
+      description: args.description,
+      detail: message
+    });
+  };
+  emitPhase(`phase: ${agent}`);
+  if (worktree) emitPhase(`worktree: ${shortWorktreeCaption(worktree.path)}`);
   const taskUserContent = buildTaskUserPrompt({
     prompt: args.prompt,
     scope: args.scope,
@@ -46380,17 +46622,45 @@ ${taskUserContent}`,
     };
   }
   const startedTools = /* @__PURE__ */ new Map();
-  const { result, error: error51, aborted: aborted2, usage, toolTrace } = await runSubAgent(harness, {
+  const onHarnessEvent = (ev) => {
+    if (ev.type === "tool_execution_start") {
+      startedTools.set(ev.toolCallId, ev.toolName);
+      emitActivity({ type: "agent_tool", agentId: liveId, toolCallId: ev.toolCallId, tool: ev.toolName, status: "started", ...ev.args ? { summary: toolCommandHint(ev.args) } : {}, ts: Date.now() });
+    } else if (ev.type === "tool_execution_end") {
+      emitActivity({ type: "agent_tool", agentId: liveId, toolCallId: ev.toolCallId, tool: startedTools.get(ev.toolCallId) ?? "unknown", status: ev.isError ? "failed" : "completed", durationMs: ev.durationMs, ts: Date.now() });
+    }
+  };
+  let { result, error: error51, aborted: aborted2, usage, toolTrace } = await runSubAgent(harness, {
     ...opts.signal ? { signal: opts.signal } : {},
-    onEvent: (ev) => {
-      if (ev.type === "tool_execution_start") {
-        startedTools.set(ev.toolCallId, ev.toolName);
-        emitActivity({ type: "agent_tool", agentId: liveId, toolCallId: ev.toolCallId, tool: ev.toolName, status: "started", ...ev.args ? { summary: toolCommandHint(ev.args) } : {}, ts: Date.now() });
-      } else if (ev.type === "tool_execution_end") {
-        emitActivity({ type: "agent_tool", agentId: liveId, toolCallId: ev.toolCallId, tool: startedTools.get(ev.toolCallId) ?? "unknown", status: ev.isError ? "failed" : "completed", durationMs: ev.durationMs, ts: Date.now() });
+    onEvent: onHarnessEvent
+  });
+  if (!aborted2 && !result && sub.fallback && sub.fallback.model !== sub.model) {
+    const { isUnknownModelError: isUnknownModelError2 } = await Promise.resolve().then(() => (init_krakenModel(), krakenModel_exports));
+    if (isUnknownModelError2(error51)) {
+      emitPhase(`model ${sub.model} unavailable \u2014 retrying with ${sub.fallback.model}`);
+      const retryConfig = {
+        ...config2,
+        model: sub.fallback.model,
+        provider: sub.fallback.provider,
+        providerStream: sub.fallback.providerStream
+      };
+      try {
+        harness = deps.harnessFactory ? deps.harnessFactory(retryConfig) : new (await Promise.resolve().then(() => (init_harness(), harness_exports))).AgentHarness(retryConfig);
+        const retry = await runSubAgent(harness, {
+          ...opts.signal ? { signal: opts.signal } : {},
+          onEvent: onHarnessEvent
+        });
+        result = retry.result;
+        error51 = retry.error;
+        aborted2 = retry.aborted;
+        usage = retry.usage;
+        toolTrace = retry.toolTrace;
+        sub = { ...sub, model: sub.fallback.model, provider: sub.fallback.provider };
+      } catch (err) {
+        error51 = err instanceof Error ? err.message : String(err);
       }
     }
-  });
+  }
   const durationMs = Date.now() - started;
   if (aborted2) {
     if (worktree && !shouldKeepWorktree()) await cleanupKrakenWorktree(worktree);
@@ -46441,6 +46711,7 @@ worktree deferred: branch=${worktree.branch} path=${worktree.path} (executor mer
   } else if (worktree) {
     let merge2 = null;
     if (!kept && isKrakenWorktreeAutoMergeEnabled()) {
+      emitPhase("merging\u2026");
       try {
         merge2 = await mergeKrakenWorktree(
           worktree,
@@ -46454,6 +46725,7 @@ worktree deferred: branch=${worktree.branch} path=${worktree.path} (executor mer
           message: `merge threw: ${err instanceof Error ? err.message : String(err)}`
         };
       }
+      emitPhase(merge2.ok ? "merge ok" : "merge failed");
     } else if (!kept) {
       await cleanupKrakenWorktree(worktree);
     }
@@ -46517,6 +46789,7 @@ ${verifyHintForGeneral(args.acceptance)}`;
     ok: true,
     agent,
     thoroughness,
+    agentId: liveId,
     model: sub.model,
     result,
     footer,
@@ -53952,6 +54225,7 @@ function createBuiltinToolRegistry(options = {}) {
           // registry's own policy (permPolicy above) — they can never
           // exceed it.
           parentPolicy: permPolicy,
+          ...options.onPermissionAsk ? { onPermissionAsk: options.onPermissionAsk } : {},
           ...options.subAgentProvider ? { provider: options.subAgentProvider } : {},
           ...options.subAgentModel ? { model: options.subAgentModel } : {}
         }),
@@ -54051,12 +54325,13 @@ function taskAgentToProfile(agent) {
   return "explore";
 }
 function createKrakenSubAgentContextFactory(opts) {
-  const { root, audit, sessionId: sessionId2, provider: providerOverride, model: modelOverride, parentPolicy } = opts;
+  const { root, audit, sessionId: sessionId2, provider: providerOverride, model: modelOverride, parentPolicy, onPermissionAsk } = opts;
   return async ({ agent, cwd: subCwd }) => {
     const cfg = providerOverride ? await providerConfigFor(providerOverride) : await providerFromEnv();
     if (!cfg) return null;
     const { resolveKrakenSubModel: resolveKrakenSubModel2, parseQualifiedModelRef: parseQualifiedModelRef2 } = await Promise.resolve().then(() => (init_krakenModel(), krakenModel_exports));
-    const resolvedModel = resolveKrakenSubModel2(agent, modelOverride || cfg.model);
+    const parentModel = modelOverride || cfg.model;
+    const resolvedModel = resolveKrakenSubModel2(agent, parentModel);
     let effCfg = cfg;
     let model = resolvedModel;
     const ref = parseQualifiedModelRef2(resolvedModel);
@@ -54085,6 +54360,7 @@ function createKrakenSubAgentContextFactory(opts) {
       diagnostics: false,
       lspProvider: null,
       permissionPolicy: effectiveSubPolicy,
+      ...onPermissionAsk ? { onPermissionAsk } : {},
       // P0.5: the tentacle's agent identity drives per-agent policy rules.
       policyAgent: agent
     });
@@ -54092,6 +54368,13 @@ function createKrakenSubAgentContextFactory(opts) {
       providerStream: buildProviderStream(subCfg),
       model,
       provider: subCfg.providerId,
+      ...model !== parentModel ? {
+        fallback: {
+          model: parentModel,
+          provider: cfg.providerId,
+          providerStream: buildProviderStream({ ...cfg, model: parentModel })
+        }
+      } : {},
       registry: subRegistry,
       tools: subRegistry.toOpenAITools().map((t) => ({
         name: t.function.name,
@@ -54111,11 +54394,14 @@ function wrapWithPermissions(original, policy, onAsk, agentLayers, precedence =
   return {
     ...original,
     execute: async (input, ctx) => {
-      const decision = resolveToolPermission(original.name, required2, policy);
+      const requiredNow = original.name === "task" ? permissionsForTaskAgent(
+        input?.agent
+      ) : required2;
+      const decision = resolveToolPermission(original.name, requiredNow, policy);
       const rule = agentLayers ? matchAgentPolicyRuleLayered(
         agentLayers,
         precedence,
-        required2,
+        requiredNow,
         input ?? {},
         root ?? process.cwd()
       ) : null;
@@ -54127,25 +54413,25 @@ function wrapWithPermissions(original, policy, onAsk, agentLayers, precedence =
         root ?? process.cwd()
       ) : void 0;
       const contractRule = matchContractCapabilityRule(
-        required2,
+        requiredNow,
         input ?? {},
         root ?? process.cwd()
       );
       let action = intersectEffects(mergeRuleEffect(decision.action, rule), claims?.effect, contractRule?.effect);
       let actionReason = decision.reason;
-      if (action !== "deny" && (required2.includes("write") || required2.includes("execute"))) {
+      if (action !== "deny" && (requiredNow.includes("write") || requiredNow.includes("execute"))) {
         const provHit = provenanceMatchIn(JSON.stringify(input ?? {}));
-        if (provHit && provenanceAppliesTo(provHit.source, required2)) {
+        if (provHit && provenanceAppliesTo(provHit.source, requiredNow)) {
           const provNote = `[provenance] args embed non-user ${provHit.source} content (via ${provHit.tool})`;
           if (action === "allow") {
             action = "ask";
-            actionReason = `${provNote} \u2014 confirm before ${required2.join("+")}`;
+            actionReason = `${provNote} \u2014 confirm before ${requiredNow.join("+")}`;
           } else {
             actionReason = `${decision.reason} \xB7 ${provNote}`;
           }
         }
       }
-      if (action === "allow" && required2.includes("execute") && activePermissionPreset() !== "yolo" && !isSessionGranted(original.name, required2)) {
+      if (action === "allow" && requiredNow.includes("execute") && activePermissionPreset() !== "yolo" && !isSessionGranted(original.name, requiredNow)) {
         const destructiveHit = destructiveCommandHit(input ?? {});
         if (destructiveHit) {
           action = "ask";
@@ -54188,7 +54474,7 @@ function wrapWithPermissions(original, policy, onAsk, agentLayers, precedence =
         }
       }
       const outcome = await original.execute(input, ctx);
-      recordResultForProvenance(original.name, required2, outcome);
+      recordResultForProvenance(original.name, requiredNow, outcome);
       return outcome;
     }
   };
@@ -55524,6 +55810,25 @@ var init_spineTelemetry = __esm({
   }
 });
 
+// src/cli/hooks/askUserTimeout.ts
+function askUserTimeoutMs() {
+  const raw = process.env.ZELARI_ASK_USER_TIMEOUT_MS?.trim();
+  if (!raw) return 3e5;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 0) return 3e5;
+  return n;
+}
+function armPickerTimeout(onFire, ms) {
+  if (ms <= 0) return () => void 0;
+  const id3 = setTimeout(onFire, ms);
+  return () => clearTimeout(id3);
+}
+var init_askUserTimeout = __esm({
+  "src/cli/hooks/askUserTimeout.ts"() {
+    "use strict";
+  }
+});
+
 // src/cli/state/fileStateStore.ts
 import { createHash as createHash17, randomUUID as randomUUID5 } from "node:crypto";
 import { promises as fs26 } from "node:fs";
@@ -60910,7 +61215,8 @@ async function* dispatchCouncil(userMessage, options) {
     maxToolLoopIterations: options.maxToolLoopIterations,
     maxToolLoopHardCap: options.maxToolLoopHardCap,
     skipSpecialists: options.skipSpecialists,
-    feedbackStore: options.feedbackStore
+    feedbackStore: options.feedbackStore,
+    signal: options.signal
   };
   if (!options.disableWorkspaceTools) {
     const { setWorkspaceStubs: setWorkspaceStubs2 } = await Promise.resolve().then(() => (init_skills2(), skills_exports));
@@ -62668,6 +62974,13 @@ async function runZelariMission(userMessage, brief, deps) {
   let forcePivot = false;
   const missionStartMs = now().getTime();
   while (true) {
+    if (deps.signal?.aborted) {
+      state3.status = "cancelled";
+      state3.updatedAt = now().toISOString();
+      await persist();
+      deps.emit("[zelari] missione cancellata.");
+      return state3;
+    }
     const runMode = pendingDesign ? "design-phase" : "implementation";
     if (runMode === "implementation") {
       deps.onMissionPhase?.("build", `impl-${implStep + 1}`);
@@ -62724,6 +63037,13 @@ async function runZelariMission(userMessage, brief, deps) {
       );
       return state3;
     }
+    if (deps.signal?.aborted) {
+      state3.status = "cancelled";
+      state3.updatedAt = now().toISOString();
+      await persist();
+      deps.emit("[zelari] missione cancellata.");
+      return state3;
+    }
     if (typeof result.costUsd === "number") cumulativeCostUsd += result.costUsd;
     if (typeof result.costTokens === "number") cumulativeTokens += result.costTokens;
     await deps.memory.add(
@@ -65842,11 +66162,12 @@ var init_facts = __esm({
 });
 
 // src/cli/utils/streamScrub.ts
-function createStreamScrubber2() {
+function createStreamScrubber2(opts = {}) {
+  const stripQuestion = opts.stripQuestion !== false;
   let rawBuf = "";
   let emittedLen = 0;
   const snapshot = () => {
-    const cleaned = cleanAgentContent(rawBuf);
+    const cleaned = cleanAgentContent(rawBuf, { stripQuestion });
     if (cleaned.length <= emittedLen) return "";
     const delta = cleaned.slice(emittedLen);
     emittedLen = cleaned.length;
@@ -66084,6 +66405,330 @@ var init_harnessStateEmit = __esm({
   }
 });
 
+// src/cli/serve/sessionControl.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function runWithSession(sessionId2, fn) {
+  return dispatchContext.run({ sessionId: sessionId2, token: {} }, fn);
+}
+function registerLiveTurnControl(control) {
+  const store6 = dispatchContext.getStore();
+  if (!store6) return void 0;
+  const registered = { ...control, token: store6.token };
+  liveTurns.set(store6.sessionId, registered);
+  return () => {
+    if (liveTurns.get(store6.sessionId) === registered) {
+      liveTurns.delete(store6.sessionId);
+    }
+  };
+}
+function getLiveTurnControl(sessionId2) {
+  return liveTurns.get(sessionId2);
+}
+function clearSessionTurnControl(sessionId2) {
+  const store6 = dispatchContext.getStore();
+  if (!store6 || store6.sessionId !== sessionId2) return;
+  const registered = liveTurns.get(sessionId2);
+  if (registered && registered.token === store6.token) {
+    liveTurns.delete(sessionId2);
+  }
+}
+var dispatchContext, liveTurns;
+var init_sessionControl = __esm({
+  "src/cli/serve/sessionControl.ts"() {
+    "use strict";
+    dispatchContext = new AsyncLocalStorage();
+    liveTurns = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/cli/headless/controlReader.ts
+function parseControlEvent(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { ok: false, id: "", reason: "control event must be a JSON object" };
+  }
+  const candidate = raw;
+  const type = candidate["type"];
+  if (typeof type !== "string" || !CONTROL_TYPES.has(type)) {
+    return {
+      ok: false,
+      id: typeof candidate["id"] === "string" ? candidate["id"] : "",
+      reason: `unknown control type: ${String(type)}`
+    };
+  }
+  if (typeof candidate["id"] !== "string" || candidate["id"].length === 0) {
+    return { ok: false, id: "", reason: "missing control id" };
+  }
+  if (type === "steer" || type === "follow_up") {
+    if (typeof candidate["text"] !== "string" || candidate["text"].trim().length === 0) {
+      return {
+        ok: false,
+        id: candidate["id"],
+        reason: `${type} requires a non-empty "text" field`
+      };
+    }
+  }
+  if (type === "cancel" && "reason" in candidate && candidate["reason"] !== void 0 && typeof candidate["reason"] !== "string") {
+    return {
+      ok: false,
+      id: candidate["id"],
+      reason: "cancel reason must be a string"
+    };
+  }
+  return {
+    ok: true,
+    event: {
+      ...candidate,
+      ts: typeof candidate["ts"] === "number" ? candidate["ts"] : Date.now()
+    }
+  };
+}
+function parseControlLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return null;
+  try {
+    return parseControlEvent(JSON.parse(trimmed));
+  } catch (e) {
+    return { ok: false, id: "", reason: `malformed JSON: ${e.message}` };
+  }
+}
+function startControlReader(input, onLine) {
+  let buffer = "";
+  const onData = (chunk) => {
+    buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line.trim().length > 0) onLine(line.replace(/\r$/, ""));
+      newlineIndex = buffer.indexOf("\n");
+    }
+  };
+  input.on("data", onData);
+  return () => {
+    input.removeListener("data", onData);
+    buffer = "";
+  };
+}
+var CONTROL_TYPES;
+var init_controlReader = __esm({
+  "src/cli/headless/controlReader.ts"() {
+    "use strict";
+    CONTROL_TYPES = /* @__PURE__ */ new Set([
+      "steer",
+      "follow_up",
+      "cancel",
+      "pause",
+      "resume"
+    ]);
+  }
+});
+
+// src/cli/headless/protocol.ts
+function protocolInfoEvent() {
+  return {
+    type: "protocol_info",
+    version: HEADLESS_PROTOCOL_VERSION,
+    capabilities: HEADLESS_PROTOCOL_CAPABILITIES,
+    ts: Date.now()
+  };
+}
+function controlAcceptedEvent(controlId, controlType) {
+  return {
+    type: "control_accepted",
+    controlId,
+    controlType,
+    ts: Date.now()
+  };
+}
+function controlAppliedEvent(controlId, controlType, boundary) {
+  return {
+    type: "control_applied",
+    controlId,
+    controlType,
+    boundary,
+    ts: Date.now()
+  };
+}
+function controlRejectedEvent(controlId, reason) {
+  return {
+    type: "control_rejected",
+    controlId,
+    reason,
+    ts: Date.now()
+  };
+}
+var HEADLESS_PROTOCOL_VERSION, HEADLESS_PROTOCOL_CAPABILITIES;
+var init_protocol2 = __esm({
+  "src/cli/headless/protocol.ts"() {
+    "use strict";
+    HEADLESS_PROTOCOL_VERSION = 2;
+    HEADLESS_PROTOCOL_CAPABILITIES = [
+      "stdin-control",
+      "steer",
+      "follow_up",
+      "cancel"
+    ];
+  }
+});
+
+// src/cli/headless/controlBridge.ts
+function attachControlPlane(opts) {
+  const { input, queue, emit, onCancel } = opts;
+  let finalized = false;
+  queue.onDrained = (events) => {
+    for (const event of events) {
+      emit(
+        controlAppliedEvent(
+          event.id,
+          event.type,
+          APPLIED_BOUNDARY[event.type] ?? "unknown"
+        )
+      );
+    }
+    const cancels = events.filter((e) => e.type === "cancel");
+    if (cancels.length > 0 && onCancel) {
+      const last = cancels[cancels.length - 1];
+      onCancel(last.type === "cancel" ? last.reason : void 0);
+    }
+  };
+  const disposeReader = startControlReader(input, (line) => {
+    const outcome = parseControlLine(line);
+    if (outcome === null) return;
+    if (!outcome.ok) {
+      emit(controlRejectedEvent(outcome.id, outcome.reason));
+      return;
+    }
+    const event = outcome.event;
+    if (event.type === "pause" || event.type === "resume") {
+      emit(
+        controlRejectedEvent(event.id, `${event.type} is not supported yet`)
+      );
+      return;
+    }
+    if (finalized) {
+      if (event.type === "steer") {
+        const converted = toFollowUp(event);
+        queue.enqueue(converted);
+        emit(controlAppliedEvent(event.id, "steer", "converted-to-follow-up"));
+        emit(controlAcceptedEvent(converted.id, "follow_up"));
+      } else if (event.type === "follow_up") {
+        queue.enqueue(event);
+        emit(controlAcceptedEvent(event.id, "follow_up"));
+      } else {
+        emit(controlRejectedEvent(event.id, "run already finished"));
+      }
+      return;
+    }
+    queue.enqueue(event);
+    emit(controlAcceptedEvent(event.id, event.type));
+  });
+  return {
+    dispose() {
+      disposeReader();
+      queue.onDrained = void 0;
+    },
+    finalize() {
+      finalized = true;
+      const lateSteers = queue.drainSteers();
+      for (const steer of lateSteers) {
+        queue.enqueue(toFollowUp(steer));
+        emit(controlAppliedEvent(steer.id, "steer", "converted-to-follow-up"));
+      }
+      const followUps = queue.drainFollowUps();
+      for (const followUp of followUps) {
+        emit(controlAppliedEvent(followUp.id, "follow_up", "run-end"));
+      }
+      return followUps.map((f) => f.text);
+    },
+    get finalized() {
+      return finalized;
+    }
+  };
+}
+function toFollowUp(steer) {
+  return {
+    type: "follow_up",
+    id: `fu-${steer.id}`,
+    text: steer.text,
+    ts: steer.ts
+  };
+}
+var APPLIED_BOUNDARY;
+var init_controlBridge = __esm({
+  "src/cli/headless/controlBridge.ts"() {
+    "use strict";
+    init_controlReader();
+    init_protocol2();
+    APPLIED_BOUNDARY = {
+      steer: "turn-end",
+      follow_up: "run-end",
+      cancel: "cancel"
+    };
+  }
+});
+
+// src/cli/headless/liveTurnAbort.ts
+function attachHeadlessLiveCancel(opts) {
+  const abort = new AbortController();
+  const controlQueue = new RuntimeControlQueue();
+  const cancel = () => {
+    if (!abort.signal.aborted) abort.abort();
+    return true;
+  };
+  const controlPlane = opts?.output === "json" && process.stdin.isTTY !== true && process.env.ZELARI_SERVE_HARNESS !== "1" ? (() => {
+    emitEvent(protocolInfoEvent());
+    return attachControlPlane({
+      input: process.stdin,
+      queue: controlQueue,
+      emit: emitEvent,
+      onCancel: () => {
+        cancel();
+      }
+    });
+  })() : void 0;
+  const unregister = process.env.ZELARI_SERVE_HARNESS === "1" ? registerLiveTurnControl({
+    queue: controlQueue,
+    cancel
+  }) : void 0;
+  if (unregister) {
+    const appliedBoundary = {
+      steer: "turn-end",
+      follow_up: "run-end",
+      cancel: "cancel"
+    };
+    controlQueue.onDrained = (events) => {
+      for (const event of events) {
+        emitEvent(
+          controlAppliedEvent(
+            event.id,
+            event.type,
+            appliedBoundary[event.type] ?? "unknown"
+          )
+        );
+      }
+    };
+  }
+  return {
+    signal: abort.signal,
+    cancel,
+    dispose() {
+      controlPlane?.finalize();
+      controlPlane?.dispose();
+      unregister?.();
+    }
+  };
+}
+var init_liveTurnAbort = __esm({
+  "src/cli/headless/liveTurnAbort.ts"() {
+    "use strict";
+    init_runtime();
+    init_sessionControl();
+    init_controlBridge();
+    init_protocol2();
+    init_headless();
+  }
+});
+
 // src/cli/headless/policyGate.ts
 import { isAbsolute as isAbsolute5, resolve as resolve7 } from "node:path";
 import { randomUUID as randomUUID9 } from "node:crypto";
@@ -66296,268 +66941,6 @@ var init_verifierLifecycle = __esm({
   }
 });
 
-// src/cli/headless/controlReader.ts
-function parseControlEvent(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return { ok: false, id: "", reason: "control event must be a JSON object" };
-  }
-  const candidate = raw;
-  const type = candidate["type"];
-  if (typeof type !== "string" || !CONTROL_TYPES.has(type)) {
-    return {
-      ok: false,
-      id: typeof candidate["id"] === "string" ? candidate["id"] : "",
-      reason: `unknown control type: ${String(type)}`
-    };
-  }
-  if (typeof candidate["id"] !== "string" || candidate["id"].length === 0) {
-    return { ok: false, id: "", reason: "missing control id" };
-  }
-  if (type === "steer" || type === "follow_up") {
-    if (typeof candidate["text"] !== "string" || candidate["text"].trim().length === 0) {
-      return {
-        ok: false,
-        id: candidate["id"],
-        reason: `${type} requires a non-empty "text" field`
-      };
-    }
-  }
-  if (type === "cancel" && "reason" in candidate && candidate["reason"] !== void 0 && typeof candidate["reason"] !== "string") {
-    return {
-      ok: false,
-      id: candidate["id"],
-      reason: "cancel reason must be a string"
-    };
-  }
-  return {
-    ok: true,
-    event: {
-      ...candidate,
-      ts: typeof candidate["ts"] === "number" ? candidate["ts"] : Date.now()
-    }
-  };
-}
-function parseControlLine(line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0) return null;
-  try {
-    return parseControlEvent(JSON.parse(trimmed));
-  } catch (e) {
-    return { ok: false, id: "", reason: `malformed JSON: ${e.message}` };
-  }
-}
-function startControlReader(input, onLine) {
-  let buffer = "";
-  const onData = (chunk) => {
-    buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-    let newlineIndex = buffer.indexOf("\n");
-    while (newlineIndex !== -1) {
-      const line = buffer.slice(0, newlineIndex);
-      buffer = buffer.slice(newlineIndex + 1);
-      if (line.trim().length > 0) onLine(line.replace(/\r$/, ""));
-      newlineIndex = buffer.indexOf("\n");
-    }
-  };
-  input.on("data", onData);
-  return () => {
-    input.removeListener("data", onData);
-    buffer = "";
-  };
-}
-var CONTROL_TYPES;
-var init_controlReader = __esm({
-  "src/cli/headless/controlReader.ts"() {
-    "use strict";
-    CONTROL_TYPES = /* @__PURE__ */ new Set([
-      "steer",
-      "follow_up",
-      "cancel",
-      "pause",
-      "resume"
-    ]);
-  }
-});
-
-// src/cli/headless/protocol.ts
-function protocolInfoEvent() {
-  return {
-    type: "protocol_info",
-    version: HEADLESS_PROTOCOL_VERSION,
-    capabilities: HEADLESS_PROTOCOL_CAPABILITIES,
-    ts: Date.now()
-  };
-}
-function controlAcceptedEvent(controlId, controlType) {
-  return {
-    type: "control_accepted",
-    controlId,
-    controlType,
-    ts: Date.now()
-  };
-}
-function controlAppliedEvent(controlId, controlType, boundary) {
-  return {
-    type: "control_applied",
-    controlId,
-    controlType,
-    boundary,
-    ts: Date.now()
-  };
-}
-function controlRejectedEvent(controlId, reason) {
-  return {
-    type: "control_rejected",
-    controlId,
-    reason,
-    ts: Date.now()
-  };
-}
-var HEADLESS_PROTOCOL_VERSION, HEADLESS_PROTOCOL_CAPABILITIES;
-var init_protocol2 = __esm({
-  "src/cli/headless/protocol.ts"() {
-    "use strict";
-    HEADLESS_PROTOCOL_VERSION = 2;
-    HEADLESS_PROTOCOL_CAPABILITIES = [
-      "stdin-control",
-      "steer",
-      "follow_up",
-      "cancel"
-    ];
-  }
-});
-
-// src/cli/headless/controlBridge.ts
-function attachControlPlane(opts) {
-  const { input, queue, emit, onCancel } = opts;
-  let finalized = false;
-  queue.onDrained = (events) => {
-    for (const event of events) {
-      emit(
-        controlAppliedEvent(
-          event.id,
-          event.type,
-          APPLIED_BOUNDARY[event.type] ?? "unknown"
-        )
-      );
-    }
-    const cancels = events.filter((e) => e.type === "cancel");
-    if (cancels.length > 0 && onCancel) {
-      const last = cancels[cancels.length - 1];
-      onCancel(last.type === "cancel" ? last.reason : void 0);
-    }
-  };
-  const disposeReader = startControlReader(input, (line) => {
-    const outcome = parseControlLine(line);
-    if (outcome === null) return;
-    if (!outcome.ok) {
-      emit(controlRejectedEvent(outcome.id, outcome.reason));
-      return;
-    }
-    const event = outcome.event;
-    if (event.type === "pause" || event.type === "resume") {
-      emit(
-        controlRejectedEvent(event.id, `${event.type} is not supported yet`)
-      );
-      return;
-    }
-    if (finalized) {
-      if (event.type === "steer") {
-        const converted = toFollowUp(event);
-        queue.enqueue(converted);
-        emit(controlAppliedEvent(event.id, "steer", "converted-to-follow-up"));
-        emit(controlAcceptedEvent(converted.id, "follow_up"));
-      } else if (event.type === "follow_up") {
-        queue.enqueue(event);
-        emit(controlAcceptedEvent(event.id, "follow_up"));
-      } else {
-        emit(controlRejectedEvent(event.id, "run already finished"));
-      }
-      return;
-    }
-    queue.enqueue(event);
-    emit(controlAcceptedEvent(event.id, event.type));
-  });
-  return {
-    dispose() {
-      disposeReader();
-      queue.onDrained = void 0;
-    },
-    finalize() {
-      finalized = true;
-      const lateSteers = queue.drainSteers();
-      for (const steer of lateSteers) {
-        queue.enqueue(toFollowUp(steer));
-        emit(controlAppliedEvent(steer.id, "steer", "converted-to-follow-up"));
-      }
-      const followUps = queue.drainFollowUps();
-      for (const followUp of followUps) {
-        emit(controlAppliedEvent(followUp.id, "follow_up", "run-end"));
-      }
-      return followUps.map((f) => f.text);
-    },
-    get finalized() {
-      return finalized;
-    }
-  };
-}
-function toFollowUp(steer) {
-  return {
-    type: "follow_up",
-    id: `fu-${steer.id}`,
-    text: steer.text,
-    ts: steer.ts
-  };
-}
-var APPLIED_BOUNDARY;
-var init_controlBridge = __esm({
-  "src/cli/headless/controlBridge.ts"() {
-    "use strict";
-    init_controlReader();
-    init_protocol2();
-    APPLIED_BOUNDARY = {
-      steer: "turn-end",
-      follow_up: "run-end",
-      cancel: "cancel"
-    };
-  }
-});
-
-// src/cli/serve/sessionControl.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-function runWithSession(sessionId2, fn) {
-  return dispatchContext.run({ sessionId: sessionId2, token: {} }, fn);
-}
-function registerLiveTurnControl(control) {
-  const store6 = dispatchContext.getStore();
-  if (!store6) return void 0;
-  const registered = { ...control, token: store6.token };
-  liveTurns.set(store6.sessionId, registered);
-  return () => {
-    if (liveTurns.get(store6.sessionId) === registered) {
-      liveTurns.delete(store6.sessionId);
-    }
-  };
-}
-function getLiveTurnControl(sessionId2) {
-  return liveTurns.get(sessionId2);
-}
-function clearSessionTurnControl(sessionId2) {
-  const store6 = dispatchContext.getStore();
-  if (!store6 || store6.sessionId !== sessionId2) return;
-  const registered = liveTurns.get(sessionId2);
-  if (registered && registered.token === store6.token) {
-    liveTurns.delete(sessionId2);
-  }
-}
-var dispatchContext, liveTurns;
-var init_sessionControl = __esm({
-  "src/cli/serve/sessionControl.ts"() {
-    "use strict";
-    dispatchContext = new AsyncLocalStorage();
-    liveTurns = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/cli/extensions/sandboxedFs.ts
 import { promises as fsp } from "node:fs";
 import path89 from "node:path";
@@ -66916,6 +67299,7 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
     // an interactive approval (permission.request over NDJSON) instead of
     // the fail-closed typedErr. Absent handler ⇒ unchanged fail-closed.
     ...opts.onPermissionAsk ? { onPermissionAsk: opts.onPermissionAsk } : {},
+    ...opts.onAskUser ? { onAskUser: opts.onAskUser } : {},
     permissionPolicy: defaultPermissionPolicy2(),
     ...nativeMemory ? { memoryService: nativeMemory } : {},
     memoryAutoWrite,
@@ -67142,7 +67526,7 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
     let finalReason = "completed";
     let exitCode = 0;
     const textBuffer = [];
-    const scrub = createStreamScrubber2();
+    const scrub = createStreamScrubber2({ stripQuestion: opts.output !== "json" });
     try {
       for await (const event of harness.run()) {
         progressRuntime.observe(event);
@@ -68684,6 +69068,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
           // ask without a UI fails closed), so this intersection actually
           // bites: tentacles can never exceed the preset.
           parentPolicy: defaultPermissionPolicy2(),
+          ...opts.onPermissionAsk ? { onPermissionAsk: opts.onPermissionAsk } : {},
           // Anchor every tentacle to the SAME provider/model this run
           // resolved (Desktop's selector, or --provider/--model), instead
           // of the persisted provider.json default the factory falls back
@@ -68800,6 +69185,8 @@ async function buildCouncilToolRegistry(planMode, opts, memoryService, memoryAut
     planMode,
     ...extras?.lspProvider ? { lspProvider: extras.lspProvider } : {},
     permissionPolicy: defaultPermissionPolicy2(),
+    ...opts?.onPermissionAsk ? { onPermissionAsk: opts.onPermissionAsk } : {},
+    ...opts?.onAskUser ? { onAskUser: opts.onAskUser } : {},
     ...memoryService ? { memoryService } : {},
     memoryAutoWrite
   });
@@ -68819,6 +69206,14 @@ async function buildCouncilToolRegistry(planMode, opts, memoryService, memoryAut
   return { toolRegistry, workspaceCtx: realCtx };
 }
 async function runHeadlessCouncil(opts, provider, model, providerStream, extras) {
+  const live = attachHeadlessLiveCancel({ output: opts.output });
+  try {
+    return await runHeadlessCouncilBody(opts, provider, model, providerStream, extras, live.signal);
+  } finally {
+    live.dispose();
+  }
+}
+async function runHeadlessCouncilBody(opts, provider, model, providerStream, extras, signal) {
   const { dispatchCouncil: dispatchCouncil2 } = await Promise.resolve().then(() => (init_councilDispatcher(), councilDispatcher_exports));
   const sessionId2 = crypto.randomUUID();
   const cwd = resolveHeadlessCwd(opts);
@@ -68894,7 +69289,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream, extras)
   const effectiveTask = buildCouncilTaskWithHistory(opts.task, historySeed);
   if (opts.task) spine.userMessage(effectiveTask);
   let exitCode = 0;
-  const scrub = createStreamScrubber2();
+  const scrub = createStreamScrubber2({ stripQuestion: opts.output !== "json" });
   let lastAssistantText = "";
   let currentAssistantText = "";
   try {
@@ -68929,6 +69324,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream, extras)
       tools: toolRegistry,
       feedbackStore,
       runMode: councilRunMode,
+      signal,
       // t23: an auto-SELECTED council runs the LITE tier (3 members) unless
       // ZELARI_COUNCIL_TIER / ZELARI_COUNCIL_SIZE explicitly opt into full.
       ...opts.orchestrationDecision?.strategy === "council" && process.env["ZELARI_COUNCIL_TIER"] === void 0 && process.env["ZELARI_COUNCIL_SIZE"] === void 0 ? { councilSize: COUNCIL_TIER_SIZES.lite } : {},
@@ -68987,7 +69383,9 @@ async function runHeadlessCouncil(opts, provider, model, providerStream, extras)
     return 2;
   }
   try {
-    await spine.close(exitCode === 0 ? "completed" : "error");
+    await spine.close(
+      signal.aborted ? "stopped" : exitCode === 0 ? "completed" : "error"
+    );
   } catch {
   }
   try {
@@ -68999,7 +69397,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream, extras)
         at: (/* @__PURE__ */ new Date()).toISOString(),
         mode: "shadow",
         taskClass: classifyTask2({ prompt: effectiveTask }).taskClass,
-        verdict: exitCode === 0 ? "PASS" : exitCode === 3 ? "FAIL" : "UNKNOWN"
+        verdict: signal.aborted ? "UNKNOWN" : exitCode === 0 ? "PASS" : exitCode === 3 ? "FAIL" : "UNKNOWN"
       });
     }
   } catch {
@@ -69018,7 +69416,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream, extras)
     } catch {
     }
   }
-  if (nativeMemory && memoryAutoWrite && lastAssistantText) {
+  if (nativeMemory && memoryAutoWrite && lastAssistantText && !signal.aborted) {
     try {
       await nativeMemory.remember({
         kind: councilRunMode === "design-phase" ? "decision" : "outcome",
@@ -69045,6 +69443,14 @@ async function runHeadlessCouncil(opts, provider, model, providerStream, extras)
   return exitCode;
 }
 async function runHeadlessZelari(opts, provider, model, providerStream, extras) {
+  const live = attachHeadlessLiveCancel({ output: opts.output });
+  try {
+    return await runHeadlessZelariBody(opts, provider, model, providerStream, extras, live.signal);
+  } finally {
+    live.dispose();
+  }
+}
+async function runHeadlessZelariBody(opts, provider, model, providerStream, extras, signal) {
   const projectRoot = resolveHeadlessCwd(opts);
   const sessionId2 = opts.resumeSessionId ?? crypto.randomUUID();
   const spine = await openHeadlessSpine({
@@ -69155,6 +69561,7 @@ ${JSON.stringify({ deliverable: brief.deliverableThisMission, mvp: brief.sliceMv
       memory,
       emit,
       buildViaAgent,
+      signal,
       onMissionPhase: (phase2, note) => spine.missionPhase(phase2, note),
       onMissionProgress: (advice, iteration) => spine.missionProgress({
         recommendation: advice.recommendation,
@@ -69180,7 +69587,7 @@ ${ragContext}` : slicePrompt;
           let writeCount = 0;
           let chairmanErrored = false;
           let membersCompleted = 0;
-          const scrub = createStreamScrubber2();
+          const scrub = createStreamScrubber2({ stripQuestion: opts.output !== "json" });
           const { composeProjectContext: composeProjectContext3 } = await Promise.resolve().then(() => (init_composeContext(), composeContext_exports));
           const { loadDurableContext: loadDurableContext3 } = await Promise.resolve().then(() => (init_loadDurableContext(), loadDurableContext_exports));
           const memOnly = ragContext?.trim() ? ragContext : void 0;
@@ -69203,6 +69610,7 @@ ${ragContext}` : slicePrompt;
             tools: toolRegistry,
             feedbackStore,
             runMode: effectiveRunMode,
+            signal,
             maxToolCallsChairman: chairmanBudget,
             ...implementerRetry ? { skipSpecialists: true } : {},
             workspaceContext: composed2.workspaceContext,
@@ -69250,11 +69658,20 @@ ${ragContext}` : slicePrompt;
           }
           let completionOk = false;
           let degraded = false;
+          if (signal.aborted) {
+            return {
+              completionOk: false,
+              ran: membersCompleted > 0 || synthesisText.length > 0,
+              synthesisText: synthesisText || void 0,
+              writeCount,
+              degraded: true
+            };
+          }
           try {
             const { detectDegradedRun: detectDegradedRun3 } = await Promise.resolve().then(() => (init_council(), council_exports));
             const d = detectDegradedRun3({
               chairmanErrored,
-              councilAborted: false,
+              councilAborted: signal.aborted,
               luciferWriteCount: writeCount,
               synthesisText,
               runMode: effectiveRunMode
@@ -69321,7 +69738,9 @@ ${ragContext}` : slicePrompt;
         const { registry: agentRegistry } = createBuiltinToolRegistry2({
           root: projectRoot,
           planMode: false,
-          permissionPolicy: defaultPermissionPolicy2()
+          permissionPolicy: defaultPermissionPolicy2(),
+          ...opts.onPermissionAsk ? { onPermissionAsk: opts.onPermissionAsk } : {},
+          ...opts.onAskUser ? { onAskUser: opts.onAskUser } : {}
         });
         await registerHeadlessMcp(agentRegistry, opts);
         const durableState = await loadDurableContext2(projectRoot);
@@ -69388,7 +69807,10 @@ ${ragContext}` : slicePrompt;
       }
     });
     if (state3.status === "error") exitCode = exitCode || 3;
-    else if (state3.status === "success") {
+    else if (state3.status === "cancelled") {
+      exitCode = 0;
+      spine.missionPhase("verification", "mission-cancelled");
+    } else if (state3.status === "success") {
       const missionGate = await evaluateStrictBuildGate("build", {
         emit: (input) => spine.appendEvent(input),
         surface: "mission",
@@ -69426,7 +69848,8 @@ ${ragContext}` : slicePrompt;
     }
     await memory.close().catch(() => void 0);
     try {
-      if (exitCode === 0) await spine.close("completed");
+      if (signal.aborted) await spine.close("stopped");
+      else if (exitCode === 0) await spine.close("completed");
       else await spine.close(exitCode === 2 ? "error" : "stopped");
     } catch {
     }
@@ -69473,6 +69896,7 @@ var init_runHeadless = __esm({
     init_metrics3();
     init_headlessSpine();
     init_harnessStateEmit();
+    init_liveTurnAbort();
     init_policyGate();
     init_policyLoadMode();
     init_runOneTurn();
@@ -71060,38 +71484,61 @@ function applyTurnPermissionPreset(input) {
   process.env[PRESET_ENV] = value;
   return true;
 }
+function isPermissionDecision(value) {
+  return typeof value === "string" && PERMISSION_DECISIONS.includes(value);
+}
 function createServePermissionBridge(write, timeoutMs2 = 12e4) {
   const pending = /* @__PURE__ */ new Map();
   let seq = 0;
-  const settle = (requestId, decision) => {
+  const settle = (requestId, decision, timedOut = false) => {
     const entry = pending.get(requestId);
     if (!entry) return false;
     pending.delete(requestId);
     clearTimeout(entry.timer);
+    write(
+      JSON.stringify({
+        type: "permission.settled",
+        requestId,
+        decision,
+        ...timedOut ? { timedOut: true } : {}
+      })
+    );
     entry.resolve(decision);
     return true;
   };
   return {
     onPermissionAsk(payload) {
       const requestId = `perm-${Date.now()}-${++seq}`;
+      const categories = payload.categories && payload.categories.length > 0 ? payload.categories : payload.category ? payload.category.split(",").map((c) => c.trim()).filter(Boolean) : [];
       return new Promise((resolve9) => {
         const timer = setTimeout(() => {
-          settle(requestId, "deny");
+          settle(requestId, "deny", true);
         }, timeoutMs2);
-        pending.set(requestId, { resolve: resolve9, timer });
+        pending.set(requestId, { resolve: resolve9, timer, payload });
         write(
           JSON.stringify({
             type: "permission.request",
             requestId,
             tool: payload.tool,
             category: payload.category,
+            categories,
             ...payload.inputPreview !== void 0 ? { inputPreview: payload.inputPreview } : {},
             ...payload.reason !== void 0 ? { reason: payload.reason } : {}
           })
         );
       });
     },
-    respond: settle,
+    respond: (requestId, decision) => settle(requestId, decision, false),
+    releaseGranted() {
+      let n = 0;
+      for (const [id3, entry] of [...pending]) {
+        const cats = entry.payload.categories && entry.payload.categories.length > 0 ? entry.payload.categories : entry.payload.category ? entry.payload.category.split(",").map((c) => c.trim()).filter(Boolean) : [];
+        if (isSessionGranted(entry.payload.tool, cats)) {
+          if (settle(id3, "allow", false)) n += 1;
+        }
+      }
+      return n;
+    },
     pendingCount: () => pending.size
   };
 }
@@ -71103,8 +71550,11 @@ function servePermissionRespond(bridge, params) {
   if (typeof requestId !== "string" || requestId.length === 0) {
     return { accepted: false, reason: "permission.respond requires a non-empty string requestId" };
   }
-  if (decision !== "allow" && decision !== "deny") {
-    return { accepted: false, reason: "permission.respond decision must be 'allow' or 'deny'" };
+  if (!isPermissionDecision(decision)) {
+    return {
+      accepted: false,
+      reason: "permission.respond decision must be 'allow' | 'deny' | 'always-tool' | 'always-category'"
+    };
   }
   return { accepted: bridge.respond(requestId, decision) };
 }
@@ -71114,18 +71564,104 @@ function asRegistryAskHandler(bridge) {
     const decision = await bridge.onPermissionAsk({
       tool: req.toolName,
       category: req.categories.join(",") || "other",
+      categories: req.categories,
       reason,
       ...req.claims && req.claims.length > 0 ? { inputPreview: req.claims.map((c) => c.summary).join(" \xB7 ") } : {}
     });
-    return decision === "allow";
+    if (decision === "deny") return false;
+    if (decision === "always-tool") {
+      grantSessionTool(req.toolName);
+      bridge.releaseGranted();
+    } else if (decision === "always-category") {
+      for (const cat of req.categories) {
+        grantSessionCategory(cat);
+      }
+      grantSessionTool(req.toolName);
+      bridge.releaseGranted();
+    }
+    return true;
   };
 }
-var SERVE_PERMISSION_PRESETS, PRESET_ENV;
+var SERVE_PERMISSION_PRESETS, PRESET_ENV, PERMISSION_DECISIONS;
 var init_permissionBridge = __esm({
   "src/cli/serve/permissionBridge.ts"() {
     "use strict";
+    init_toolPermissions();
     SERVE_PERMISSION_PRESETS = ["standard", "strict", "yolo"];
     PRESET_ENV = "ZELARI_PERMISSION_PRESET";
+    PERMISSION_DECISIONS = [
+      "allow",
+      "deny",
+      "always-tool",
+      "always-category"
+    ];
+  }
+});
+
+// src/cli/serve/askUserBridge.ts
+function createServeAskUserBridge(write, timeoutMs2 = askUserTimeoutMs()) {
+  const pending = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const settle = (requestId, answer, timedOut = false) => {
+    const entry = pending.get(requestId);
+    if (!entry) return false;
+    pending.delete(requestId);
+    clearTimeout(entry.timer);
+    write(
+      JSON.stringify({
+        type: "ask_user.settled",
+        requestId,
+        answer,
+        ...timedOut ? { timedOut: true } : {}
+      })
+    );
+    entry.resolve(answer);
+    return true;
+  };
+  return {
+    onAskUser(req) {
+      const question = req.question.trim();
+      const choices = req.choices.map((c) => c.trim()).filter(Boolean);
+      if (choices.length < 2) return Promise.resolve(null);
+      const requestId = `ask-${Date.now()}-${++seq}`;
+      return new Promise((resolve9) => {
+        const timer = setTimeout(() => {
+          settle(requestId, null, true);
+        }, timeoutMs2);
+        pending.set(requestId, { resolve: resolve9, timer });
+        write(
+          JSON.stringify({
+            type: "ask_user.request",
+            requestId,
+            question,
+            choices,
+            ...req.context ? { context: req.context } : {}
+          })
+        );
+      });
+    },
+    respond: (requestId, answer) => settle(requestId, answer, false),
+    pendingCount: () => pending.size
+  };
+}
+function serveAskUserRespond(bridge, params) {
+  if (!params || typeof params !== "object") {
+    return { accepted: false, reason: "ask_user.respond requires an object params" };
+  }
+  const { requestId, answer } = params;
+  if (typeof requestId !== "string" || requestId.length === 0) {
+    return { accepted: false, reason: "ask_user.respond requires a non-empty string requestId" };
+  }
+  if (answer !== null && typeof answer !== "string") {
+    return { accepted: false, reason: "ask_user.respond answer must be a string or null" };
+  }
+  const text = typeof answer === "string" ? answer.trim() : null;
+  return { accepted: bridge.respond(requestId, text && text.length > 0 ? text : null) };
+}
+var init_askUserBridge = __esm({
+  "src/cli/serve/askUserBridge.ts"() {
+    "use strict";
+    init_askUserTimeout();
   }
 });
 
@@ -71242,7 +71778,7 @@ function resolveTurnLspProvider(services) {
   const candidate = services?.lspManager;
   return candidate instanceof LspManager ? candidate : void 0;
 }
-function createCliRunTurn(onPermissionAsk) {
+function createCliRunTurn(onPermissionAsk, onAskUser) {
   let streamPromise = null;
   const ensureStream = () => {
     if (!streamPromise) {
@@ -71269,6 +71805,7 @@ function createCliRunTurn(onPermissionAsk) {
     const { provider, model, stream } = await ensureStream();
     const opts = bindHarnessTurnOptions(input, deps.session.workspaceRoot);
     if (onPermissionAsk) opts.onPermissionAsk = onPermissionAsk;
+    if (onAskUser) opts.onAskUser = onAskUser;
     applyTurnPermissionPreset(input);
     const lspProvider = resolveTurnLspProvider(deps.services);
     const exitCode = await dispatchHeadlessTurn(
@@ -71304,6 +71841,7 @@ function startHarnessServer(options = {}) {
     write(JSON.stringify(envelope));
   };
   const permissionBridge = createServePermissionBridge(write);
+  const askUserBridge = createServeAskUserBridge(write);
   const dispatch = async (req) => {
     if (typeof req.method !== "string") {
       return { id: req.id ?? null, ok: false, error: { code: "bad_request", message: "missing method" } };
@@ -71317,11 +71855,21 @@ function startHarnessServer(options = {}) {
           result: servePermissionRespond(permissionBridge, params)
         };
       }
+      case "ask_user.respond": {
+        return {
+          id: req.id ?? null,
+          ok: true,
+          result: serveAskUserRespond(askUserBridge, params)
+        };
+      }
       case "session.create": {
         const root = typeof params.workspaceRoot === "string" ? params.workspaceRoot : process.cwd();
         const session = server.createSession({
           workspaceRoot: root,
-          runTurn: options.runTurn ?? createCliRunTurn(asRegistryAskHandler(permissionBridge))
+          runTurn: options.runTurn ?? createCliRunTurn(
+            asRegistryAskHandler(permissionBridge),
+            askUserBridge.onAskUser
+          )
         });
         return { id: req.id ?? null, ok: true, result: { sessionId: session.id, workspaceRoot: session.workspaceRoot } };
       }
@@ -71475,6 +72023,7 @@ var init_harnessServer = __esm({
     init_policyGate();
     init_policyLoadMode();
     init_permissionBridge();
+    init_askUserBridge();
     init_spineLockSweep();
   }
 });
@@ -72517,7 +73066,12 @@ function readPackageJson4() {
   }
 }
 function getGlobalPrefix() {
-  return (process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || "").trim() || tryExec("npm prefix -g");
+  const fromNpm = tryExec("npm prefix -g");
+  if (fromNpm) return fromNpm;
+  return (process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || "").trim();
+}
+function isSourceCheckout() {
+  return existsSync62(path95.join(packageRoot, "src", "cli", "main.ts")) && existsSync62(path95.join(packageRoot, "apps", "desktop", "package.json"));
 }
 function checkShim(pkgName) {
   const prefix = getGlobalPrefix();
@@ -72528,6 +73082,14 @@ function checkShim(pkgName) {
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
   const shimPath = path95.join(prefix, shimName);
   if (!existsSync62(shimPath)) {
+    const localBin = path95.join(packageRoot, "bin", "zelari-code.js");
+    if (isSourceCheckout() && existsSync62(localBin)) {
+      return WARN(
+        `global shim not found at ${shimPath}
+         source checkout \u2014 using ${localBin}
+         optional: npm install -g ${pkgName}@latest --force`
+      );
+    }
     return FAIL(
       `shim not found at ${shimPath}
          fix:  npm install -g ${pkgName}@latest --force`
@@ -72922,16 +73484,15 @@ __export(fixPath_exports, {
 });
 import { spawnSync as spawnSync3 } from "node:child_process";
 function getGlobalPrefix2() {
-  return (process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || "").trim() || (() => {
-    try {
-      return spawnSync3("npm", ["prefix", "-g"], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).stdout?.trim() ?? "";
-    } catch {
-      return "";
-    }
-  })();
+  try {
+    const fromNpm = spawnSync3("npm", ["prefix", "-g"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).stdout?.trim() ?? "";
+    if (fromNpm) return fromNpm;
+  } catch {
+  }
+  return (process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || "").trim();
 }
 function powershell(script) {
   try {
@@ -76570,22 +77131,7 @@ init_spineTelemetry();
 
 // src/cli/hooks/permissionPicker.ts
 init_toolPermissions();
-
-// src/cli/hooks/askUserTimeout.ts
-function askUserTimeoutMs() {
-  const raw = process.env.ZELARI_ASK_USER_TIMEOUT_MS?.trim();
-  if (!raw) return 3e5;
-  const n = Number.parseInt(raw, 10);
-  if (!Number.isFinite(n) || n < 0) return 3e5;
-  return n;
-}
-function armPickerTimeout(onFire, ms) {
-  if (ms <= 0) return () => void 0;
-  const id3 = setTimeout(onFire, ms);
-  return () => clearTimeout(id3);
-}
-
-// src/cli/hooks/permissionPicker.ts
+init_askUserTimeout();
 function createPermissionAskHandler(opts) {
   const { setPicker: setPicker2, appendSystem: appendSystem2 } = opts;
   return (req) => new Promise((resolve9) => {
@@ -76678,6 +77224,7 @@ ${detail}${note}${claimsBlock}
 }
 
 // src/cli/hooks/useChatTurn.ts
+init_askUserTimeout();
 init_toolPermissions();
 init_skills2();
 init_fileStateStore();
@@ -78577,6 +79124,7 @@ async function runZelariMissionInTui(userMessage, deps, emit) {
               const hook = await runPostCouncilHook2(workspaceCtx, {
                 runMode: "implementation",
                 userMessage,
+                sessionId: deps.sessionId,
                 synthesisText: synthesisText || void 0,
                 degradedRun: d.degraded,
                 degradedReasons: d.reasons
@@ -78606,6 +79154,7 @@ init_permissionBroker();
 init_brokerHandlers();
 import { useEffect as useEffect5, useRef as useRef5 } from "react";
 init_messageHelpers();
+init_askUserTimeout();
 function usePermissionBroker(opts) {
   const { setPicker: setPicker2, setMessages } = opts;
   const handleRef = useRef5(null);