@event4u/agent-config 14.20.0 → 14.22.0

package/src/scripts/ai_council/content_ceiling.ts

@@ -0,0 +1,79 @@
+/**
+ * One binary content ceiling per seat — road-to-admissible-council-seats 2.2.
+ *
+ * Redaction today is a SECRETS floor and says so
+ * (`src/skills/ai-council/references/cost-and-redaction.md`). Nothing above it
+ * could express "this project's diff may not go to that seat", which is a
+ * different question with a different answer: a diff carrying no secret at all
+ * is still the consumer's private source.
+ *
+ * Deliberately BINARY. A graded scale invites a middle value nobody can define
+ * and every caller reads differently; two values force the decision at
+ * authoring time, where it belongs.
+ *
+ *   public-artifact  — repo-owned artefacts: skill descriptions, the trigger
+ *                      corpus, rule text, bench fixtures. Already public.
+ *   project-content  — everything a consumer supplies. The DEFAULT, so an
+ *                      unclassified payload is treated as private rather than
+ *                      as publishable.
+ *
+ * A seat's ceiling is the most sensitive class it may receive. `public-artifact`
+ * is therefore the NARROWER seat: it admits public artefacts only.
+ */
+
+export const CONTENT_CLASSES = ['public-artifact', 'project-content'] as const;
+export type ContentClass = (typeof CONTENT_CLASSES)[number];
+
+/** The default for anything not explicitly classified: private, not public. */
+export const DEFAULT_CONTENT_CLASS: ContentClass = 'project-content';
+
+/** The default seat ceiling: unchanged behaviour for every existing seat. */
+export const DEFAULT_SEAT_CEILING: ContentClass = 'project-content';
+
+const _SET: ReadonlySet<string> = new Set<string>(CONTENT_CLASSES);
+
+/**
+ * Any configured value → a content class. Unrecognised input becomes
+ * `project-content`, the RESTRICTIVE value: a typo must narrow what a seat may
+ * receive, never widen it.
+ */
+export function classifyContentClass(raw: unknown, fallback: ContentClass = DEFAULT_CONTENT_CLASS): ContentClass {
+    if (typeof raw === 'string' && _SET.has(raw)) {
+        return raw as ContentClass;
+    }
+    return fallback;
+}
+
+export interface CeilingVerdict {
+    readonly admitted: boolean;
+    /** Non-null exactly when `admitted` is false. */
+    readonly reason: string | null;
+}
+
+/**
+ * Does a seat whose ceiling is `seatCeiling` admit a payload of `contentClass`?
+ *
+ * The one refusal is `project-content` into a `public-artifact` seat. Every
+ * other pairing is admitted, including public artefacts into a
+ * `project-content` seat — a seat cleared for private content is trivially
+ * cleared for public content, and refusing that would be a nonsense that
+ * disables the default seat for its own repo's fixtures.
+ *
+ * Refusal is a GREEN path (this roadmap's 2.2 verify): the caller drops the
+ * seat and the run continues. It is not an error, because a policy working as
+ * designed is not a failure.
+ */
+export function admitsContent(
+    seatCeiling: ContentClass,
+    contentClass: ContentClass,
+): CeilingVerdict {
+    if (seatCeiling === 'public-artifact' && contentClass === 'project-content') {
+        return {
+            admitted: false,
+            reason:
+                "seat ceiling is 'public-artifact'; the payload is classified " +
+                "'project-content' (consumer-supplied)",
+        };
+    }
+    return { admitted: true, reason: null };
+}

package/src/scripts/ai_council/deliberation_metrics.ts

