@event4u/agent-config 9.2.0 → 9.4.0

package/src/scripts/ai_council/orchestrator.ts

@@ -484,7 +484,10 @@ export function consult(
 
     const spent: Spent = { input: 0, output: 0, usd: 0.0 };
     let last_results: CouncilResponse[] = [];
-    let current_user_prompt = question.user_prompt;
+    // A3 read unlock: the stable prefix is ALWAYS the original user prompt;
+    // per-round critiques + the STANCE contract ride in a volatile suffix so
+    // cache-capable clients read the [system + artefact] prefix on round N+1.
+    let current_suffix = '';
 
     const stance_tally = opts.stance_tally ?? false;
     for (let round_idx = 0; round_idx < rounds; round_idx++) {
@@ -492,11 +495,11 @@ export function consult(
         // 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 =
+        const suffix_for_round =
             is_final && stance_tally
-                ? `${base_prompt}\n\n---\n\n${STANCE_LINE_CONTRACT}`
-                : base_prompt;
+                ? `${current_suffix}\n\n---\n\n${STANCE_LINE_CONTRACT}`
+                : current_suffix;
+        const prompt_for_round = `${question.user_prompt}${suffix_for_round}`;
         const round_question =
             round_idx === 0 && prompt_for_round === question.user_prompt
                 ? question
@@ -511,16 +514,15 @@ export function consult(
             project,
             original_ask,
             advisor_plans,
+            split: suffix_for_round
+                ? { stable: question.user_prompt, suffix: suffix_for_round }
+                : null,
         });
         if (on_round_complete !== null) {
             on_round_complete(round_idx, last_results);
         }
         if (round_idx + 1 < rounds) {
-            current_user_prompt = _augment_for_next_round(
-                question.user_prompt,
-                last_results,
-                round_idx + 2,
-            );
+            current_suffix = _critique_suffix(last_results, round_idx + 2);
         }
     }
 
@@ -579,6 +581,14 @@ interface RunRoundOptions {
     project: ProjectContext | null;
     original_ask: string;
     advisor_plans?: Map<string, AdvisorPlan> | null;
+    /**
+     * A3 cross-round read unlock: when set, members are called via
+     * `ask_split(system, stable, suffix)` so cache-capable clients keep the
+     * breakpoint on the byte-stable [system + artefact] prefix and the
+     * per-round critiques ride behind it. `question.user_prompt` stays the
+     * full concatenation (estimates + persistence unchanged).
+     */
+    split?: { stable: string; suffix: string } | null;
 }
 
 /** Run a single round; mutate `spent` with cumulative totals. */
@@ -626,11 +636,18 @@ function _run_round(
         if (!(_getattr(member, 'billable', true) as boolean)) {
             let response: CouncilResponse;
             try {
-                response = member.ask(
-                    _system_prompt_for_member(member),
-                    question.user_prompt,
-                    question.max_tokens,
-                );
+                response = opts.split
+                    ? member.ask_split(
+                          _system_prompt_for_member(member),
+                          opts.split.stable,
+                          opts.split.suffix,
+                          question.max_tokens,
+                      )
+                    : member.ask(
+                          _system_prompt_for_member(member),
+                          question.user_prompt,
+                          question.max_tokens,
+                      );
             } catch (exc) {
                 response = new CouncilResponse({
                     provider: member.name,
@@ -702,11 +719,18 @@ function _run_round(
         // ── actual call ──────────────────────────────────────────────
         let response: CouncilResponse;
         try {
-            response = member.ask(
-                _system_prompt_for_member(member),
-                question.user_prompt,
-                question.max_tokens,
-            );
+            response = opts.split
+                ? member.ask_split(
+                      _system_prompt_for_member(member),
+                      opts.split.stable,
+                      opts.split.suffix,
+                      question.max_tokens,
+                  )
+                : member.ask(
+                      _system_prompt_for_member(member),
+                      question.user_prompt,
+                      question.max_tokens,
+                  );
         } catch (exc) {
             response = new CouncilResponse({
                 provider: member.name,
@@ -796,6 +820,19 @@ function _augment_for_next_round(
     original_prompt: string,
     prior_responses: CouncilResponse[],
     next_round_number: number,
+): string {
+    return `${original_prompt}${_critique_suffix(prior_responses, next_round_number)}`;
+}
+
+/**
+ * The volatile per-round block ONLY (A3 read unlock) — everything after the
+ * byte-stable original prompt. Empty string when no prior response survives.
+ * `_augment_for_next_round` = original + this; the rounds loop feeds this to
+ * `ask_split` so the cached [system + artefact] prefix stays byte-identical.
+ */
+function _critique_suffix(
+    prior_responses: CouncilResponse[],
+    next_round_number: number,
 ): string {
     const blocks: string[] = [];
     let label_idx = 0;
@@ -808,11 +845,11 @@ function _augment_for_next_round(
         blocks.push(`### Reviewer ${label}\n\n${_pyStrip(r.text)}`);
     }
     if (blocks.length === 0) {
-        return original_prompt;
+        return '';
     }
     const prior_block = blocks.join('\n\n');
     return (
-        `${original_prompt}\n\n` +
+        `\n\n` +
         `---\n\n` +
         `## Prior round critiques (round ${next_round_number - 1})\n\n` +
         `You are now in round ${next_round_number}. Below are anonymised\n` +
@@ -910,6 +947,15 @@ function _augment_for_debate_round(
     // 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 {
+    return `${original_prompt}${_debate_suffix(prior_responses, next_round_number, anti_conformity)}`;
+}
+
+/** Debate twin of `_critique_suffix` — the volatile block only (A3). */
+function _debate_suffix(
+    prior_responses: CouncilResponse[],
+    next_round_number: number,
+    anti_conformity = false,
 ): string {
     const blocks: string[] = [];
     let label_idx = 0;
@@ -922,12 +968,12 @@ function _augment_for_debate_round(
         blocks.push(`### Reviewer ${label}\n\n${_pyStrip(r.text)}`);
     }
     if (blocks.length === 0) {
-        return original_prompt;
+        return '';
     }
     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` +
         `---\n\n` +
         `## Prior round positions (round ${next_round_number - 1})\n\n` +
         `You are now in round ${next_round_number} of a structured\n` +
@@ -1122,6 +1168,9 @@ export function run_debate(
 
     const spent: Spent = { input: 0, output: 0, usd: 0.0 };
     const all_rounds: CouncilResponse[][] = [];
+    // A3 read unlock (debate twin): stable prefix = the original prompt; the
+    // per-round positions block rides in a volatile suffix (see consult loop).
+    let current_suffix = '';
     let current_user_prompt = question.user_prompt;
 
     // Phase 3 restate: one pre-round-1 call per member. Runs BEFORE any debate
@@ -1167,6 +1216,9 @@ export function run_debate(
                 project,
                 original_ask,
                 advisor_plans,
+                split: current_suffix
+                    ? { stable: question.user_prompt, suffix: current_suffix }
+                    : null,
             });
         }
 
@@ -1195,12 +1247,12 @@ export function run_debate(
         // Prep the user-prompt for the next round so the cost estimate
         // below covers the augmented bytes.
         if (round_idx + 1 < max_rounds) {
-            current_user_prompt = _augment_for_debate_round(
-                question.user_prompt,
+            current_suffix = _debate_suffix(
                 results,
                 round_number + 1,
                 opts.debate_gates ?? false,
             );
+            current_user_prompt = `${question.user_prompt}${current_suffix}`;
             // Hard-cap + continue-prompt gating before kicking off N+1.
             let next_round_usd: number;
             if (table !== null) {

package/src/scripts/ai_council/pricing.ts

@@ -119,6 +119,65 @@ export interface CacheTokenBreakdown {
     output_tokens: number;
 }
 
+/** A1↔A3 coupling verdict for a proposed model downgrade (Phase A3). */
+export interface DowngradeCoupling {
+    /** Full-rate cost delta per call: estimate(current) − estimate(suggested). */
+    downgrade_savings_usd: number;
+    /**
+     * Cache value forfeited by leaving the current model: the prompt cache is
+     * model-scoped, so a downgraded member re-pays the full input rate on the
+     * span that would have been read back at CACHE_READ_MULTIPLIER.
+     */
+    lost_cache_savings_usd: number;
+    /** True iff downgrade_savings_usd > lost_cache_savings_usd. */
+    net_positive: boolean;
+}
+
+/**
+ * Decide whether a suggested downgrade is net-positive AFTER accounting for
+ * the model-scoped prompt cache (roadmap A3 gate: downgrade only when
+ * `downgrade_savings > lost_cache_savings`).
+ *
+ * `cache.expected_reads` is the number of same-model cache reads the run
+ * would plausibly realize at the CURRENT model (rounds − 1 on multi-round
+ * runs, 0 on one-shot paths like the low-impact fast-path). With caching
+ * disabled the lost term is 0 and any cheaper model wins.
+ */
+export function downgrade_coupling(
+    provider: string,
+    current_model: string,
+    suggested_model: string,
+    input_tokens: number,
+    max_output_tokens: number,
+    cache: {
+        enabled: boolean;
+        cacheable_prefix_tokens: number;
+        expected_reads: number;
+    },
+    table: PriceTable,
+): DowngradeCoupling {
+    const cur = estimate_cost(provider, current_model, input_tokens, max_output_tokens, table);
+    const sug = estimate_cost(provider, suggested_model, input_tokens, max_output_tokens, table);
+    const downgrade_savings_usd =
+        cur.input_usd + cur.output_usd - (sug.input_usd + sug.output_usd);
+    let lost_cache_savings_usd = 0;
+    if (cache.enabled && cache.expected_reads > 0 && cache.cacheable_prefix_tokens > 0) {
+        const cur_rates = lookup(table, provider, current_model);
+        if (cur_rates !== null) {
+            lost_cache_savings_usd =
+                (cache.cacheable_prefix_tokens / 1_000_000) *
+                cur_rates.input_per_1m_usd *
+                (1 - CACHE_READ_MULTIPLIER) *
+                cache.expected_reads;
+        }
+    }
+    return {
+        downgrade_savings_usd,
+        lost_cache_savings_usd,
+        net_positive: downgrade_savings_usd > lost_cache_savings_usd,
+    };
+}
+
 /**
  * Realized cost of a call given OBSERVED cache-token counts (from
  * `CouncilResponse.usage`). Deliberately separate from `estimate_cost`, which

package/src/scripts/ai_council/prompts.ts

@@ -88,6 +88,13 @@ correctness lens AND a shipping-risk lens:
    Is the blast radius bigger than the title implies?
 5. Reviewer fatigue — is anything in the diff that a tired reviewer
    would rubber-stamp but should not?
+6. Reuse & object-oriented shape — does the diff reinvent a component
+   or abstraction the codebase likely already provides (should compose
+   / reuse instead), and where it adds structure, is the OO shape
+   (encapsulation, composition over inheritance) justified by
+   complexity it removes rather than speculative abstraction? Judge in
+   the codebase's own paradigm — do not push classes onto functional /
+   pipeline code; smallest-change still wins over OO advocacy.
 End with: APPROVE / REQUEST_CHANGES / REJECT, one sentence why, and
 the single highest-leverage change the PR author should make before
 merge.`;

package/src/scripts/ai_council/stance_tally.ts

@@ -59,6 +59,37 @@ export interface StanceTallyResult {
 const _STANCE_RE =
     /STANCE:\s*(.+?)\s*\|\s*CONFIDENCE:\s*(high|med(?:ium)?|low)\s*\|\s*DEALBREAKER:\s*(yes|no)/gi;
 
+
+/** Run the strict stance grammar; return the LAST match or null. */
+function _last_stance_match(text: string): RegExpExecArray | null {
+    _STANCE_RE.lastIndex = 0;
+    let last: RegExpExecArray | null = null;
+    let m: RegExpExecArray | null;
+    while ((m = _STANCE_RE.exec(text)) !== null) {
+        last = m;
+    }
+    return last;
+}
+
+/**
+ * Normalize the two cosmetic defect classes the lenient pass forgives, on
+ * lines that mention STANCE only: markdown emphasis characters and comma /
+ * semicolon field separators. Everything else is left byte-identical.
+ */
+export function _normalize_stance_cosmetics(text: string): string {
+    return text
+        .split('\n')
+        .map((line) => {
+            if (!/stance/i.test(line)) {
+                return line;
+            }
+            let out = line.replace(/[*_`]/g, '');
+            out = out.replace(/\s*[;,]\s*(?=(?:CONFIDENCE|DEALBREAKER)\b)/gi, ' | ');
+            return out;
+        })
+        .join('\n');
+}
+
 /**
  * Parse the member's stance line from their reply text. Returns the LAST stance
  * line if several appear (the final, most-authoritative one), or `null` when no
@@ -66,11 +97,17 @@ const _STANCE_RE =
  * infers a stance from the surrounding prose.
  */
 export function parse_stance_line(text: string): Omit<StanceLine, 'member'> | null {
-    _STANCE_RE.lastIndex = 0;
-    let last: RegExpExecArray | null = null;
-    let m: RegExpExecArray | null;
-    while ((m = _STANCE_RE.exec(text)) !== null) {
-        last = m;
+    let last = _last_stance_match(text);
+    if (last === null) {
+        // Lenient fallback (A3 repair-tightening): a stance whose only defect
+        // is cosmetic — markdown emphasis around the field names (`**STANCE:**`),
+        // or `,`/`;` used where the contract says `|` — is NOT "genuinely
+        // unparseable" and must not burn a repair call. Normalize those two
+        // defect classes on stance-bearing lines only, then re-run the SAME
+        // strict grammar. Anything the strict grammar still rejects (missing
+        // fields, invalid enum values, no STANCE line at all) stays a repair
+        // marker — leniency never invents a stance from prose.
+        last = _last_stance_match(_normalize_stance_cosmetics(text));
     }
     if (last === null) {
         return null;

package/src/scripts/build_catalog_index.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env tsx
+/**
+ * Build the lazy-catalog index — `dist/catalog-index-v1.json`.
+ *
+ * A queryable metadata index over every skill, persona, and domain command:
+ * `{ id, cls, name, description, tags, path }` — **metadata only, no bodies**.
+ * Bodies load lazily from disk at `catalog_load` time (the stdio server has the
+ * repo underneath it, unlike the upstream Hermes plugin which embeds bodies).
+ *
+ * Feeds the `catalog_search / _inspect / _load` MCP tools (built as discovery
+ * stubs; activation deferred behind a quality A/B — see
+ * road-to-persona-library-harvest.md Phase 2). Deterministic output (entries
+ * sorted by (cls, id), stable keys) so the artifact diffs cleanly. `--check`
+ * fails on drift instead of writing (CI mode), mirroring the
+ * build_mcp_registry_manifest convention.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { parse as parseYaml } from 'yaml';
+
+const _HERE = fileURLToPath(import.meta.url);
+export const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+// The `-v1` namespace tracks `schema_version` below (per lint_versioned_cache):
+// bump both together on a shape change so any stale cached copy self-invalidates
+// by name rather than being read as the new shape.
+export const OUT = path.join(ROOT, 'dist', 'catalog-index-v1.json');
+
+export type CatalogClass = 'skill' | 'persona' | 'command';
+
+export interface CatalogIndexEntry {
+    /** Globally unique handle: `<cls>:<slug>`. */
+    id: string;
+    cls: CatalogClass;
+    name: string;
+    description: string;
+    /** Domain / packs / tier — for filtering and search-text weighting. */
+    tags: string[];
+    /** Repo-relative path to the body (resolved by catalog_load). */
+    path: string;
+}
+
+const SKILLS_DIR = path.join(ROOT, 'src', 'skills');
+const PERSONAS_DIR = path.join(ROOT, 'src', 'agent-src', 'personas');
+const DOMAINS_DIR = path.join(ROOT, 'src', 'domains');
+
+function _isDir(p: string): boolean {
+    try { return fs.statSync(p).isDirectory(); } catch { return false; }
+}
+function _isFile(p: string): boolean {
+    try { return fs.statSync(p).isFile(); } catch { return false; }
+}
+function _rel(abs: string): string {
+    return path.relative(ROOT, abs).split(path.sep).join('/');
+}
+
+function _frontmatter(abs: string): Record<string, unknown> {
+    const text = fs.readFileSync(abs, 'utf-8');
+    const m = /^---\n([\s\S]*?)\n---/.exec(text);
+    if (!m || m.index !== 0) return {};
+    try {
+        const fm = parseYaml(m[1] as string, { version: '1.1' });
+        return fm !== null && typeof fm === 'object' && !Array.isArray(fm) ? (fm as Record<string, unknown>) : {};
+    } catch {
+        return {};
+    }
+}
+
+function _str(v: unknown): string {
+    return typeof v === 'string' ? v.trim() : v == null ? '' : String(v);
+}
+function _list(v: unknown): string[] {
+    if (Array.isArray(v)) return v.map((x) => _str(x)).filter((s) => s.length > 0);
+    const s = _str(v);
+    return s ? [s] : [];
+}
+
+function _walkLeaf(dir: string, leaf: string, out: string[]): void {
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const ent of entries) {
+        const full = path.join(dir, ent.name);
+        if (ent.isDirectory() || (ent.isSymbolicLink() && _isDir(full))) _walkLeaf(full, leaf, out);
+        else if (ent.name === leaf) out.push(full);
+    }
+}
+
+export function buildEntries(): CatalogIndexEntry[] {
+    const out: CatalogIndexEntry[] = [];
+
+    // Skills
+    if (_isDir(SKILLS_DIR)) {
+        for (const slug of fs.readdirSync(SKILLS_DIR).sort()) {
+            const abs = path.join(SKILLS_DIR, slug, 'SKILL.md');
+            if (!_isFile(abs)) continue;
+            const fm = _frontmatter(abs);
+            out.push({
+                id: `skill:${slug}`,
+                cls: 'skill',
+                name: _str(fm['name']) || slug,
+                description: _str(fm['description']),
+                tags: [_str(fm['domain']), ..._list(fm['packs'])].filter((s) => s.length > 0),
+                path: _rel(abs),
+            });
+        }
+    }
+
+    // Personas (top-level *.md, skip _template/advisors and underscore-prefixed)
+    if (_isDir(PERSONAS_DIR)) {
+        for (const name of fs.readdirSync(PERSONAS_DIR).sort()) {
+            if (!name.endsWith('.md') || name.startsWith('_')) continue;
+            const abs = path.join(PERSONAS_DIR, name);
+            if (!_isFile(abs)) continue;
+            const fm = _frontmatter(abs);
+            const id = _str(fm['id']) || name.replace(/\.md$/, '');
+            out.push({
+                id: `persona:${id}`,
+                cls: 'persona',
+                name: _str(fm['role']) || id,
+                description: _str(fm['description']),
+                tags: [_str(fm['tier']), _str(fm['mode'])].filter((s) => s.length > 0),
+                path: _rel(abs),
+            });
+        }
+    }
+
+    // Domain commands
+    const cmds: string[] = [];
+    _walkLeaf(DOMAINS_DIR, 'command.md', cmds);
+    for (const abs of cmds.sort()) {
+        const fm = _frontmatter(abs);
+        // logical id = <pack>/<subpath> under src/domains, without /command.md
+        const relFromDomains = path.relative(DOMAINS_DIR, path.dirname(abs)).split(path.sep).join('/');
+        const name = _str(fm['name']) || relFromDomains.split('/').pop() || relFromDomains;
+        out.push({
+            id: `command:${relFromDomains}`,
+            cls: 'command',
+            name,
+            description: _str(fm['description']) || _str(fm['intent']),
+            tags: [_str(fm['pack']), _str(fm['tier']), _str(fm['visibility'])].filter((s) => s.length > 0),
+            path: _rel(abs),
+        });
+    }
+
+    // Deterministic order: (cls, id).
+    out.sort((a, b) => (a.cls < b.cls ? -1 : a.cls > b.cls ? 1 : a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return out;
+}
+
+export function serialize(entries: CatalogIndexEntry[]): string {
+    return JSON.stringify({ schema_version: 1, count: entries.length, entries }, null, 2) + '\n';
+}
+
+export function main(argv?: string[]): number {
+    const args = argv ?? process.argv.slice(2);
+    const check = args.includes('--check');
+    const quiet = args.includes('--quiet');
+    const entries = buildEntries();
+    const rendered = serialize(entries);
+
+    if (check) {
+        const current = _isFile(OUT) ? fs.readFileSync(OUT, 'utf-8') : '';
+        if (current !== rendered) {
+            process.stderr.write(`build_catalog_index: DRIFT — ${_rel(OUT)} is stale; run build_catalog_index to regenerate.\n`);
+            return 1;
+        }
+        if (!quiet) process.stdout.write(`build_catalog_index: OK — ${entries.length} entries, index up to date.\n`);
+        return 0;
+    }
+
+    fs.mkdirSync(path.dirname(OUT), { recursive: true });
+    fs.writeFileSync(OUT, rendered, 'utf-8');
+    if (!quiet) process.stdout.write(`build_catalog_index: wrote ${entries.length} entries → ${_rel(OUT)}\n`);
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) return false;
+    if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) return true;
+    try {
+        return fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(path.resolve(process.argv[1]));
+    } catch { return false; }
+}
+
+if (_isCliEntry()) {
+    process.exit(main());
+}

package/src/scripts/council_cli.ts

@@ -98,7 +98,9 @@ import {
 } from './ai_council/orchestrator.js';
 import {
     type PriceTable,
+    downgrade_coupling,
     estimate_cost,
+    estimate_input_tokens,
     load_prices,
     prices_file_for,
 } from './ai_council/pricing.js';
@@ -1605,7 +1607,8 @@ function _necessity_gate(opts: {
 function _resolve_model_downgrade(ai_cfg: Dict, lens: string): [boolean, boolean] {
     const md_block = (ai_cfg['model_downgrade'] as Dict) || {};
     let enabled = md_block['enabled'] === undefined ? true : Boolean(_pyBool(md_block['enabled']));
-    let auto_apply = md_block['auto_apply'] === undefined ? false : Boolean(_pyBool(md_block['auto_apply']));
+    // A3: auto-downgrade is the default; `auto_apply: false` is the opt-out.
+    let auto_apply = md_block['auto_apply'] === undefined ? true : Boolean(_pyBool(md_block['auto_apply']));
     const overrides = ((ai_cfg['lens_overrides'] as Dict) || {})['model_downgrade'] || {};
     const lens_override = _isDict(overrides) ? (overrides as Dict)[lens] : null;
     if (_isDict(lens_override)) {
@@ -1622,6 +1625,10 @@ function _size_fit_gate(opts: {
     members: ExternalAIClient[];
     ai_cfg: Dict;
     stdout?: ((s: string) => void) | null;
+    /** Planned rounds for the run; expected same-model cache reads = rounds − 1. */
+    rounds?: number;
+    /** Price table for the A1↔A3 cache-coupling gate; null → coupling skipped. */
+    price_table?: PriceTable | null;
 }): Array<[string, SizeFitVerdict, boolean]> {
     const out = opts.stdout ?? _stdout;
     const [enabled, auto_apply] = _resolve_model_downgrade(opts.ai_cfg, opts.lens);
@@ -1629,8 +1636,25 @@ function _size_fit_gate(opts: {
     if (!enabled) {
         return decisions;
     }
+    const md_block = (opts.ai_cfg['model_downgrade'] as Dict) || {};
+    const tier_override = (md_block['model_tier_override'] as Dict) || {};
+    const cache_enabled = opts.ai_cfg['prompt_cache'] !== false;
+    const expected_reads = Math.max(0, (opts.rounds ?? 1) - 1);
     const members_cfg = (opts.ai_cfg['members'] as Dict) || {};
     for (const member of opts.members) {
+        // Per-run escape hatch: a member pinned in model_tier_override gets
+        // exactly that model — classifier and coupling both skipped.
+        const pinned = tier_override[member.name];
+        if (typeof pinned === 'string' && pinned.length > 0) {
+            if (pinned !== member.model) {
+                out(
+                    `council:size-fit · ${member.name} · model_tier_override ` +
+                        `\`${member.model}\` → \`${pinned}\` (operator pin)\n`,
+                );
+                member.model = pinned;
+            }
+            continue;
+        }
         const member_cfg = (members_cfg[member.name] as Dict) || {};
         const ladder = (member_cfg['model_ladder'] as string[]) || [];
         if (ladder.length === 0) {
@@ -1639,6 +1663,35 @@ function _size_fit_gate(opts: {
         const verdict = classify_size_fit(opts.prompt, member.model, ladder, opts.lens);
         let applied = false;
         if (!verdict.fit && verdict.suggested_model) {
+            // A1↔A3 coupling: a downgraded member misses the model-scoped
+            // prompt cache — downgrade only when the model saving beats the
+            // forfeited cache reads. No price table → conservative skip is
+            // wrong for the cost goal, so coupling only gates when computable.
+            if (opts.price_table) {
+                const prefix_tokens = estimate_input_tokens(opts.prompt);
+                const coupling = downgrade_coupling(
+                    member.name,
+                    member.model,
+                    verdict.suggested_model,
+                    prefix_tokens,
+                    4096,
+                    {
+                        enabled: cache_enabled,
+                        cacheable_prefix_tokens: prefix_tokens,
+                        expected_reads,
+                    },
+                    opts.price_table,
+                );
+                if (!coupling.net_positive) {
+                    out(
+                        `council:size-fit · ${member.name} · downgrade skipped — ` +
+                            `lost cache savings $${coupling.lost_cache_savings_usd.toFixed(4)} ` +
+                            `≥ model savings $${coupling.downgrade_savings_usd.toFixed(4)}\n`,
+                    );
+                    decisions.push([member.name, verdict, false]);
+                    continue;
+                }
+            }
             if (auto_apply) {
                 out(
                     `council:size-fit · ${member.name} · auto-downgrade ` +
@@ -1845,6 +1898,8 @@ function cmd_run(
         lens: question.mode,
         members,
         ai_cfg,
+        rounds: _getattr(args, 'rounds', 1) as number,
+        price_table: table,
     });
     const project = detect_project_context(REPO_ROOT);
     const billable = members.filter((m) => _getattr(m, 'billable', true));

package/src/scripts/generate_index.ts

@@ -232,7 +232,10 @@ export function _collect_skills(): Entry[] {
                 kind: 'skill',
                 name,
                 description: _truncate(fm['description'] ?? ''),
-                extra: '',
+                // Provenance: `official` unless the skill declares
+                // `provenance: community` (external contribution — credited in
+                // CREDITS.md; the catalog column makes the credit visible).
+                extra: fm['provenance'] ?? 'official',
                 path: _relativeToPosix(skillMd, ROOT),
             });
         }
@@ -372,7 +375,7 @@ export function _render_index(
         '',
         `## Skills (${skills.length})`,
         '',
-        _render_table(skills, ['kind', 'name', 'extra', 'description'], '../'),
+        _render_table(skills, ['kind', 'name', 'source', 'description'], '../'),
         '',
         `## Rules (${rules.length})`,
         '',
@@ -428,7 +431,7 @@ export function _render_catalog(
         '> (`./scripts-run src/scripts/domain_soundness_status`). A disclaimer',
         '> floor bounds liability, not correctness — see [the proof page](proof.md).',
         '',
-        _render_table(skills, ['kind', 'name', 'extra', 'description'], '../', _to_shipped_path),
+        _render_table(skills, ['kind', 'name', 'source', 'description'], '../', _to_shipped_path),
         '',
         `## Rules (${publicRules.length})`,
         '',