@event4u/agent-config 8.10.0 → 8.12.0

package/src/scripts/ai_council/config.ts

@@ -373,6 +373,13 @@ export interface MemberConfig {
     readonly binary: string | null;
     readonly model_ladder: readonly string[];
     readonly participate_low_impact: boolean;
+    /**
+     * Optional capability rank for chairman-`auto` tie-breaking (Phase 2;
+     * council 2026-07-12 — provider-family difference is primary, tier is the
+     * tie-break). Higher = stronger. `null` when unset; selection then falls
+     * back to deterministic config order.
+     */
+    readonly tier: number | null;
 }
 
 /**
@@ -451,6 +458,32 @@ export interface DecisionReplayConfig {
     readonly include_member_arguments: boolean;
 }
 
+/** Option-level stance tally (road-to-opt-council-deliberation Phase 1). */
+export interface StanceTallyConfig {
+    readonly enabled: boolean;
+}
+
+/** Chairman synthesis (road-to-opt-council-deliberation Phase 2). Default
+ *  `host` = today's host-synthesis behaviour, byte-identical. */
+export interface ChairmanConfig {
+    readonly mode: string; // one of _VALID_CHAIRMAN_MODES
+    readonly member: string | null; // required (and validated) when mode === 'member'
+}
+
+/** Debate enforcement gates (road-to-opt-council-deliberation Phase 3).
+ *  Enables the anti-conformity directive + the deterministic post-round
+ *  dissent-quota / novelty checks on the debate path. */
+export interface DebateGatesConfig {
+    readonly enabled: boolean;
+}
+
+/** Pre-round-1 restatement pass (road-to-opt-council-deliberation Phase 3). */
+export interface RestateConfig {
+    readonly enabled: boolean;
+}
+
+const _VALID_CHAIRMAN_MODES: ReadonlySet<string> = new Set(['host', 'member', 'auto']);
+
 /** Routing entry for one impact class (Phase 10). */
 export interface DecisionResolutionEntry {
     readonly mode: string;
@@ -519,6 +552,10 @@ export interface CouncilConfig {
     readonly model_downgrade: ModelDowngradeConfig;
     readonly debate: DebateConfig;
     readonly decision_replay: DecisionReplayConfig;
+    readonly stance_tally: StanceTallyConfig;
+    readonly chairman: ChairmanConfig;
+    readonly debate_gates: DebateGatesConfig;
+    readonly restate: RestateConfig;
     readonly decision_resolution: DecisionResolutionConfig;
     readonly routing: RoutingConfig;
     readonly low_impact: LowImpactConfig;
@@ -748,6 +785,20 @@ export function _build_config(raw: Dict, source_path: PathLike): CouncilConfig {
         _asDict(_getOr(raw, 'decision_replay', {})),
         'decision_replay',
     );
+    const stance_tally = _build_stance_tally(
+        _asDict(_getOr(raw, 'stance_tally', {})),
+        'stance_tally',
+    );
+    const chairman = _build_chairman(
+        _asDict(_getOr(raw, 'chairman', {})),
+        'chairman',
+        members,
+    );
+    const debate_gates = _build_debate_gates(
+        _asDict(_getOr(raw, 'debate_gates', {})),
+        'debate_gates',
+    );
+    const restate = _build_restate(_asDict(_getOr(raw, 'restate', {})), 'restate');
     const decision_resolution = _build_decision_resolution(
         _asDict(_getOr(raw, 'decision_resolution', {})),
     );
@@ -774,6 +825,10 @@ export function _build_config(raw: Dict, source_path: PathLike): CouncilConfig {
         model_downgrade,
         debate,
         decision_replay,
+        stance_tally,
+        chairman,
+        debate_gates,
+        restate,
         decision_resolution,
         routing,
         low_impact,
@@ -927,6 +982,96 @@ function _build_decision_replay(d: Dict, scope: string): DecisionReplayConfig {
     };
 }
 
+/**
+ * `ai_council.stance_tally` — option-level stance tally (Phase 1). Default-off;
+ * an absent block yields `{ enabled: false }`, keeping the council path
+ * byte-identical. Per-field type validation (mirrors `_build_decision_replay`);
+ * a non-bool `enabled` is rejected rather than silently coerced.
+ */
+function _build_stance_tally(d: Dict, scope: string): StanceTallyConfig {
+    if (!_isDict(d)) {
+        throw new CouncilConfigError(`\`${scope}\` must be a mapping.`);
+    }
+    const enabled = _get(d, 'enabled', false);
+    if (!_isBool(enabled)) {
+        throw new CouncilConfigError(`\`${scope}.enabled\` must be a bool.`);
+    }
+    return { enabled: Boolean(enabled) };
+}
+
+/**
+ * `ai_council.chairman` (Phase 2). Default `{ mode: 'host', member: null }` =
+ * today's host synthesis, byte-identical. Enum-validates `mode`; when
+ * `mode: 'member'` the named member must exist AND be enabled (fail-closed at
+ * load, mirroring the advisor cross-validation). `mode: 'auto'` needs no member.
+ */
+function _build_chairman(
+    d: Dict,
+    scope: string,
+    members: ReadonlyMap<string, MemberConfig>,
+): ChairmanConfig {
+    if (!_isDict(d)) {
+        throw new CouncilConfigError(`\`${scope}\` must be a mapping.`);
+    }
+    const mode = _get(d, 'mode', 'host');
+    if (!(_isStr(mode) && _VALID_CHAIRMAN_MODES.has(mode))) {
+        throw new CouncilConfigError(
+            `\`${scope}.mode\`=${_pyRepr(mode)} not in ${_sortedListRepr(_VALID_CHAIRMAN_MODES)}.`,
+        );
+    }
+    let member: string | null = null;
+    const rawMember = _get(d, 'member', null);
+    if (rawMember !== null && rawMember !== undefined) {
+        if (!_isStr(rawMember)) {
+            throw new CouncilConfigError(`\`${scope}.member\` must be a string.`);
+        }
+        member = rawMember;
+    }
+    if (mode === 'member') {
+        if (member === null) {
+            throw new CouncilConfigError(
+                `\`${scope}.mode\` is 'member' but \`${scope}.member\` is unset.`,
+            );
+        }
+        const bound = members.get(member);
+        if (bound === undefined) {
+            throw new CouncilConfigError(
+                `\`${scope}.member\`=${_pyReprStr(member)}: no such member in the \`members\` block.`,
+            );
+        }
+        if (!bound.enabled) {
+            throw new CouncilConfigError(
+                `\`${scope}.member\`=${_pyReprStr(member)}: member exists but is disabled.`,
+            );
+        }
+    }
+    return { mode, member };
+}
+
+/** `ai_council.debate_gates` (Phase 3). `{enabled}`, default false. */
+function _build_debate_gates(d: Dict, scope: string): DebateGatesConfig {
+    if (!_isDict(d)) {
+        throw new CouncilConfigError(`\`${scope}\` must be a mapping.`);
+    }
+    const enabled = _get(d, 'enabled', false);
+    if (!_isBool(enabled)) {
+        throw new CouncilConfigError(`\`${scope}.enabled\` must be a bool.`);
+    }
+    return { enabled: Boolean(enabled) };
+}
+
+/** `ai_council.restate` (Phase 3). `{enabled}`, default false. */
+function _build_restate(d: Dict, scope: string): RestateConfig {
+    if (!_isDict(d)) {
+        throw new CouncilConfigError(`\`${scope}\` must be a mapping.`);
+    }
+    const enabled = _get(d, 'enabled', false);
+    if (!_isBool(enabled)) {
+        throw new CouncilConfigError(`\`${scope}.enabled\` must be a bool.`);
+    }
+    return { enabled: Boolean(enabled) };
+}
+
 const _VALID_RESOLUTION_MODES: ReadonlySet<string> = new Set([
     'agent',
     'council',
@@ -1529,6 +1674,17 @@ function _build_member(
                 `(got ${_pyTypeName(participate_raw)}).`,
         );
     }
+    const tier_raw = _get(cfg, 'tier', null);
+    let tier: number | null = null;
+    if (tier_raw !== null && tier_raw !== undefined) {
+        if (typeof tier_raw !== 'number' || !Number.isInteger(tier_raw) || tier_raw < 1) {
+            throw new CouncilConfigError(
+                `members.${name}.tier must be an integer >= 1 when set ` +
+                    `(got ${_pyRepr(tier_raw)}).`,
+            );
+        }
+        tier = tier_raw;
+    }
     return {
         name,
         enabled: member_enabled,
@@ -1538,6 +1694,7 @@ function _build_member(
         binary: (binary as string | null) ?? null,
         model_ladder: ladder,
         participate_low_impact: participate_raw,
+        tier,
     };
 }
 

package/src/scripts/ai_council/debate_gates.ts

@@ -0,0 +1,89 @@
+// Debate enforcement-gate detectors (road-to-opt-council-deliberation Phase 3).
+//
+// Pure, deterministic checks on the debate path — no LLM call. They decide
+// WHETHER a bounded repair re-prompt is warranted; the re-prompt DISPATCH (one
+// billable call per member per round, under a hard cap) and its auto-fire-vs-
+// confirm POLICY live in the run path and are gated behind
+// `ai_council.debate_gates.enabled` + the /council:design policy decision.
+//
+// The anti-conformity directive (the prompt-level half of the gates) is in
+// `prompts.ts` (`ANTI_CONFORMITY_DIRECTIVE`) and wired into the debate augmenter.
+
+import { jaccardSimilarity } from '../_lib/text_similarity.js';
+
+/** Near-duplicate bar: reuse the existing shared MERGE-level Jaccard threshold. */
+export const NOVELTY_DUP_THRESHOLD = 0.8;
+
+/** Minimum distinct dissenting members for the dissent quota to be satisfied. */
+export const DISSENT_QUOTA = 2;
+
+// Objection markers — the engine has no dissent parser (existing "dissent" is
+// LLM-score-derived, not text-marker-derived), so the marker is defined here.
+const _OBJECTION_RE =
+    /\b(disagree|disagrees|object|objection|reject|however|but\b|flaw|flawed|wrong|counter|counter-position|dissent|contradict|refute)\b/i;
+
+/**
+ * Novelty gate: a member's round-N reply is a **near-duplicate** of its own
+ * round-(N-1) reply when their normalised token similarity meets the threshold.
+ * Token-set Jaccard is order-independent and lowercased, so this is the
+ * "normalised near-duplicate" the gate targets. A duplicate → the member added
+ * nothing this round and warrants one targeted re-prompt.
+ */
+export function is_near_duplicate(
+    prevText: string,
+    currText: string,
+    threshold = NOVELTY_DUP_THRESHOLD,
+): boolean {
+    if (prevText.trim().length === 0 || currText.trim().length === 0) {
+        return false;
+    }
+    return jaccardSimilarity(prevText, currText) >= threshold;
+}
+
+/**
+ * Dissent quota: at least `quota` members voice an explicit objection (carry an
+ * objection marker). Below quota, the round has collapsed toward agreement and
+ * warrants one targeted dissent re-prompt to the most-recently-converged member.
+ * Empty / error replies do not count.
+ */
+export function count_dissenters(texts: readonly string[]): number {
+    let n = 0;
+    for (const t of texts) {
+        if (t.trim().length > 0 && _OBJECTION_RE.test(t)) {
+            n += 1;
+        }
+    }
+    return n;
+}
+
+/** True when the dissent quota is satisfied (≥ `quota` members objected). */
+export function dissent_quota_met(texts: readonly string[], quota = DISSENT_QUOTA): boolean {
+    return count_dissenters(texts) >= quota;
+}
+
+/** What the run path does when a gate warrants a repair re-prompt. */
+export type RepairAction = 'fire' | 'confirm' | 'skip';
+
+/**
+ * Repair-call policy — decided by the contested-design council pass
+ * (anthropic/claude-sonnet-4-5 + openai/gpt-4o, 2-round debate, 2026-07-12):
+ * a cost estimate is an **upper bound, not a spend commitment**, and repairs
+ * are failure-mode responses rather than the mainline path. So:
+ *
+ * - unattended runs (`--auto-continue`) **auto-fire** under the hard cap
+ *   (≤ 1 repair per member per round);
+ * - interactive runs get a **one-line confirm** before each repair call;
+ * - the cap is absolute: a member that already received its repair this round
+ *   is never re-prompted again (`skip`), regardless of mode;
+ * - manual-transport members follow the same policy (deliberation-flow impact,
+ *   not cost, governs — the repair "call" is one more paste block).
+ */
+export function repair_action(opts: {
+    auto_continue: boolean;
+    already_repaired: boolean;
+}): RepairAction {
+    if (opts.already_repaired) {
+        return 'skip';
+    }
+    return opts.auto_continue ? 'fire' : 'confirm';
+}

package/src/scripts/ai_council/orchestrator.ts

@@ -56,6 +56,8 @@ import type { ProjectContext } from './project_context.js';
 import type { AdvisorPlan } from './advisors.js';
 import {
     advisor_system_prompt,
+    ANTI_CONFORMITY_DIRECTIVE,
+    STANCE_LINE_CONTRACT,
     build_extraction_user_prompt,
     build_peer_review_user_prompt,
     build_scoring_user_prompt,
@@ -63,6 +65,8 @@ import {
     synthesis_template,
     system_prompt_for,
 } from './prompts.js';
+import { count_dissenters, dissent_quota_met, is_near_duplicate } from './debate_gates.js';
+import { parse_stance_line, render_vote_tally, tally_stances } from './stance_tally.js';
 
 // ── Python-format / stdlib parity helpers ────────────────────────────────
 //
@@ -409,6 +413,21 @@ export interface ConsultOptions {
         | ((round_idx: number, responses: CouncilResponse[]) => void)
         | null;
     advisor_plans?: Map<string, AdvisorPlan> | null;
+    /**
+     * Phase 1 (stance tally): when true, the FINAL round's user prompt appends
+     * the mandatory `STANCE:` closing-line contract so `stance_tally.ts` can
+     * tally option-level verdicts deterministically. Default `false` → every
+     * round's prompt is byte-identical to today.
+     */
+    stance_tally?: boolean;
+    /**
+     * Phase 1 stance-repair transport (2026-07-12 council policy): confirm per
+     * member in interactive runs; `null`/absent → a missing/unparseable stance
+     * stays a repair-marker in the tally, never an unplanned billable call.
+     */
+    on_stance_repair?: ((member: string) => boolean) | null;
+    /** Receives each stance-repair response so the caller can account its cost. */
+    on_stance_repair_result?: ((r: CouncilResponse) => void) | null;
 }
 
 /**
@@ -467,13 +486,23 @@ export function consult(
     let last_results: CouncilResponse[] = [];
     let current_user_prompt = question.user_prompt;
 
+    const stance_tally = opts.stance_tally ?? false;
     for (let round_idx = 0; round_idx < rounds; round_idx++) {
+        // Phase 1: the FINAL round carries the mandatory STANCE closing-line
+        // contract when the tally is enabled. Off (default) → the original
+        // question object flows through untouched, byte-identical to today.
+        const is_final = round_idx === rounds - 1;
+        const base_prompt = round_idx === 0 ? question.user_prompt : current_user_prompt;
+        const prompt_for_round =
+            is_final && stance_tally
+                ? `${base_prompt}\n\n---\n\n${STANCE_LINE_CONTRACT}`
+                : base_prompt;
         const round_question =
-            round_idx === 0
+            round_idx === 0 && prompt_for_round === question.user_prompt
                 ? question
                 : new CouncilQuestion({
                       mode: question.mode,
-                      user_prompt: current_user_prompt,
+                      user_prompt: prompt_for_round,
                       max_tokens: question.max_tokens,
                   });
         last_results = _run_round(members, round_question, resolvedBudget, spent, {
@@ -495,6 +524,46 @@ export function consult(
         }
     }
 
+    // Phase 1 stance repair: one bounded stance-line-only re-prompt per member
+    // whose final reply lacks a parseable STANCE line — dispatched only through
+    // the on_stance_repair transport, reusing _run_round (spend gate + ledger +
+    // stamping unchanged). The repaired stance line is APPENDED to the member's
+    // final text so the deterministic tally can read it.
+    const on_stance_repair = opts.on_stance_repair ?? null;
+    if (stance_tally && on_stance_repair !== null) {
+        for (let i = 0; i < last_results.length; i++) {
+            const r = last_results[i] as CouncilResponse;
+            if (r.error !== null || r.text.trim() === '' || parse_stance_line(r.text) !== null) {
+                continue;
+            }
+            const member = members[i];
+            if (member === undefined || !on_stance_repair(member.name)) {
+                continue;
+            }
+            const repairQ = new CouncilQuestion({
+                mode: question.mode,
+                user_prompt:
+                    `Your reply is missing the mandatory closing stance line. ` +
+                    `Reply with ONLY that single line for your final position.\n\n${STANCE_LINE_CONTRACT}`,
+                max_tokens: question.max_tokens,
+            });
+            const rr = _run_round([member], repairQ, resolvedBudget, spent, {
+                table,
+                on_overrun,
+                project,
+                original_ask,
+                advisor_plans,
+            });
+            const rep = rr[0];
+            if (rep !== undefined) {
+                opts.on_stance_repair_result?.(rep);
+                if (rep.error === null && parse_stance_line(rep.text) !== null) {
+                    r.text = `${r.text.trim()}\n\n${rep.text.trim()}`;
+                }
+            }
+        }
+    }
+
     return last_results;
 }
 
@@ -838,6 +907,9 @@ function _augment_for_debate_round(
     original_prompt: string,
     prior_responses: CouncilResponse[],
     next_round_number: number,
+    // Phase 3: when the debate gates are enabled, prepend the anti-conformity
+    // directive. Default `false` keeps the prompt byte-identical to today.
+    anti_conformity = false,
 ): string {
     const blocks: string[] = [];
     let label_idx = 0;
@@ -853,6 +925,7 @@ function _augment_for_debate_round(
         return original_prompt;
     }
     const prior_block = blocks.join('\n\n');
+    const anti_conformity_block = anti_conformity ? `${ANTI_CONFORMITY_DIRECTIVE}\n\n` : '';
     return (
         `${original_prompt}\n\n` +
         `---\n\n` +
@@ -861,6 +934,7 @@ function _augment_for_debate_round(
         `debate. Below are anonymised positions from independent\n` +
         `reviewers in the previous round. You do NOT know which model\n` +
         `produced which position.\n\n` +
+        anti_conformity_block +
         `Identify the SINGLE strongest opposing position and write a\n` +
         `rebuttal addressed at its strongest steel-manned form. Do NOT\n` +
         `search for common ground — name the load-bearing flaw the\n` +
@@ -870,6 +944,90 @@ function _augment_for_debate_round(
     );
 }
 
+/**
+ * Phase 3 post-round enforcement (2026-07-12 council policy): deterministic
+ * detectors flag members whose round added nothing (novelty near-duplicate of
+ * their own prior round) or when the round collapsed toward agreement (dissent
+ * quota unmet → the most-recently-converged member). At most ONE bounded repair
+ * re-prompt per member per round, dispatched only through the `on_repair`
+ * transport (confirm-interactive / auto-fire under --auto-continue); the repair
+ * call reuses `_run_round`, so the projected-spend gate, ledger, and metadata
+ * stamping apply unchanged. A successful repair REPLACES the member's entry so
+ * downstream rounds/persistence see the repaired reply.
+ */
+function _run_debate_gate_repairs(
+    members: ExternalAIClient[],
+    results: CouncilResponse[],
+    prior: CouncilResponse[],
+    round_question: CouncilQuestion,
+    budget: CostBudget,
+    spent: Spent,
+    round_opts: {
+        table: PriceTable | null;
+        on_overrun: OnOverrunCallback | null;
+        project: ProjectContext | null;
+        original_ask: string;
+        advisor_plans: Map<string, AdvisorPlan> | null;
+    },
+    on_repair: ((member: string, reason: string) => boolean) | null,
+): CouncilResponse[] {
+    const flagged: Array<{ idx: number; reason: string }> = [];
+    const okText = (r: CouncilResponse | undefined): string =>
+        r !== undefined && r.error === null ? r.text : '';
+    for (let i = 0; i < results.length; i++) {
+        const curr = okText(results[i]);
+        const prev = okText(prior[i]);
+        if (curr !== '' && prev !== '' && is_near_duplicate(prev, curr)) {
+            flagged.push({ idx: i, reason: 'novelty: near-duplicate of your own prior round' });
+        }
+    }
+    const texts = results.map((r) => okText(r));
+    if (!dissent_quota_met(texts.filter((t) => t !== ''))) {
+        // Most-recently-converged heuristic: the LAST member with a real reply
+        // that carries no objection marker.
+        for (let i = results.length - 1; i >= 0; i--) {
+            const t = okText(results[i]);
+            if (t !== '' && count_dissenters([t]) === 0 && !flagged.some((f) => f.idx === i)) {
+                flagged.push({ idx: i, reason: 'dissent quota unmet: state a genuine objection or confirm with a named reason' });
+                break;
+            }
+        }
+    }
+    if (flagged.length === 0 || on_repair === null) {
+        return results;
+    }
+    const repaired = new Set<number>();
+    const out = [...results];
+    for (const f of flagged) {
+        if (repaired.has(f.idx)) {
+            continue; // hard cap: <= 1 repair per member per round
+        }
+        const member = members[f.idx];
+        if (member === undefined) {
+            continue;
+        }
+        if (!on_repair(member.name, f.reason)) {
+            continue;
+        }
+        repaired.add(f.idx);
+        const repairQ = new CouncilQuestion({
+            mode: round_question.mode,
+            user_prompt:
+                `${round_question.user_prompt}\n\n---\n\n` +
+                `REPAIR RE-PROMPT (${f.reason}). Your previous reply this round did not ` +
+                `advance the debate. Respond again: either a genuinely updated position ` +
+                `naming the specific flaw that moved you, or an explicit defense with NEW evidence.`,
+            max_tokens: round_question.max_tokens,
+        });
+        const rr = _run_round([member], repairQ, budget, spent, round_opts);
+        const r0 = rr[0];
+        if (r0 !== undefined && r0.error === null && r0.text.trim() !== '') {
+            out[f.idx] = r0;
+        }
+    }
+    return out;
+}
+
 export interface RunDebateOptions {
     budget?: CostBudget | null;
     table?: PriceTable | null;
@@ -883,6 +1041,28 @@ export interface RunDebateOptions {
     on_continue?: DebateContinuePrompt | null;
     advisor_plans?: Map<string, AdvisorPlan> | null;
     seed_round_1?: CouncilResponse[] | null;
+    /**
+     * Phase 3: when true (from `ai_council.debate_gates.enabled`), round-2+
+     * prompts carry the anti-conformity directive. Default `false` → the debate
+     * prompt is byte-identical to today.
+     */
+    debate_gates?: boolean;
+    /**
+     * Phase 3 repair transport, per the 2026-07-12 council policy
+     * (`debate_gates.repair_action`): the CLI passes `() => true` under
+     * `--auto-continue` (auto-fire under the cap) or an interactive one-line
+     * confirm otherwise. `null`/absent → gates detect but never dispatch
+     * (no unplanned spend without an explicit transport).
+     */
+    on_repair?: ((member: string, reason: string) => boolean) | null;
+    /**
+     * Phase 3 restate pass (`ai_council.restate.enabled` / `--restate`): a
+     * pre-round-1 billable call per member collecting a <=50-word restatement
+     * + one alternative framing. Default off -> no extra calls, byte-identical.
+     */
+    restate?: boolean;
+    /** Receives the restate responses (rendering, divergence flags, cost). */
+    on_restate?: ((responses: CouncilResponse[]) => void) | null;
 }
 
 /**
@@ -944,6 +1124,27 @@ export function run_debate(
     const all_rounds: CouncilResponse[][] = [];
     let current_user_prompt = question.user_prompt;
 
+    // Phase 3 restate: one pre-round-1 call per member. Runs BEFORE any debate
+    // spend so a diverging restatement can be flagged before round-2 cost.
+    if (opts.restate === true) {
+        const restateQ = new CouncilQuestion({
+            mode: question.mode,
+            user_prompt:
+                `Before the debate begins: RESTATE the question below in at most 50 words, ` +
+                `then offer ONE alternative framing of it. Do not argue a position yet.\n\n---\n\n` +
+                `${question.user_prompt}`,
+            max_tokens: question.max_tokens,
+        });
+        const restated = _run_round(members, restateQ, budget, spent, {
+            table,
+            on_overrun,
+            project,
+            original_ask,
+            advisor_plans,
+        });
+        opts.on_restate?.(restated);
+    }
+
     for (let round_idx = 0; round_idx < max_rounds; round_idx++) {
         const round_number = round_idx + 1;
         let results: CouncilResponse[];
@@ -969,6 +1170,23 @@ export function run_debate(
             });
         }
 
+        if (opts.debate_gates === true && round_idx > 0 && all_rounds.length > 0) {
+            results = _run_debate_gate_repairs(
+                members,
+                results,
+                all_rounds[all_rounds.length - 1] as CouncilResponse[],
+                // round_idx > 0 here, so current_user_prompt IS this round's prompt.
+                new CouncilQuestion({
+                    mode: question.mode,
+                    user_prompt: current_user_prompt,
+                    max_tokens: question.max_tokens,
+                }),
+                budget,
+                spent,
+                { table, on_overrun, project, original_ask, advisor_plans },
+                opts.on_repair ?? null,
+            );
+        }
         all_rounds.push(results);
         if (on_round_complete !== null) {
             on_round_complete(round_number, results);
@@ -981,6 +1199,7 @@ export function run_debate(
                 question.user_prompt,
                 results,
                 round_number + 1,
+                opts.debate_gates ?? false,
             );
             // Hard-cap + continue-prompt gating before kicking off N+1.
             let next_round_usd: number;
@@ -1433,6 +1652,18 @@ export interface RenderOptions {
     consensus?: ConsensusResult | null;
     peer_review?: PeerReviewResult | null;
     explain_confidence?: boolean | null;
+    /**
+     * Phase 1 (stance tally): when true, a `### Vote Tally` block — computed
+     * deterministically from the final-round response texts — is rendered
+     * before the Convergence / Divergence slot. Default `false` → byte-identical.
+     */
+    stance_tally?: boolean;
+    /**
+     * Phase 2 (chairman): when a chairman-authored synthesis exists (persisted
+     * in the payload), it REPLACES the template in the Convergence/Divergence
+     * slot, prefixed by the visible annotation. Absent/null → byte-identical.
+     */
+    chairman?: { member: string | null; annotation: string; text: string | null } | null;
 }
 
 /**
@@ -1505,6 +1736,25 @@ export function render(responses: CouncilResponse[], opts: RenderOptions = {}):
     } else {
         body = '*to be summarised by the host agent*';
     }
+    const chairman = opts.chairman ?? null;
+    if (chairman !== null && chairman.text !== null && chairman.text.trim() !== '') {
+        // Chairman-authored synthesis replaces the template; the annotation is
+        // always visible (never a silent substitution).
+        body = `_${chairman.annotation}_\n\n${chairman.text.trim()}`;
+    } else if (chairman !== null) {
+        body = `_${chairman.annotation}_\n\n${body}`;
+    }
+    if (opts.stance_tally === true) {
+        // Phase 1: deterministic option-level tally from the final-round
+        // response texts (the STANCE closing lines live IN the texts, so the
+        // render is a pure projection — no config or transport needed here).
+        const tally = tally_stances(
+            responses
+                .filter((r) => !r.error)
+                .map((r) => ({ member: `${r.provider}:${r.model}`, text: r.text })),
+        );
+        blocks.push(render_vote_tally(tally));
+    }
     blocks.push(`## Convergence / Divergence\n\n${body}`);
     return blocks.join('\n\n---\n\n');
 }