@@ -0,0 +1,353 @@
+/**
+ * Two per-run deliberation measurements, both computed from outputs the run has
+ * already paid for: a per-correction stage attribution, and the
+ * `zero_marginal_value_call_rate`.
+ *
+ * Pure and offline. No model call, no new similarity measure — every judgement
+ * below reuses `is_near_duplicate` from `debate_gates.ts`, which is the
+ * repository's existing answer to "did this reply add anything", and the
+ * objection vocabulary that module already publishes. Forking a second
+ * similarity notion here would be two answers to one question, and the second
+ * is the one nobody updates.
+ *
+ * WHAT A CORRECTION IS, AND WHAT IT IS NOT.
+ *
+ * A correction is an objection-bearing sentence: one that carries a marker from
+ * {@link CORRECTION_MARKERS} and therefore names something it is pushing back
+ * on. Its FIRST STAGE is the earliest stage whose text contains that sentence
+ * or a near-duplicate of it — so a point raised in round 1 and repeated in
+ * round 3 is attributed to round 1, which is the whole question 10.2 asks.
+ *
+ * It decides ATTRIBUTION, never USEFULNESS. Whether a correction improved the
+ * verdict is a benchmark question and the benchmark has not run; a mechanism
+ * here that claimed to score usefulness would be inventing the number the
+ * forbidden-claims list exists to prevent. {@link attributeCorrections} answers
+ * "where did this first appear", and the word "useful" in the step it serves is
+ * a filter a human applies to the output, not one this code applies for them.
+ *
+ * WHAT ZERO MARGINAL VALUE IS.
+ *
+ * A call has zero marginal value when its text near-duplicates something the
+ * run had ALREADY received when the call was made. Not "duplicates the member's
+ * own prior round" — a member restating a peer's answer verbatim adds exactly
+ * as little, and the per-member reading would score it as novel. So the
+ * comparison set is every successful call that preceded it in run order.
+ *
+ * The first successful call is never zero-marginal: nothing preceded it. That
+ * makes the denominator at least 1 whenever the run produced any usable call,
+ * which is why the rate is a number rather than a `null` on every real run —
+ * and a run that produced NO usable call gets `null` with a stated reason,
+ * because zero calls is not a rate of zero.
+ *
+ * HONEST SCOPE. This measures textual novelty against an 0.8 Jaccard bar. It
+ * does not measure whether a call changed the verdict, and no consumer may read
+ * it as decision-quality evidence. The threshold is the shipped
+ * `NOVELTY_DUP_THRESHOLD`, inherited rather than tuned here; nothing has been
+ * benchmarked against it.
+ */
+import type { CouncilResponse } from './clients.js';
+import { is_near_duplicate, NOVELTY_DUP_THRESHOLD } from './debate_gates.js';
+
+/**
+ * Objection markers. Deliberately the same vocabulary the shipped dissent
+ * counter uses, kept as its own constant because that one counts members and
+ * this one classifies sentences.
+ */
+export const CORRECTION_MARKERS =
+    /\b(disagree|disagrees|object|objection|reject|rejects|however|but|flaw|flawed|wrong|incorrect|counter|counter-position|dissent|contradict|contradicts|refute|refutes|mistaken|overstates|understates)\b/i;
+
+/** One call the run made, in the order the run made it. */
+export interface DeliberationCall {
+    /** Stage the call belongs to — a round label, a phase name, whatever the caller uses. */
+    readonly stage: string;
+    /** `provider/model`, or any stable member identity. */
+    readonly member: string;
+    /** The reply text. Empty or error replies are not scored. */
+    readonly text: string;
+    /** True when the transport reported a failure; such a call is not scored. */
+    readonly failed?: boolean;
+}
+
+/** Where one correction first entered the deliberation. */
+export interface CorrectionAttribution {
+    /** The correction sentence, trimmed and whitespace-collapsed. */
+    readonly correction: string;
+    /** Stage label of the earliest call carrying it. */
+    readonly firstStage: string;
+    /** Zero-based index of that call in run order. */
+    readonly firstCallIndex: number;
+    /** Member whose call first carried it. */
+    readonly firstMember: string;
+    /** How many later calls restated it. 0 means it was said once. */
+    readonly restatements: number;
+}
+
+/**
+ * One deliberation stage and what it produced — the record shape
+ * `CouncilRouteRecord` carries, filled from a real run rather than by a test.
+ */
+export interface StageProduction {
+    readonly stage: string;
+    readonly produced: number;
+    readonly calls: number;
+}
+
+export interface ZeroMarginalValueReading {
+    /**
+     * Zero-marginal calls over scored calls, or `null` when the run produced no
+     * scorable call at all. `null` is "not measurable here", never zero.
+     */
+    readonly rate: number | null;
+    /** Why the rate is `null`. Empty string when it is not. */
+    readonly unavailableReason: string;
+    /** Every call the caller passed, failed and empty ones included. */
+    readonly callsTotal: number;
+    /** Calls that carried usable text — the denominator. */
+    readonly callsScored: number;
+    /** Calls that near-duplicated something already received — the numerator. */
+    readonly callsZeroMarginal: number;
+    /** The Jaccard bar used, published so the number can be re-derived. */
+    readonly threshold: number;
+}
+
+/** Decimals the published rate is rounded to, so a JSON round-trip is exact. */
+export const RATE_PRECISION = 6;
+
+function _round(value: number): number {
+    const f = 10 ** RATE_PRECISION;
+    return Math.round(value * f) / f;
+}
+
+function _usable(c: DeliberationCall): boolean {
+    return c.failed !== true && c.text.trim().length > 0;
+}
+
+/** Split a reply into sentences. Crude on purpose: no NLP, no dependency. */
+function _sentences(text: string): string[] {
+    return text
+        .split(/(?<=[.!?])\s+|\n+/)
+        .map((s) => s.replace(/\s+/g, ' ').trim())
+        .filter((s) => s.length > 0);
+}
+
+/**
+ * Correction sentences in one reply.
+ *
+ * A minimum length is applied because a bare "But." carries a marker and no
+ * position; the bar is characters rather than a judgement so it stays
+ * predictable.
+ */
+export const MIN_CORRECTION_CHARS = 25;
+
+export function correctionSentences(text: string): string[] {
+    return _sentences(text).filter(
+        (s) => s.length >= MIN_CORRECTION_CHARS && CORRECTION_MARKERS.test(s),
+    );
+}
+
+/**
+ * Attribute every correction to the earliest call that carried it.
+ *
+ * Calls are read in the order given, which must be run order — the attribution
+ * is only meaningful if "earlier in the list" means "earlier in the run".
+ */
+export function attributeCorrections(
+    calls: readonly DeliberationCall[],
+    threshold: number = NOVELTY_DUP_THRESHOLD,
+): CorrectionAttribution[] {
+    const out: CorrectionAttribution[] = [];
+    const restatements: number[] = [];
+
+    calls.forEach((call, idx) => {
+        if (!_usable(call)) return;
+        for (const sentence of correctionSentences(call.text)) {
+            const seen = out.findIndex(
+                (a) =>
+                    a.correction === sentence || is_near_duplicate(a.correction, sentence, threshold),
+            );
+            if (seen !== -1) {
+                restatements[seen] = (restatements[seen] ?? 0) + 1;
+                continue;
+            }
+            restatements.push(0);
+            out.push({
+                correction: sentence,
+                firstStage: call.stage,
+                firstCallIndex: idx,
+                firstMember: call.member,
+                restatements: 0,
+            });
+        }
+    });
+
+    return out.map((a, i) => ({ ...a, restatements: restatements[i] ?? 0 }));
+}
+
+/**
+ * Per-stage production, derived from the attribution so the two can never
+ * disagree: `produced` counts the corrections FIRST attributed to that stage.
+ */
+export function stageProduction(
+    calls: readonly DeliberationCall[],
+    attributions: readonly CorrectionAttribution[],
+): StageProduction[] {
+    const order: string[] = [];
+    const callCount = new Map<string, number>();
+    for (const c of calls) {
+        if (!callCount.has(c.stage)) {
+            order.push(c.stage);
+            callCount.set(c.stage, 0);
+        }
+        callCount.set(c.stage, (callCount.get(c.stage) ?? 0) + 1);
+    }
+    const produced = new Map<string, number>();
+    for (const a of attributions) {
+        produced.set(a.firstStage, (produced.get(a.firstStage) ?? 0) + 1);
+    }
+    return order.map((stage) => ({
+        stage,
+        produced: produced.get(stage) ?? 0,
+        calls: callCount.get(stage) ?? 0,
+    }));
+}
+
+/**
+ * The `zero_marginal_value_call_rate` for one run.
+ *
+ * Every scored call is compared against every scored call that preceded it. The
+ * comparison is O(n squared) in the number of calls, which is fine: a council
+ * run is single digits of calls per round.
+ */
+export function zeroMarginalValueRate(
+    calls: readonly DeliberationCall[],
+    threshold: number = NOVELTY_DUP_THRESHOLD,
+): ZeroMarginalValueReading {
+    const received: string[] = [];
+    let zero = 0;
+
+    for (const call of calls) {
+        if (!_usable(call)) continue;
+        const dup = received.some((prior) => is_near_duplicate(prior, call.text, threshold));
+        if (dup) zero += 1;
+        received.push(call.text);
+    }
+
+    if (received.length === 0) {
+        return {
+            rate: null,
+            unavailableReason:
+                'no scorable call — every call failed or returned empty text, and zero calls is not a rate of zero',
+            callsTotal: calls.length,
+            callsScored: 0,
+            callsZeroMarginal: 0,
+            threshold,
+        };
+    }
+
+    return {
+        rate: _round(zero / received.length),
+        unavailableReason: '',
+        callsTotal: calls.length,
+        callsZeroMarginal: zero,
+        callsScored: received.length,
+        threshold,
+    };
+}
+
+/** Everything this module emits for one run, ready to serialise. */
+export interface DeliberationMetrics {
+    readonly zero_marginal_value_call_rate: number | null;
+    readonly zero_marginal_value_unavailable_reason: string;
+    readonly calls_total: number;
+    readonly calls_scored: number;
+    readonly calls_zero_marginal: number;
+    readonly novelty_threshold: number;
+    readonly stage_outputs: readonly StageProduction[];
+    readonly correction_attributions: readonly CorrectionAttribution[];
+}
+
+/** Compute both measurements in one pass over the run's calls. */
+export function measureDeliberation(
+    calls: readonly DeliberationCall[],
+    threshold: number = NOVELTY_DUP_THRESHOLD,
+): DeliberationMetrics {
+    const attributions = attributeCorrections(calls, threshold);
+    const zmv = zeroMarginalValueRate(calls, threshold);
+    return {
+        zero_marginal_value_call_rate: zmv.rate,
+        zero_marginal_value_unavailable_reason: zmv.unavailableReason,
+        calls_total: zmv.callsTotal,
+        calls_scored: zmv.callsScored,
+        calls_zero_marginal: zmv.callsZeroMarginal,
+        novelty_threshold: zmv.threshold,
+        stage_outputs: stageProduction(calls, attributions),
+        correction_attributions: attributions,
+    };
+}
+
+/**
+ * The parts of one council run that made provider calls, in the order the run
+ * made them.
+ *
+ * Assembled here rather than at the call site because "which calls did this run
+ * make, and at which stage" is this module's own subject, and the CLI had the
+ * list only as a flat array with the stage boundaries implicit in the order.
+ * Both readings come out of one walk, so the billing total and the attribution
+ * can never be computed over different sets.
+ */
+export interface RunCallParts {
+    /** The deliberation responses `consult()` returned. */
+    readonly deliberation: readonly CouncilResponse[];
+    readonly peerReview?: readonly CouncilResponse[] | null;
+    readonly consensusExtraction?: readonly CouncilResponse[] | null;
+    readonly consensusScoring?: readonly CouncilResponse[] | null;
+    readonly chairman?: CouncilResponse | null;
+    readonly stanceRepairs?: readonly CouncilResponse[] | null;
+}
+
+/** The six stage labels, in run order. */
+export const RUN_STAGES = Object.freeze([
+    'deliberation',
+    'peer-review',
+    'consensus-extraction',
+    'consensus-scoring',
+    'chairman',
+    'stance-repair',
+] as const);
+
+export interface RunCalls {
+    /** Stage-labelled calls, for {@link measureDeliberation}. */
+    readonly calls: readonly DeliberationCall[];
+    /** The same calls as raw responses, in the same order, for cost aggregation. */
+    readonly responses: CouncilResponse[];
+}
+
+function _asCall(stage: string, r: CouncilResponse): DeliberationCall {
+    return {
+        stage,
+        member: `${r.provider}/${r.model}`,
+        text: r.text,
+        failed: r.error !== null && r.error !== undefined,
+    };
+}
+
+/** Walk one run's parts into stage-labelled calls plus the flat response list. */
+export function runCallsFrom(parts: RunCallParts): RunCalls {
+    const groups: ReadonlyArray<readonly [string, readonly CouncilResponse[]]> = [
+        ['deliberation', parts.deliberation],
+        ['peer-review', parts.peerReview ?? []],
+        ['consensus-extraction', parts.consensusExtraction ?? []],
+        ['consensus-scoring', parts.consensusScoring ?? []],
+        ['chairman', parts.chairman === null || parts.chairman === undefined ? [] : [parts.chairman]],
+        ['stance-repair', parts.stanceRepairs ?? []],
+    ];
+    const calls: DeliberationCall[] = [];
+    const responses: CouncilResponse[] = [];
+    for (const [stage, group] of groups) {
+        for (const r of group) {
+            calls.push(_asCall(stage, r));
+            responses.push(r);
+        }
+    }
+    return { calls, responses };
+}

