@event4u/agent-config 8.10.0 → 8.11.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,7 @@ import {
     synthesis_template,
     system_prompt_for,
 } from './prompts.js';
+import { render_vote_tally, tally_stances } from './stance_tally.js';
 
 // ── Python-format / stdlib parity helpers ────────────────────────────────
 //
@@ -409,6 +412,13 @@ 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;
 }
 
 /**
@@ -467,13 +477,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, {
@@ -838,6 +858,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 +876,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 +885,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` +
@@ -883,6 +908,12 @@ 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;
 }
 
 /**
@@ -981,6 +1012,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 +1465,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 +1549,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');
 }

package/src/scripts/ai_council/prompts.ts

@@ -148,6 +148,28 @@ one of several independent reviewers. Round-specific instructions:
 End each round with: a one-line position summary and the single
 piece of evidence that would change your mind.`;
 
+/**
+ * Mandatory closing-line contract appended to the FINAL round when
+ * `ai_council.stance_tally` is enabled (Phase 1). Peers backing the same option
+ * MUST reuse the same label so the deterministic tally can canonicalise it;
+ * `abstain` is allowed. Parsed by `stance_tally.parse_stance_line` — the tally
+ * never infers a stance from the surrounding prose, so an omitted or malformed
+ * line becomes a repair-marker, not a guess.
+ */
+export const STANCE_LINE_CONTRACT = `Close your reply with EXACTLY this line, and nothing after it:
+STANCE: <option-label> | CONFIDENCE: high|med|low | DEALBREAKER: yes|no
+Reuse the SAME <option-label> as any peer backing the same option (match their wording); use \`abstain\` only if you genuinely cannot choose. CONFIDENCE is your certainty in the pick; DEALBREAKER is \`yes\` only if you would block on the alternative.`;
+
+/**
+ * Anti-conformity directive appended to round-2+ debate prompts when
+ * `ai_council.debate_gates` is enabled (road-to-opt-council-deliberation
+ * Phase 3). Counters the round-over-round convergence-to-consensus drift the
+ * `rounds:N` path otherwise invites. Byte-identical across the api / cli /
+ * manual transports (it becomes part of the shared `user_prompt`, which every
+ * client's `ask()` receives verbatim), so no per-transport special-casing.
+ */
+export const ANTI_CONFORMITY_DIRECTIVE = `Anti-conformity rule for this round: defend a position you still believe is correct. Change your position ONLY when a specific, named flaw in it has been identified — and you must name that flaw explicitly to justify the change. Do not soften or converge merely because other reviewers disagree; agreement without a named reason is conformity, not reasoning.`;
+
 const _MODE_TABLE: Record<string, string> = {
     prompt: PROMPT_MODE,
     roadmap: ROADMAP_MODE,
@@ -233,8 +255,15 @@ read it directly from a response.
 A single sentence: which course the host agent should advise the
 user to take, grounded in the strongest converged point.
 
-### Next step
-One concrete next action the user can take in their current turn.`;
+### Kill criteria
+Observable conditions that would falsify this recommendation without
+re-convening the council. Each entry names a threshold or a specific
+event — never a vague "if it goes wrong". Omit only if genuinely none
+exist, and say so explicitly.
+
+### Concrete next step
+Exactly one artefact-producing action the user can take in their
+current turn.`;
 
 export const PR_SYNTHESIS = `Summarise the council with the PR-review shape below.
 
@@ -251,7 +280,17 @@ and the host agent confirms are load-bearing. Maximum five.
 
 ### Recommendation
 APPROVE / REQUEST_CHANGES / REJECT and a single sentence justifying
-the verdict, anchored on the strongest consensus or must-fix line.`;
+the verdict, anchored on the strongest consensus or must-fix line.
+
+### Kill criteria
+Observable conditions that would falsify this verdict without re-convening
+the council (a failing check, a missing test, a regression signal). Each
+entry names a threshold or a specific event. Omit only if genuinely none
+exist, and say so.
+
+### Concrete next step
+Exactly one artefact-producing action the author can take in their current
+turn.`;
 
 export const ANALYSIS_SYNTHESIS = `Summarise the council with the analysis-lens shape below.
 
@@ -270,19 +309,41 @@ metadata shape as Top-10.
 ### Outliers
 Single-reviewer findings the others did not engage with. Keep them
 — they are signal for a future deeper analysis pass — but mark each
-as \`unverified-by-council\`.`;
-
-// Creative lenses — open-ended prose, no template. The renderer keeps
-// the bare "Convergence / Divergence" slot so the host agent can write
-// free-form synthesis.
-const _CREATIVE_PASSTHROUGH = '';
+as \`unverified-by-council\`.
+
+### Kill criteria
+Observable conditions that would falsify the analysis's leading finding
+without re-convening the council. Each entry names a threshold or event.
+Omit only if genuinely none exist, and say so.
+
+### Concrete next step
+Exactly one artefact-producing action the user can take in their current
+turn.`;
+
+// Creative lenses — free-form prose synthesis, then the two required
+// verdict-discipline sections. The body stays open-ended (the host agent
+// writes the Convergence / Divergence prose on its own merits); only the
+// falsifiable close is mandated, so every lens carries Kill criteria +
+// Concrete next step (road-to-opt-council-deliberation Phase 0).
+export const CREATIVE_SYNTHESIS = `Write a free-form convergence / divergence
+synthesis of the council in prose — no fixed section shape for the body.
+Then close with exactly these two sections:
+
+### Kill criteria
+Observable conditions that would falsify the direction you converged on,
+without re-convening the council. Each entry names a threshold or event.
+Omit only if genuinely none exist, and say so.
+
+### Concrete next step
+Exactly one artefact-producing action the user can take in their current
+turn.`;
 
 const _SYNTHESIS_TABLE: Record<string, string> = {
     default: DEFAULT_SYNTHESIS,
     pr: PR_SYNTHESIS,
     analysis: ANALYSIS_SYNTHESIS,
-    design: _CREATIVE_PASSTHROUGH,
-    optimize: _CREATIVE_PASSTHROUGH,
+    design: CREATIVE_SYNTHESIS,
+    optimize: CREATIVE_SYNTHESIS,
 };
 
 // Input modes inherit the `default` decision template. Lens overrides
@@ -371,6 +432,55 @@ export function all_synthesis_modes(): string[] {
     return Object.keys(_SYNTHESIS_TABLE).sort();
 }
 
+/**
+ * Raised when a completed synthesis is missing a required verdict-discipline
+ * section (Kill criteria / Concrete next step) or carries it empty. Named so
+ * the render step fails loudly rather than emitting an unfalsifiable verdict.
+ * Mirrors the `CouncilConfigError` named-error precedent in `config.ts`.
+ */
+export class SynthesisRenderError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'SynthesisRenderError';
+    }
+}
+
+/** The two sections every lens synthesis must close with (Phase 0). */
+export const REQUIRED_SYNTHESIS_SECTIONS = ['Kill criteria', 'Concrete next step'] as const;
+
+/**
+ * Validate a **completed** synthesis (the host- or chairman-authored text that
+ * fills the Convergence / Divergence slot) — not the template prompt. Every
+ * lens must close with a non-empty `### Kill criteria` and `### Concrete next
+ * step`; a missing or placeholder-empty section throws `SynthesisRenderError`
+ * naming the first offender. Called on the synthesis-emit path (the chairman
+ * synthesis in Phase 2, and any future synthesis-record step); safe to call on
+ * decision and creative lenses alike, since both now require the two sections.
+ */
+export function assert_synthesis_sections(text: string): void {
+    const lines = text.split('\n');
+    const isHeading = (l: string): boolean => /^#{2,4}\s/.test(l);
+    for (const section of REQUIRED_SYNTHESIS_SECTIONS) {
+        const headingRe = new RegExp(`^#{2,4}\\s+${section}\\s*$`, 'i');
+        const idx = lines.findIndex((l) => headingRe.test(l));
+        if (idx === -1) {
+            throw new SynthesisRenderError(
+                `synthesis is missing the required "### ${section}" section`,
+            );
+        }
+        let body = '';
+        for (let i = idx + 1; i < lines.length; i++) {
+            if (isHeading(lines[i] as string)) break;
+            body += lines[i];
+        }
+        if (body.trim().length === 0) {
+            throw new SynthesisRenderError(
+                `synthesis "### ${section}" section is empty (placeholder)`,
+            );
+        }
+    }
+}
+
 /**
  * Drop any *whole line* containing a host-agent identity substring.
  *

package/src/scripts/ai_council/replay.ts

@@ -308,6 +308,23 @@ export function render_decision_replay(inputs: DecisionReplayInputs): string {
         }
         lines.push(`**Synthesis verdict**: ${verdict} consensus — ${f.source} sourced.\n`);
     }
+    // Aggregate render lines (Phase 0 fold): one evidence-label line + one
+    // provider-spread line — folded into the trailer, not a new template
+    // section (gap-table FOLD row: evidence labels + provider spread → replay).
+    const evTally: Record<string, number> = { H: 0, M: 0, L: 0 };
+    for (const f of ranked) {
+        const em = _metaGet(inputs.metadata, f.id);
+        const q = (em?.evidence_quality ?? '').toUpperCase().charAt(0);
+        if (q === 'H' || q === 'M' || q === 'L') {
+            evTally[q] = (evTally[q] as number) + 1;
+        }
+    }
+    const providers = new Set(inputs.deliberation.map((r) => r.provider));
+    lines.push(
+        `- **Evidence spread**: ${evTally.H} high · ${evTally.M} medium · ` +
+            `${evTally.L} low (across ${ranked.length} finding(s))\n` +
+            `- **Provider spread**: ${providers.size} distinct provider(s) deliberated\n`,
+    );
     const mode_label = inputs.include_member_arguments ? 'full' : 'redacted (counts only)';
     lines.push(`---\n\n_artefact mode: ${mode_label}_\n`);
     return _pyRStrip(lines.join('\n')) + '\n';