@zelari/core 2.33.0 → 2.34.0

package/dist/agents/councilApi.js

@@ -1,268 +1,22 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { getAgent, getCouncilAgents, resolveRoleSystemPrompt, swapMembers } from './roles.js';
+import { getAgent, getCouncilAgents, swapMembers } from './roles.js';
 import { getProviderTools } from './toolSchemas.js';
-import { buildSystemPromptSplit, computeAgentTools, } from './systemPromptBuilder.js';
-import { getAllTools } from './tools.js';
+import { computeAgentTools, } from './systemPromptBuilder.js';
 import { buildLanguagePolicyModuleFor } from './languagePolicy.js';
-import { scrubProprietaryLeak } from './secrecyPolicy.js';
 import { createBrainEvent } from '../shared/events.js';
-import { AgentHarness, normalizeTextToolArgs, parseTextToolCalls, } from '../core/AgentHarness.js';
-import { councilModeBanner } from '../council/modeBanners.js';
+import { AgentHarness, } from '../core/AgentHarness.js';
 import { councilTierFromSize } from '../council/runMode.js';
 import { parseProjectRootFromWorkspaceContext, runChairmanMicroGate, } from '../council/verification/microGate.js';
-import { buildImplementationVerifyRetryPrompt, checkImplementationCompletion, resolveVerifyRetryTool, } from '../council/verification/completion.js';
 import { warnIfNfrSpecMissing } from '../council/scope/nfrSpecWarn.js';