package/src/scripts/ai_council/jury_aggregate.ts

@@ -0,0 +1,178 @@
+/**
+ * Jury aggregation — road-to-admissible-council-seats 3.2.
+ *
+ * BESIDE `consensus.ts`, not inside it, and the separation is the design.
+ * `consensus.ts` aggregates a COUNCIL, whose members carry verdicts.
+ * A jury does not: per ADR-257 a route this package did not pay for may propose
+ * and may score, never decide. Folding jury scoring into the consensus path
+ * would put a scorer on the code path that produces verdicts, which is the
+ * exact transition this roadmap's Risk 5 names — "scoring quietly becomes
+ * deciding".
+ *
+ * Two rules, and both are refusals.
+ *
+ * 1. **At least two model families, or the panel is ABSENT.** Not a warning, a
+ *    refusal: `docs/CLAIMS.md` records that a same-posture second vendor's
+ *    catches were a strict SUBSET of the first's. A same-family panel therefore
+ *    measures redundancy, and reporting redundancy as agreement is the failure
+ *    a diversity requirement exists to prevent.
+ * 2. **The aggregate is a trimmed statistic, never a vote count.** For the same
+ *    reason: counting agreeing voices rewards a panel for being correlated.
+ *
+ * What "trimmed" means here, exactly: with n >= 3 the single lowest and single highest score are dropped and the
+ * rest averaged — which at n = 3 IS the median, and is why one corrupted score
+ * in a three-judge panel cannot move the result the way it moves an arithmetic
+ * mean. With n = 2 there is nothing to trim; the mean is returned with
+ * `trimmed: 0` so a reader can see that no robustness was available rather than
+ * inferring it from a method name.
+ */
+
+import {
+    judgeBothOrders,
+    positionConsistency,
+    type JudgeConsistency,
+    type PairResolution,
+    type PairwiseJudge,
+    type SwapObservation,
+} from './judge_position_bias.js';
+
+/** One judge's score for one item. `family` is the MODEL family, not the seat. */
+export interface JuryScore {
+    readonly judge: string;
+    readonly family: string;
+    /** Any finite number. The aggregator does not impose a scale. */
+    readonly score: number;
+}
+
+/** Why a panel produced no aggregate. Each value is a REFUSAL, not an error. */
+export type JuryAbsentReason = 'no_scores' | 'single_family' | 'non_finite_score';
+
+export type JuryResult =
+    | {
+          readonly present: false;
+          readonly absentReason: JuryAbsentReason;
+          readonly reason: string;
+      }
+    | {
+          readonly present: true;
+          readonly aggregate: number;
+          readonly method: 'trimmed-mean';
+          /** How many scores the trim discarded. 0 when n < 3. */
+          readonly trimmed: number;
+          readonly judges: number;
+          readonly families: readonly string[];
+      };
+
+/**
+ * Aggregate one item's jury scores.
+ *
+ * Never throws on panel composition: a refused panel is a VERDICT the caller
+ * reads, the same shape the transport resolver uses for a refused seat. An
+ * exception would make "this panel does not qualify" indistinguishable from a
+ * bug at every call site.
+ */
+export function juryAggregate(scores: readonly JuryScore[]): JuryResult {
+    if (scores.length === 0) {
+        return { present: false, absentReason: 'no_scores', reason: 'no jury scores supplied' };
+    }
+    for (const s of scores) {
+        if (!Number.isFinite(s.score)) {
+            return {
+                present: false,
+                absentReason: 'non_finite_score',
+                reason: `judge ${s.judge} returned a non-finite score; the panel is refused rather than silently dropping it`,
+            };
+        }
+    }
+    const families = [...new Set(scores.map((s) => s.family))].sort();
+    if (families.length < 2) {
+        return {
+            present: false,
+            absentReason: 'single_family',
+            reason:
+                `panel spans ${families.length} model family (${families.join(', ') || 'none'}); ` +
+                'at least two are required — a same-family panel measures redundancy, not agreement',
+        };
+    }
+    const sorted = [...scores.map((s) => s.score)].sort((a, b) => a - b);
+    const trimmed = sorted.length >= 3 ? 2 : 0;
+    const kept = trimmed === 0 ? sorted : sorted.slice(1, sorted.length - 1);
+    const aggregate = kept.reduce((acc, v) => acc + v, 0) / kept.length;
+    return {
+        present: true,
+        aggregate,
+        method: 'trimmed-mean',
+        trimmed,
+        judges: scores.length,
+        families,
+    };
+}
+
+/** One judge's swapped observation plus the family it belongs to. */
+export interface JuryPairwiseJudge {
+    readonly judge: string;
+    readonly family: string;
+    readonly fn: PairwiseJudge;
+}
+
+export interface JuryPairwiseResult {
+    readonly present: boolean;
+    readonly absentReason: JuryAbsentReason | null;
+    readonly reason: string | null;
+    /** Panel resolution, or `null` when the panel is absent. */
+    readonly resolution: PairResolution | null;
+    readonly observations: readonly SwapObservation[];
+    readonly consistency: readonly JudgeConsistency[];
+}
+
+/**
+ * Run a pairwise jury with the position swap applied PER JUDGE.
+ *
+ * Reuses `judge_position_bias.ts` rather than re-implementing the swap: a
+ * second implementation of "show both orders and reconcile" is a second place
+ * for the reconciliation to be subtly wrong, and that module already resolves a
+ * verdict that does not survive the swap to `inconsistent` rather than to a
+ * winner.
+ *
+ * The panel resolution is the strict majority of the judges' own resolutions,
+ * and `inconsistent` judges are counted in the DENOMINATOR — a judge that
+ * flipped has an opinion about nothing, and dropping it from the denominator
+ * would let two stable judges out of five look unanimous.
+ */
+export function juryPairwise(
+    id: string,
+    a: string,
+    b: string,
+    judges: readonly JuryPairwiseJudge[],
+): JuryPairwiseResult {
+    const families = [...new Set(judges.map((j) => j.family))].sort();
+    if (judges.length === 0 || families.length < 2) {
+        return {
+            present: false,
+            absentReason: judges.length === 0 ? 'no_scores' : 'single_family',
+            reason:
+                judges.length === 0
+                    ? 'no judges supplied'
+                    : `panel spans ${families.length} model family; at least two are required`,
+            resolution: null,
+            observations: [],
+            consistency: [],
+        };
+    }
+    const observations: SwapObservation[] = [];
+    const consistency: JudgeConsistency[] = [];
+    const tally = new Map<PairResolution, number>();
+    for (const j of judges) {
+        const obs = judgeBothOrders(id, a, b, j.fn);
+        observations.push(obs);
+        consistency.push(positionConsistency(j.judge, [obs]));
+        tally.set(obs.resolution, (tally.get(obs.resolution) ?? 0) + 1);
+    }
+    let resolution: PairResolution = 'inconsistent';
+    for (const [k, v] of tally) {
+        if (v * 2 > judges.length) {
+            resolution = k;
+        }
+    }
+    return { present: true, absentReason: null, reason: null, resolution, observations, consistency };
+}

package/src/scripts/ai_council/prompts.ts

@@ -25,6 +25,7 @@
 import { wrapUntrustedBlocks } from '../_lib/untrusted_content.js';
 
 import type { ProjectContext } from './project_context.js';
+import { RESOLVING_EVIDENCE_SECTION } from './synthesis_disagreement.js';
 
 // Python: NEUTRALITY_PREAMBLE = """\...""".strip()
 export const NEUTRALITY_PREAMBLE = `You are an independent reviewer. You have NOT seen any prior reasoning,
@@ -302,6 +303,8 @@ 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.
 
+${RESOLVING_EVIDENCE_SECTION}
+
 ### Kill criteria
 Observable conditions that would falsify this recommendation without
 re-convening the council. Each entry names a threshold or a specific
@@ -329,6 +332,8 @@ and the host agent confirms are load-bearing. Maximum five.
 APPROVE / REQUEST_CHANGES / REJECT and a single sentence justifying
 the verdict, anchored on the strongest consensus or must-fix line.
 
+${RESOLVING_EVIDENCE_SECTION}
+
 ### Kill criteria
 Observable conditions that would falsify this verdict without re-convening
 the council (a failing check, a missing test, a regression signal). Each
@@ -363,6 +368,8 @@ separate certainty word for that; \`evidence:\` measures how well a
 finding is supported, and being alone in raising it is a different
 property the section already carries.
 
+${RESOLVING_EVIDENCE_SECTION}
+
 ### Kill criteria
 Observable conditions that would falsify the analysis's leading finding
 without re-convening the council. Each entry names a threshold or event.
@@ -381,6 +388,8 @@ 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:
 
+${RESOLVING_EVIDENCE_SECTION}
+
 ### Kill criteria
 Observable conditions that would falsify the direction you converged on,
 without re-convening the council. Each entry names a threshold or event.