-import { loadNfrSpec, DEFAULT_NFR_SPEC, runImplementationVerification, } from '../council/verification/runChecks.js';
-import { buildDeliveryFixPrompt, buildImplementationWriteRetryPrompt, checkImplementationDelivery, countEmittedWriteTools, filterDeliveryBlockingFails, } from '../council/verification/implementationDelivery.js';
-import { applyInlineJsAutofix } from '../council/verification/inlineJsAutofix.js';
-/**
- * Council members whose tool-emission retry is DISABLED.
- *
- * v0.7.7 Opzione B put 'nettun' here because its contract (12 createTask
- * + 1 createMilestone = 13+ sequential calls) exceeded what composer-2.5
- * could persist in the 240s budget, making the retry a pure waste.
- *
- * v0.7.8 removes 'nettun': the plan contract is now satisfiable with a
- * SINGLE `createPlan` batch call (phases + nested tasks + milestone in
- * one emission), so the forced retry has the same 1-call budget that
- * already works reliably for Minosse and Lucifero. The set stays
- * exported as the opt-out mechanism for future members.
- */
-export const NON_RETRY_AGENTS = new Set([]);
-const QUESTION_MARKER = '---QUESTION---';
-const QUESTION_END_MARKER = '---END---';
-/**
- * Extract the first top-level JSON object from `s` using brace depth so trailing
- * MiniMax/tool garbage after `}` does not break JSON.parse (common failure mode:
- * `---QUESTION--- {…}]<]minimax…` without ---END---).
- */
-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;
-}
-export 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())
-                : undefined,
-            context: typeof parsed.context === 'string' ? parsed.context.trim() : undefined,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/** True when text contains a structured question with ≥2 choices (pause UI). */
-export function hasInteractiveClarification(text) {
-    const c = parseClarificationRequest(text);
-    return !!(c && c.choices && c.choices.length >= 2);
-}
-export function parseThinking(text) {
-    // Prefer complete blocks; fall back to unclosed trailing block (common mid-stream).
-    const complete = text.match(/<think(?:ing)?>([\s\S]*?)<\/think(?:ing)?>/i);
-    if (complete)
-        return complete[1].trim();
-    const open = text.match(/<think(?:ing)?>([\s\S]*)$/i);
-    return open ? open[1].trim() : '';
-}
-/**
- * Strip model "private" channels from text shown to the user / re-fed as
- * history. Covers:
- *   - complete + unclosed `<think>` / `<thinking>` (GLM/MiniMax style) — optional
- *   - MiniMax XML tool-call wrappers
- *   - clarifying-question JSON blocks (display only; keep in provider history)
- *
- * Without unclosed-tag stripping, streamed thinking that never got a closing
- * tag leaked into the TUI as visible assistant prose (v1.8.1).
- */
-export 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, '');
-    }
-    // Tool-call markup that models sometimes dump into prose (MiniMax / GLM / generic).
-    // Prefer closed-block removal first; only then strip *trailing* unclosed
-    // open tags. Never use a mid-string open-tag → EOF wipe for tool tags when
-    // there may still be real prose after a broken unclosed tag sequence —
-    // headless streamScrub re-cleans the full buffer each push, so closed pairs
-    // are enough mid-stream; trailing open is for end-of-turn.
-    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, '')
-        // Trailing unclosed tool channels only (end of buffer)
-        .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) {
-        // Closed block, or unclosed (model often omits ---END--- then dumps tools).
-        out = out
-            .replace(/---QUESTION---[\s\S]*?---END---/g, '')
-            .replace(/---QUESTION---[\s\S]*$/g, '');
-    }
-    out = out.replace(/\n{3,}/g, '\n\n').trim();
-    // Defense-in-depth: strip proprietary prompt dumps that escaped model policy.
-    return scrubProprietaryLeak(out);
-}
-/**
- * Tools that mutate project files. In implementation-mode council runs only the
- * chairman (Lucifero) implements; specialists + Minosse analyze and hand off.
- * We strip these from every non-implementer so multiple agents never edit the
- * same files (multi-writer chaos) and "who implemented" stays unambiguous.
- * Note: specialists inherit write tools via skill `requiredTools`, so this must
- * filter the RESULT of computeAgentTools, not just the declared role tools.
- */
-export const MUTATING_PROJECT_TOOLS = ['write_file', 'edit_file'];
-/**
- * Remove file-mutating tools for non-implementer members in implementation mode.
- * Design-phase and the implementer (chairman) keep the full set unchanged.
- */
-export 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) {
-    // v0.7.5: the AVAILABLE TOOLS prompt block must match the schemas the
-    // harness actually advertises. The v0.7.3 fix filtered the schemas
-    // (filterExecutable) but NOT this prompt text, so members still read
-    // "searchRAG: search the knowledge base…" in their system prompt and
-    // called it — every call a guaranteed "Tool not found" (live test
-    // 2026-07-03, /council in Z:\EasyPeasy\test).
-    const allToolNames = computeAgentTools(agent, aiConfig);
-    const toolNames = executableTools
-        ? allToolNames.filter((n) => executableTools.has(n))
-        : allToolNames;
-    // Merge language policy into custom modules so every primary council turn
-    // gets it (retries previously received the arg but never used it).
-    const mergedAiConfig = languageModule
-        ? {
-            enabledSkills: aiConfig?.enabledSkills ?? [],
-            enabledTools: aiConfig?.enabledTools ?? [],
-            agentSkillConfigs: aiConfig?.agentSkillConfigs ?? [],
-            customSkills: aiConfig?.customSkills,
-            customPromptModules: [
-                ...(aiConfig?.customPromptModules ?? []),
-                languageModule,
-            ],
-        }
-        : aiConfig;
-    // Mode-split: design mandatories only when runMode is design-phase.
-    const modeAwareAgent = {
-        ...agent,
-        systemPrompt: resolveRoleSystemPrompt(agent, runMode),
-    };
-    // Cache-efficient split (Cache Wars): stable = identity/tools/role;
-    // volatile = workspace/RAG; banners stay trailing system msgs (volatile).
-    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) {
-        // Cap each prior member blob so one verbose specialist cannot saturate
-        // downstream members (chairman especially). Full text is not product law.
-        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)}\n… [truncated ${o.content.length}→${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 — prefer product files on disk if they conflict):\n${summary}\n\n` +
-                `Original user request: ${userMessage}`,
-        });
-    }
-    else {
-        messages.push({ role: 'user', content: userMessage });
-    }
-    return messages;
-}
+import { loadNfrSpec, DEFAULT_NFR_SPEC, } from '../council/verification/runChecks.js';
+import { checkImplementationDelivery, countEmittedWriteTools, } from '../council/verification/implementationDelivery.js';
+import { NON_RETRY_AGENTS } from './council/types.js';
+export { NON_RETRY_AGENTS } from './council/types.js';
+import { cleanAgentContent, parseClarificationRequest, parseThinking } from './council/outputCleaning.js';
+export { cleanAgentContent, hasInteractiveClarification, parseClarificationRequest, parseThinking } from './council/outputCleaning.js';
+import { buildAgentMessages, restrictImplementationWrites } from './council/memberMessages.js';
+export { MUTATING_PROJECT_TOOLS, restrictImplementationWrites } from './council/memberMessages.js';
 /**
  * PURE council orchestration. Loops through specialists, optionally runs
  * the oracle (debate mode), then runs the chairman synthesis.
@@ -1036,640 +790,12 @@ export async function* runCouncilPure(userMessage, config, callbacks = {}) {
         durationMs: 0,
     };
 }
-/**
- * Implementation-mode anti-resa retry: force grep/bash after writes.
- */
-export async function* applyCompletionRetry(args) {
-    const check = checkImplementationCompletion(args.emittedToolNames);
-    if (check.ok)
-        return;
-    const retryTool = resolveVerifyRetryTool(args.executableNames);
-    if (!retryTool) {
-        // eslint-disable-next-line no-console
-        console.warn('[council] implementation verify retry skipped — no grep_content/bash in registry');
-        return;
-    }
-    if (!shouldRetryMember([retryTool], 0))
-        return;
-    // eslint-disable-next-line no-console
-    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) {
-        // eslint-disable-next-line no-console
-        console.error(`[council] ${args.agent.id} verify retry failed:`, retryErr);
-    }
-    const after = checkImplementationCompletion(args.emittedToolNames);
-    if (!after.ok) {
-        // eslint-disable-next-line no-console
-        console.warn(`[council] ${args.agent.id} still missing verify after retry: ${after.reason}`);
-    }
-}
-/**
- * Build the scoped fix instruction for the chairman from deterministic motion
- * violations. Groups by file, lists file:line + rule, and constrains the model
- * to fix ONLY these (no new features, no rewrites). Exported for testing.
- */
-export function buildMotionFixPrompt(violations) {
-    const byFile = new Map();
-    for (const v of violations) {
-        const file = v.file || 'index.html';
-        const loc = v.line ? `${file}:L${v.line}` : file;
-        const list = byFile.get(file) ?? [];
-        list.push(`  - ${loc}: ${v.message}`);
-        byFile.set(file, 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 — do not add features, do not rewrite sections, do not touch anything else:\n${blocks}\n\n` +
-        `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 — no summary.`);
-}
-/**
- * Forced retry when Lucifero finished without a successful write_file/edit_file.
- */
-export 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);
-    // eslint-disable-next-line no-console
-    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) {
-        // eslint-disable-next-line no-console
-        console.error(`[council] ${args.chairman.id} implementation write retry failed:`, retryErr);
-    }
-}
-/** Max verify-driven delivery passes after the chairman turn (inline-js, motion, etc.). */
-export const MAX_DELIVERY_ATTEMPTS = 2;
-/**
- * Increment 5 — verify-driven delivery loop. Re-runs deterministic verification
- * and forces scoped chairman fix turns until blocking technical issues clear
- * or the attempt cap is hit.
- */
-export 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);
-        // eslint-disable-next-line no-console
-        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) {
-            // eslint-disable-next-line no-console
-            console.error(`[council] ${args.chairman.id} delivery pass ${attempt} failed:`, deliveryErr);
-            break;
-        }
-        for (const rel of args.changedFiles) {
-            for (const w of runChairmanMicroGate({ projectRoot: args.projectRoot, relPath: rel, zelariRoot })) {
-                // refresh changed set — delivery may touch same targets
-                args.changedFiles.add(w.file ?? rel);
-            }
-        }
-    }
-    const finalReport = runImplementationVerification({
-        projectRoot: args.projectRoot,
-        zelariRoot,
-    });
-    return filterDeliveryBlockingFails(finalReport.results).length === 0;
-}
-/**
- * Re-execute edit_file/write_file calls from a `---TOOLS---` block after the
- * chairman turn. Safety net when the harness path parsed the block but edits
- * failed (oldString drift) or the block was not fully executed.
- */
-export 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;
-}
-/**
- * Increment 4 — bounded deterministic fix loop for the chairman. When the
- * micro-gate flagged motion violations in Lucifero's writes, force a scoped
- * fix turn (read_file + edit_file only), re-scan the changed files, and repeat
- * until clean or the attempt cap. Emits only the fix turn's own events; the
- * post-council verification reports the final PASS/FAIL to the user.
- */
-export 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,
-            });
-            for await (const event of fixGenerator) {
-                if (event.type === 'tool_execution_start')
-                    args.onToolCall?.();
-                yield event;
-            }
-        }
-        catch (fixErr) {
-            // eslint-disable-next-line no-console
-            console.error(`[council] chairman fix pass ${attempt} failed:`, fixErr);
-            break;
-        }
-        // Re-scan the changed target files for the next iteration / termination.
-        const rescanned = 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());
-    }
-}
-/**
- * Pure helper: given the list of tool names a member emitted during its
- * turn, and a list of requirements, return whether all requirements are
- * met.
- */
-export function checkMemberToolEmissions(_memberId, emittedToolNames, requirements) {
-    if (requirements.length === 0) {
-        return { ok: true, missing: [] };
-    }
-    // Tally emitted counts once for all requirements.
-    const counts = 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 };
-}
-/**
- * v0.7.8 — Per-member tool-emission requirement SETS for the design-phase
- * council run. The outer array is an OR of alternatives: the member's turn
- * is complete when ANY one set is fully satisfied. The FIRST set is the
- * preferred contract — its unmet requirements drive the warning message
- * and the forced-retry tool list.
- *
- * Nettuno has two ways to satisfy its contract:
- *   1. (preferred) ONE `createPlan` batch call — phases + nested tasks +
- *      milestone in a single emission. Retry budget: 1 call, which
- *      composer-2.5 handles reliably (same shape as the Minosse/Lucifero
- *      retries that already work).
- *   2. (legacy) the itemized trio — kept so stronger models (e.g. Opus)
- *      that emit createPhase/createTask/createMilestone directly are not
- *      flagged or retried.
- */
-export const 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 }],
-    ],
-};
-/**
- * Preferred (first) requirement set per member — kept as the flat map the
- * council loops pass to `applyRetryIfMissing` for the retry budget. For
- * Nettuno this is `createPlan min 1`, so the forced retry advertises ONE
- * tool with a 1-call budget instead of the old 13+-call itemized contract.
- */
-export const DESIGN_PHASE_REQUIREMENTS = Object.fromEntries(Object.entries(DESIGN_PHASE_REQUIREMENT_SETS).map(([id, sets]) => [id, sets[0]]));
-/**
- * Pure helper: OR-of-sets variant of {@link checkMemberToolEmissions}.
- * Returns ok when ANY set is fully satisfied. When none is, the missing
- * list reflects the FIRST (preferred) set so the warning and the retry
- * point the model at the cheapest way to comply.
- */
-export function checkMemberToolEmissionSets(memberId, emittedToolNames, sets) {
-    if (sets.length === 0) {
-        return { ok: true, missing: [] };
-    }
-    const results = sets.map((set) => checkMemberToolEmissions(memberId, emittedToolNames, set));
-    if (results.some((r) => r.ok)) {
-        return { ok: true, missing: [] };
-    }
-    return results[0];
-}
-/**
- * Run the post-condition check for a member and emit a console.warn when
- * any required tool was not emitted the minimum number of times. Returns
- * the check result so callers can act on it (Pass 3 may add automatic
- * retry; for now we only warn).
- */
-export 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) {
-        // eslint-disable-next-line no-console
-        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;
-}
-/**
- * Maximum number of forced retry turns per council member. Cap of 1
- * keeps the worst-case council latency bounded (a single extra turn per
- * member × 4 design-phase members ≈ 30-60 s on top of the base run).
- * Going above 1 tends to produce hallucinated tool arguments because
- * the model has already spent its "tool budget" on exploration.
- */
-export const MAX_RETRY_PER_MEMBER = 1;
-/**
- * Pure helper: should the council loop spin up one more forced turn for
- * this member to recover the missing tool emissions?
- *
- * Returns true when:
- *   - at least one tool is still missing after the post-condition check, AND
- *   - the retry budget for this member has not been exhausted.
- *
- * Returns false otherwise. Tested as a pure function so the council
- * loop can branch on the answer without coupling to AgentHarness.
- */
-export function shouldRetryMember(missingToolNames, attemptsSoFar) {
-    if (missingToolNames.length === 0)
-        return false;
-    if (attemptsSoFar >= MAX_RETRY_PER_MEMBER)
-        return false;
-    return true;
-}
-/**
- * Build the one-line prompt that the retry turn sends to the model.
- * The shape matters: the model is primed by its role prompt to produce
- * prose, so the retry prompt must be unambiguous, imperative, and
- * scoped to ONLY the missing tools.
- *
- * Format: "You did not emit: <names>. Call <names> NOW with concrete
- * arguments. No prose."
- *
- * Multiple tools are listed comma-separated in the same call so the
- * model can satisfy them in a single tool_calls turn (which is the
- * cheapest path through AgentHarness).
- */
-export 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.`;
-}
-// ── Forced retry turn (v0.7.7 Pass 3) ──────────────────────────────────────
-//
-// When the post-condition check fails for a member, the council loop can
-// spin up ONE more AgentHarness turn whose ONLY purpose is to force the
-// missing tool emissions. This is a structural fix for the failure mode
-// where the model terminates after exploration (`searchDocuments` × 2)
-// without persisting the required artifacts.
-//
-// The retry turn is intentionally minimal:
-//   - System prompt: same as the original (via buildAgentMessages) so
-//     the model still has its role contract.
-//   - User message: the retry prompt (one line, imperative).
-//   - Tools: ONLY the missing tools (filtered through filterExecutable
-//     so we never advertise a tool the runtime cannot execute).
-//   - maxToolCallsPerTurn: exactly the number of missing tools — the
-//     model cannot explore again, it can only call what's missing.
-//
-// Returns the additional tool names emitted during the retry. The caller
-// is responsible for re-running checkMemberToolEmissions with the
-// union of original + retry emissions.
-export async function* runRetryTurnForMember(args) {
-    // Filter the missing tools against what's actually executable in this
-    // runtime. If a tool is missing from executableTools, the retry can't
-    // emit it — log and skip.
-    const executableMissing = args.executableTools
-        ? args.missingToolNames.filter((n) => args.executableTools.has(n))
-        : args.missingToolNames;
-    if (executableMissing.length === 0) {
-        return [];
-    }
-    // Build the minimal tool set — only the missing tools.
-    const retryToolNames = executableMissing;
-    const retryToolSpecs = getProviderTools(retryToolNames).map((t) => ({
-        name: t.function.name,
-        description: t.function.description,
-        parameters: t.function.parameters,
-    }));
-    // Build the messages: same system + role context as the original turn,
-    // then the retry prompt as a user message appended at the end.
-    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),
-        },
-    ];
-    // Budget the retry turn so the model can satisfy ALL minimums in a
-    // single tool_calls turn. For createDocument min:1 this is 1; for
-    // createTask min:12 this is 12. Falls back to `missingToolNames.length`
-    // when no per-tool min map is provided.
-    const maxToolCalls = args.minPerTool !== undefined
-        ? 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;
-}
-/**
- * Shared retry orchestrator used by specialist, oracle, and chairman
- * loops. Given the post-condition check result, decides whether to
- * spin up a forced retry turn, and if so yields the events from that
- * turn back to the caller (so the UI sees them) while mutating the
- * shared `emittedToolNames` array (so the next post-condition check
- * sees the union of original + retry emissions).
- *
- * The retry turn is skipped when:
- *   - the check passed (no missing tools), OR
- *   - the retry budget for this member is exhausted (shouldRetryMember).
- *
- * On retry failure (network error, model error, etc.) the function logs
- * the error and continues — it never throws. The next post-condition
- * check will simply re-warn.
- */
-export async function* applyRetryIfMissing(args) {
-    if (args.check.ok)
-        return;
-    const missingToolNames = args.check.missing.map((m) => m.split(' ')[0]);
-    if (!shouldRetryMember(missingToolNames, 0))
-        return;
-    // eslint-disable-next-line no-console
-    console.warn(`[council] ${args.agent.id} retrying missing tools: ${missingToolNames.join(', ')}`);
-    // Build the minPerTool map from the original requirements so the
-    // retry turn budgets enough tool calls to satisfy every minimum.
-    // Without this, a createTask min:12 requirement would be capped at
-    // 1 call (the number of distinct missing tools).
-    const minPerTool = {};
-    if (args.requirements) {
-        for (const req of args.requirements) {
-            if (missingToolNames.includes(req.name)) {
-                minPerTool[req.name] = req.min;
-            }
-        }
-    }
-    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,
-        });
-        for await (const event of retryGenerator) {
-            if (event.type === 'tool_execution_start') {
-                args.onToolCall();
-                args.emittedToolNames.push(event.toolName);
-            }
-            yield event;
-        }
-    }
-    catch (retryErr) {
-        // eslint-disable-next-line no-console
-        console.error(`[council] ${args.agent.id} retry failed:`, retryErr);
-    }
-    // Re-run the check so the final warning reflects the union of
-    // original + retry emissions.
-    enforceDesignPhaseToolEmissions(args.agent.id, args.emittedToolNames);
-}
+import { applyImplementationWriteRetry, runChairmanDeliveryLoop } from './council/chairmanDelivery.js';
+export { applyCompletionRetry, applyImplementationWriteRetry, buildMotionFixPrompt, MAX_DELIVERY_ATTEMPTS, runChairmanDeliveryLoop } from './council/chairmanDelivery.js';
+import { replayChairmanTextTools, runChairmanFixLoop } from './council/chairmanFixLoop.js';
+export { replayChairmanTextTools, runChairmanFixLoop } from './council/chairmanFixLoop.js';
+import { DESIGN_PHASE_REQUIREMENTS, enforceDesignPhaseToolEmissions } from './council/toolEmission.js';
+export { checkMemberToolEmissionSets, checkMemberToolEmissions, DESIGN_PHASE_REQUIREMENTS, DESIGN_PHASE_REQUIREMENT_SETS, enforceDesignPhaseToolEmissions } from './council/toolEmission.js';
+import { applyRetryIfMissing } from './council/retryTurn.js';
+export { applyRetryIfMissing, buildRetryPrompt, MAX_RETRY_PER_MEMBER, runRetryTurnForMember, shouldRetryMember } from './council/retryTurn.js';
 //# sourceMappingURL=councilApi.js.map