@event4u/agent-config 16.3.0 → 16.5.0

package/src/scripts/report_parked_blockers.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env tsx
+/**
+ * Census of open blockers in parked roadmaps — measures, never gates.
+ *
+ * `lint_roadmap_blockers` and `/roadmap:resolve-blockers` both exclude
+ * the parked directory (`later/`) by a recorded decision ("history rather than
+ * debt"). This report reads exactly that directory so the decision can be
+ * revisited on a number rather than a guess: every `### blocker:` entry whose
+ * `Status:` is not `resolved`, with its file, its raw `Owner:` value and
+ * whether that owner is the owner (maintainer / user / owner — the same set
+ * `lint_roadmap_blockers` treats as a user decision) or a condition an agent
+ * can reach. Separately it lists every blockquote that names an owner
+ * question or owner decision, because such a question is invisible to any
+ * blocker reader even when its directory is in scope.
+ *
+ * The raw `Owner:` value is printed beside its classification: the field is
+ * free text, and a misread must be visible to whoever reads the report.
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/report_parked_blockers
+ *   ./scripts-run src/scripts/report_parked_blockers --format json
+ *   ./scripts-run src/scripts/report_parked_blockers --dir <path>
+ *
+ * Exit codes: 0 report emitted · 2 usage error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { REPO_ROOT, _stripFencedCode } from './lint_roadmap_blockers.js';
+
+type OwnerWait = 'owner' | 'agent';
+
+interface ParkedBlocker {
+    file: string;
+    id: string;
+    status: string;
+    owner: string;
+    wait: OwnerWait;
+}
+
+interface OwnerQuestion {
+    file: string;
+    line: number;
+    text: string;
+    blocker_entries_in_file: number;
+}
+
+interface Census {
+    dir: string;
+    files_scanned: number;
+    files_with_open_blockers: number;
+    blockers: ParkedBlocker[];
+    owner_questions: OwnerQuestion[];
+}
+
+const BLOCKERS_SECTION_RE = /^##[ \t]+Blockers[ \t]*$/im;
+const NEXT_H2_RE = /^##[ \t]+\S/m;
+const BLOCKER_HEADING_RE = /^###[ \t]+blocker:[ \t]*(.+?)[ \t]*$/gim;
+const STATUS_RE = /^-[ \t]*\*\*Status:\*\*[ \t]*(.*)$/im;
+const OWNER_RE = /^-[ \t]*\*\*Owner:\*\*[ \t]*(.*)$/im;
+const OWNER_WAIT_RE = /^(maintainer|user|owner)\b/i;
+const OWNER_QUESTION_RE = /owner[ \t]+(question|decision)/i;
+
+function _classifyOwner(raw: string): OwnerWait {
+    return OWNER_WAIT_RE.test(raw.trim()) ? 'owner' : 'agent';
+}
+
+/** Every blocker entry in one file's `## Blockers` section, open or not. */
+function _blockerEntries(text: string): Array<{ id: string; status: string; owner: string }> {
+    const stripped = _stripFencedCode(text);
+    const sectionMatch = BLOCKERS_SECTION_RE.exec(stripped);
+    if (!sectionMatch) {
+        return [];
+    }
+    const start = sectionMatch.index + sectionMatch[0].length;
+    const rest = stripped.slice(start);
+    const h2 = NEXT_H2_RE.exec(rest);
+    const section = h2 ? rest.slice(0, h2.index) : rest;
+
+    const heads: Array<{ start: number; end: number; id: string }> = [];
+    BLOCKER_HEADING_RE.lastIndex = 0;
+    let hm: RegExpExecArray | null;
+    while ((hm = BLOCKER_HEADING_RE.exec(section)) !== null) {
+        heads.push({ start: hm.index, end: hm.index + hm[0].length, id: (hm[1] as string).trim() });
+        if (hm.index === BLOCKER_HEADING_RE.lastIndex) {
+            BLOCKER_HEADING_RE.lastIndex++;
+        }
+    }
+    return heads.map((cur, i) => {
+        const next = heads[i + 1];
+        const body = section.slice(cur.end, next ? next.start : section.length);
+        return {
+            id: cur.id,
+            status: (STATUS_RE.exec(body)?.[1] ?? '').trim(),
+            owner: (OWNER_RE.exec(body)?.[1] ?? '').trim(),
+        };
+    });
+}
+
+/** Blockquote lines that name an owner question or owner decision. */
+function _ownerQuestionLines(text: string): Array<{ line: number; text: string }> {
+    const out: Array<{ line: number; text: string }> = [];
+    let inFence = false;
+    text.split('\n').forEach((raw, i) => {
+        if (/^[ \t]*```/.test(raw)) {
+            inFence = !inFence;
+            return;
+        }
+        if (!inFence && /^[ \t]*>/.test(raw) && OWNER_QUESTION_RE.test(raw)) {
+            out.push({ line: i + 1, text: raw.trim() });
+        }
+    });
+    return out;
+}
+
+function collect(dir: string, root: string = REPO_ROOT): Census {
+    const files = fs.existsSync(dir)
+        ? fs
+              .readdirSync(dir, { withFileTypes: true })
+              .filter((e) => e.isFile() && e.name.endsWith('.md'))
+              .map((e) => path.join(dir, e.name))
+              .sort()
+        : [];
+    const blockers: ParkedBlocker[] = [];
+    const ownerQuestions: OwnerQuestion[] = [];
+    const filesWithOpen = new Set<string>();
+    for (const abs of files) {
+        const rel = path.relative(root, abs).split(path.sep).join('/');
+        const text = fs.readFileSync(abs, 'utf8');
+        const entries = _blockerEntries(text);
+        for (const e of entries) {
+            if (/^resolved\b/i.test(e.status)) {
+                continue;
+            }
+            filesWithOpen.add(rel);
+            blockers.push({ file: rel, id: e.id, status: e.status, owner: e.owner, wait: _classifyOwner(e.owner) });
+        }
+        for (const q of _ownerQuestionLines(text)) {
+            ownerQuestions.push({ file: rel, line: q.line, text: q.text, blocker_entries_in_file: entries.length });
+        }
+    }
+    return {
+        dir: path.relative(root, dir).split(path.sep).join('/'),
+        files_scanned: files.length,
+        files_with_open_blockers: filesWithOpen.size,
+        blockers,
+        owner_questions: ownerQuestions,
+    };
+}
+
+function format(c: Census): string {
+    const owner = c.blockers.filter((b) => b.wait === 'owner');
+    const agent = c.blockers.filter((b) => b.wait === 'agent');
+    const lines: string[] = [];
+    lines.push(`Parked blockers under ${c.dir}/`);
+    lines.push(
+        `files scanned: ${c.files_scanned} · files with an open blocker: ${c.files_with_open_blockers} · open blockers: ${c.blockers.length} (owner-wait ${owner.length}, agent-wait ${agent.length})`,
+    );
+    for (const [label, group] of [
+        ['owner-wait', owner],
+        ['agent-wait', agent],
+    ] as const) {
+        lines.push('');
+        lines.push(`## ${label} (${group.length})`);
+        for (const b of group) {
+            lines.push(`- ${b.file} · ${b.id} · Owner: ${b.owner || '(none)'} · Status: ${b.status || '(none)'}`);
+        }
+    }
+    lines.push('');
+    lines.push(`## owner questions in blockquotes (${c.owner_questions.length})`);
+    for (const q of c.owner_questions) {
+        lines.push(`- ${q.file}:${q.line} · blocker entries in file: ${q.blocker_entries_in_file} · ${q.text.slice(0, 120)}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+
+function fail(message: string): never {
+    process.stderr.write(`report_parked_blockers: ${message}\n`);
+    process.exit(2);
+}
+
+function main(argv: string[] = process.argv.slice(2)): number {
+    let fmt: 'text' | 'json' = 'text';
+    let dir = path.join(REPO_ROOT, 'agents', 'roadmaps', 'later');
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--format') {
+            const v = argv[i + 1];
+            if (v !== 'text' && v !== 'json') fail(`--format must be 'text' or 'json'`);
+            fmt = v;
+            i += 1;
+        } else if (arg === '--dir') {
+            const v = argv[i + 1];
+            if (v === undefined) fail('--dir requires a value');
+            dir = path.resolve(v);
+            i += 1;
+        } else {
+            fail(`unknown argument: ${arg}`);
+        }
+    }
+    const census = collect(dir);
+    process.stdout.write(fmt === 'json' ? `${JSON.stringify(census, null, 2)}\n` : format(census));
+    return 0;
+}
+
+if (process.argv[1] !== undefined) {
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv1 = fs.realpathSync(path.resolve(process.argv[1]));
+        if (here === argv1) {
+            process.exit(main());
+        }
+    } catch {
+        if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+            process.exit(main());
+        }
+    }
+}
+
+export { _classifyOwner, _blockerEntries, _ownerQuestionLines, collect, format, main };
+export type { Census, ParkedBlocker, OwnerQuestion };

package/src/scripts/report_required_checks_drift.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env tsx
+/**
+ * Required-check drift report — compares the live ruleset to the contract.
+ *
+ * `print_required_checks.ts` carries the list of status contexts the `main
+ * protection` ruleset requires, and it is contractually offline: it never calls
+ * `gh`. So nothing compared that list to the ruleset, and it drifted — it named
+ * one required context for a month after the ruleset gained a second. This
+ * report is the comparison: it reads the ruleset through `gh api`, extracts the
+ * required status contexts, and exits non-zero when they differ from
+ * `ENFORCED_CHECKS`.
+ *
+ * READ-ONLY. It writes nothing and changes nothing on the ruleset. It is run by
+ * hand or on a schedule and is NOT wired as a required check — a network read
+ * cannot sit on the path of every pull request, and the token it needs is a
+ * repository-read token, not something each PR should depend on.
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/report_required_checks_drift
+ *   ./scripts-run src/scripts/report_required_checks_drift --repo <owner/name>
+ *   ./scripts-run src/scripts/report_required_checks_drift --from-json <file>
+ *
+ * `--from-json` reads a ruleset object (the shape `gh api
+ * repos/{owner}/{repo}/rulesets/{id}` returns) from a file instead of the
+ * network, so the comparison itself is testable offline.
+ *
+ * Exit codes: 0 the lists agree · 1 they differ · 2 usage error, or the ruleset
+ * could not be read or carries no required-status-checks rule.
+ */
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { ENFORCED_CHECKS } from './print_required_checks.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+
+export const RULESET_NAME = 'main protection';
+const DEFAULT_REPO = 'event4u-app/agent-config';
+
+export interface Drift {
+    readonly missingFromContract: readonly string[];
+    readonly missingFromRuleset: readonly string[];
+}
+
+class ReadError extends Error {}
+
+/** The required status contexts of one ruleset object, sorted. */
+export function requiredContexts(ruleset: unknown): string[] {
+    const rules = (ruleset as { rules?: unknown }).rules;
+    if (!Array.isArray(rules)) {
+        throw new ReadError('the ruleset object carries no `rules` array');
+    }
+    const lists = rules
+        .filter(
+            (r): r is { parameters?: { required_status_checks?: unknown } } =>
+                typeof r === 'object' && r !== null && (r as { type?: unknown }).type === 'required_status_checks',
+        )
+        .map((r) => r.parameters?.required_status_checks)
+        .filter((c): c is unknown[] => Array.isArray(c));
+    if (lists.length === 0) {
+        throw new ReadError('the ruleset has no `required_status_checks` rule');
+    }
+    // Every such rule counts: a context required by any of them blocks the merge.
+    const contexts = new Set(
+        lists
+            .flat()
+            .map((c) => (c as { context?: unknown }).context)
+            .filter((c): c is string => typeof c === 'string'),
+    );
+    return [...contexts].sort();
+}
+
+/** Set difference in both directions; empty both ways means agreement. */
+export function compare(live: readonly string[], contract: readonly string[]): Drift {
+    const liveSet = new Set(live);
+    const contractSet = new Set(contract);
+    return {
+        missingFromContract: live.filter((c) => !contractSet.has(c)).sort(),
+        missingFromRuleset: contract.filter((c) => !liveSet.has(c)).sort(),
+    };
+}
+
+function ghJson(endpoint: string, paginate = false): unknown {
+    const args = paginate ? ['api', '--paginate', '--slurp', endpoint] : ['api', endpoint];
+    const r = spawnSync('gh', args, { encoding: 'utf-8', maxBuffer: 16 * 1024 * 1024 });
+    if (r.status !== 0) {
+        throw new ReadError(`gh api ${endpoint} failed: ${(r.stderr ?? '').trim() || `exit ${String(r.status)}`}`);
+    }
+    return JSON.parse(r.stdout) as unknown;
+}
+
+function readLiveRuleset(repo: string): unknown {
+    // --paginate --slurp: one array per page, so a ruleset past the first page
+    // of 30 is still found.
+    const pages = ghJson(`repos/${repo}/rulesets`, true);
+    if (!Array.isArray(pages) || !pages.every((p) => Array.isArray(p))) {
+        throw new ReadError('the rulesets listing is not an array of pages');
+    }
+    const list = (pages as unknown[][]).flat();
+    const hit = list.find((r) => (r as { name?: unknown }).name === RULESET_NAME) as { id?: unknown } | undefined;
+    if (hit === undefined || typeof hit.id !== 'number') {
+        throw new ReadError(`no ruleset named "${RULESET_NAME}" on ${repo}`);
+    }
+    return ghJson(`repos/${repo}/rulesets/${String(hit.id)}`);
+}
+
+interface Options {
+    repo: string;
+    fromJson: string | null;
+}
+
+function parseArgs(argv: readonly string[]): Options | string {
+    let repo = DEFAULT_REPO;
+    let fromJson: string | null = null;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i] as string;
+        if (a === '--repo' || a === '--from-json') {
+            const v = argv[i + 1];
+            if (v === undefined || v.startsWith('--')) {
+                return `${a} needs a value`;
+            }
+            if (a === '--repo') {
+                repo = v;
+            } else {
+                fromJson = v;
+            }
+            i++;
+        } else {
+            return `unknown argument: ${a}`;
+        }
+    }
+    return { repo, fromJson };
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    const opts = parseArgs(argv);
+    if (typeof opts === 'string') {
+        process.stderr.write(`❌  report_required_checks_drift: ${opts}\n`);
+        process.stderr.write('usage: report_required_checks_drift [--repo OWNER/NAME] [--from-json FILE]\n');
+        return 2;
+    }
+    let live: string[];
+    try {
+        const ruleset =
+            opts.fromJson === null
+                ? readLiveRuleset(opts.repo)
+                : (JSON.parse(fs.readFileSync(opts.fromJson, 'utf-8')) as unknown);
+        live = requiredContexts(ruleset);
+    } catch (e) {
+        process.stderr.write(`❌  report_required_checks_drift: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 2;
+    }
+    const drift = compare(live, ENFORCED_CHECKS);
+    const source = opts.fromJson === null ? `${opts.repo} ruleset "${RULESET_NAME}"` : opts.fromJson;
+    process.stdout.write(`required contexts read from ${source}: ${String(live.length)}\n`);
+    for (const c of live) {
+        process.stdout.write(`  - ${c}\n`);
+    }
+    if (drift.missingFromContract.length === 0 && drift.missingFromRuleset.length === 0) {
+        process.stdout.write(
+            '✅  agrees with ENFORCED_CHECKS in src/scripts/print_required_checks.ts\n',
+        );
+        return 0;
+    }
+    for (const c of drift.missingFromContract) {
+        process.stdout.write(`  ❌ required by the ruleset, absent from the contract: ${c}\n`);
+    }
+    for (const c of drift.missingFromRuleset) {
+        process.stdout.write(`  ❌ named by the contract, not required by the ruleset: ${c}\n`);
+    }
+    process.stdout.write(
+        '❌  drift — update ENFORCED_CHECKS and docs/contracts/branch-protection-policy.md ' +
+            'together, with the date the ruleset was read.\n',
+    );
+    return 1;
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    if (pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) {
+        return true;
+    }
+    try {
+        return fs.realpathSync(path.resolve(process.argv[1])) === fs.realpathSync(_HERE);
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exitCode = main();
+}

package/src/scripts/report_skill_ranker_confusion.ts

@@ -55,7 +55,7 @@ import {
     sliceForId,
     sliceSizes,
 } from './measure_skill_ranker_baseline.js';
-import { _globSkillMd, rank, type RankRow } from './skill_tools/score_skill_relevance.js';
+import { _globSkillMd, rank, rankDetailed, type RankRow } from './skill_tools/score_skill_relevance.js';
 
 /** How deep "outside the top ten" is. 1.3's own number, not a derived one. */
 export const DEEP_MISS_DEPTH = 10;
@@ -92,6 +92,38 @@ export interface RowReading {
     rankedFirst: string | null;
     topScore: number;
     rankOfExpected: number;
+    /** An expected skill shares the winner's integer score (hit or miss). */
+    expectedInTopScoreBlock: boolean;
+    /** An expected skill shares the winner's whole ordering key and loses on name. */
+    lostOnTie: boolean;
+}
+
+/**
+ * The two tie readings for one ranking.
+ *
+ * `inBlock` asks whether an expected skill scored the winner's INTEGER — the
+ * block the alphabet orders under `keyword-v1`. `lostOnTie` asks whether the
+ * row was a top-1 miss that nothing but the name decided: the expected skill
+ * shares the winner's integer score and, under `tieBreakUnrounded`, its
+ * unrounded score too. Without the flag the two keys coincide, so `lostOnTie`
+ * is the evidence page's "scored exactly the winner's score and lost on its
+ * initial" class; with it, `lostOnTie` is what the unrounded score left.
+ */
+export function tieReading(
+    rows: readonly RankRow[],
+    raw: ReadonlyMap<string, number>,
+    expected: readonly string[],
+    tieBreakUnrounded: boolean,
+): { inBlock: boolean; lostOnTie: boolean } {
+    const first = rows[0];
+    if (!first) return { inBlock: false, lostOnTie: false };
+    const block = rows.filter((r) => r[1] === first[1]);
+    const inBlock = block.some((r) => expected.includes(r[0]));
+    if (!inBlock || expected.includes(first[0])) return { inBlock, lostOnTie: false };
+    const lostOnTie = block.some(
+        (r) => expected.includes(r[0]) && (!tieBreakUnrounded || raw.get(r[0]) === raw.get(first[0])),
+    );
+    return { inBlock, lostOnTie };
 }
 
 export function readRows(
@@ -101,13 +133,16 @@ export function readRows(
 ): RowReading[] {
     const opts = rankOptionsFor(ranker);
     return prompts.map((p) => {
-        const rows = rank(p.prompt, skillsDir, opts);
+        const { rows, raw } = rankDetailed(p.prompt, skillsDir, opts);
+        const tie = tieReading(rows, raw, p.expected, Boolean(opts.tieBreakUnrounded));
         return {
             id: p.id,
             expected: p.expected,
             rankedFirst: rows[0]?.[0] ?? null,
             topScore: rows[0]?.[1] ?? 0,
             rankOfExpected: firstExpectedRank(rows, p.expected),
+            expectedInTopScoreBlock: tie.inBlock,
+            lostOnTie: tie.lostOnTie,
         };
     });
 }
@@ -262,6 +297,41 @@ export function falseActivation(
     };
 }
 
+export interface AbstentionReading {
+    empties: number;
+    /** Empties whose top score is 0 — the ranker already abstains. */
+    noSkill: number;
+    threshold: number | null;
+    /** Empties whose top score is below `threshold`. */
+    abstainedEmpties: number;
+    correctHits: number;
+    /** Correct top-1 hits whose top score is below `threshold`. */
+    hitsLost: number;
+}
+
+/**
+ * What abstaining below one threshold buys on the empties and costs on the hits.
+ *
+ * A `null` threshold reads the no-skill rate only: with no correct hit there is
+ * no recall to cost, and inventing a cutoff would put a number chosen here
+ * beside a measured one.
+ */
+export function abstentionReading(
+    labelled: readonly RowReading[],
+    emptyTopScores: readonly number[],
+    threshold: number | null,
+): AbstentionReading {
+    const hits = labelled.filter((r) => r.rankOfExpected === 1);
+    return {
+        empties: emptyTopScores.length,
+        noSkill: emptyTopScores.filter((s) => s === 0).length,
+        threshold,
+        abstainedEmpties: threshold === null ? 0 : emptyTopScores.filter((s) => s < threshold).length,
+        correctHits: hits.length,
+        hitsLost: threshold === null ? 0 : hits.filter((r) => r.topScore < threshold).length,
+    };
+}
+
 function interval(successes: number, trials: number): string {
     const raw = wilsonInterval(successes, trials);
     return `${round3(raw.lower).toFixed(3)} – ${round3(raw.upper).toFixed(3)}`;
@@ -286,6 +356,8 @@ export function renderReport(opts: {
     const misses = readings.filter((r) => r.rankOfExpected !== 1);
     const deep = misses.filter((r) => r.rankOfExpected === 0 || r.rankOfExpected > DEEP_MISS_DEPTH).length;
     const mrr = meanReciprocalRank(readings);
+    const tieLoss = readings.filter((r) => r.lostOnTie).length;
+    const inBlock = readings.filter((r) => r.expectedInTopScoreBlock).length;
 
     const empties = emptyRowIds(opts.repo, opts.slice);
     const rankOpts = rankOptionsFor(opts.ranker);
@@ -368,6 +440,18 @@ export function renderReport(opts: {
     L.push('of the existing signal can recover a skill the formula never surfaces. The two');
     L.push('take different fixes, which is why the split is reported rather than an average.');
     L.push('');
+    L.push('## Ties');
+    L.push('');
+    L.push('| metric | rows | share of rows read |');
+    L.push('|---|---:|---:|');
+    L.push(`| \`top1_loss_due_to_tie\` | ${String(tieLoss)} | ${pct(tieLoss, n)} |`);
+    L.push(`| \`expected_in_top_score_block\` | ${String(inBlock)} | ${pct(inBlock, n)} |`);
+    L.push('');
+    L.push('`top1_loss_due_to_tie` counts top-1 misses where an expected skill shares the');
+    L.push('winner\'s whole ordering key and loses on the name alone — the integer score, and');
+    L.push('under `tieBreakUnrounded` the unrounded score as well. `expected_in_top_score_block`');
+    L.push('counts rows, hit or miss, whose expected skill scores the winner\'s integer.');
+    L.push('');
     L.push('## False activation on the no-skill prompts');
     L.push('');
     L.push('| | |');
@@ -393,6 +477,23 @@ export function renderReport(opts: {
     L.push('populations at all. A share near one half means it does not: a prompt a seat');
     L.push('judged to have no skill answer is scored as confidently as a prompt it got right.');
     L.push('');
+    const ab = abstentionReading(readings, emptyScores, fa.correct_hits > 0 ? fa.median_correct_hit_score : null);
+    L.push('## Abstention, beside its cost');
+    L.push('');
+    L.push('| | |');
+    L.push('|---|---:|');
+    L.push(`| empties the ranker already returns nothing for (no-skill rate) | ${String(ab.noSkill)} of ${String(ab.empties)} (${pct(ab.noSkill, ab.empties)}) |`);
+    if (ab.threshold === null) {
+        L.push('| abstention threshold | n/a — no correct top-1 hit, so no threshold |');
+    } else {
+        L.push(`| abstention threshold (abstain below the median correct-hit score) | ${String(ab.threshold)} |`);
+        L.push(`| empties that threshold abstains on | ${String(ab.abstainedEmpties)} of ${String(ab.empties)} (${pct(ab.abstainedEmpties, ab.empties)}) |`);
+        L.push(`| correct top-1 hits it would suppress (recall cost) | ${String(ab.hitsLost)} of ${String(ab.correctHits)} (${pct(ab.hitsLost, ab.correctHits)}) |`);
+    }
+    L.push('');
+    L.push('One threshold, the same median the false-activation table compares against, so');
+    L.push('the gain on the empties and the recall it costs are read off one number.');
+    L.push('');
     L.push(`## Per-pack top-1, worst first`);
     L.push('');
     L.push('| pack | labelled rows | top-1 |');

package/src/scripts/report_standing_payload_by_host.ts

@@ -229,7 +229,7 @@ export const HOST_SURFACES: readonly HostSurface[] = [
     },
     {
         host: 'codex', surface: '.codex/agent-config.md', perRuleTree: false,
-        writer: 'src/scripts/install.ts:1382',
+        writer: 'src/scripts/install.ts:1377',
         // Scoped to `.codex` rather than the bare filename: nine other lines in
         // `install.ts` write an `agent-config.md` for some other host, so the
         // unscoped anchor would have accepted a drift onto any of them — the

package/src/scripts/routing_doctor.ts

@@ -355,10 +355,10 @@ export function collect_orchestration(
   platform_assumed: boolean,
 ): OrchestrationReport {
   const settings = load_agent_settings({ cwd: workspace_root });
-  const sub = (settings["subagents"] ?? {}) as Record<string, unknown>;
   const emergency = (settings["emergency"] ?? {}) as Record<string, unknown>;
   const halted = emergency["orchestration_halt"] === true;
-  const downshift = sub["downshift"] !== false;
+  // Fixed on: the `subagents.downshift` key was retired with this default.
+  const downshift = true;
   const { manifest: host_manifest, sources: host_manifest_sources } =
     describeHostCapabilities(platform);
   const activationInputs: ActivationInputs = {

package/src/scripts/schemas/agent-settings.schema.json

@@ -11,17 +11,6 @@
       "enum": ["minimal", "balanced", "full", "custom"],
       "description": "Rule-tier loading footprint. See docs/contracts/cost-profile-defaults.md and docs/contracts/rule-router.md. NOT a memory or model lever."
     },
-    "memory": {
-      "type": "object",
-      "additionalProperties": true,
-      "properties": {
-        "cadence": {
-          "type": "string",
-          "enum": ["auto", "always", "never"],
-          "description": "Cadence of the 🧠 memory-visibility line. See docs/contracts/memory-visibility-v1.md. Owns its own key since the 2026-06-01 untangle; previously collided with rule_loading_tier."
-        }
-      }
-    },
     "model": {
       "type": "object",
       "additionalProperties": true,
@@ -79,25 +68,34 @@
         }
       }
     },
-    "design": {
+    "git": {
       "type": "object",
       "additionalProperties": true,
       "properties": {
-        "fidelity_mode": {
+        "commit_format": {
           "type": "string",
-          "enum": ["strict", "structural", "hard-floor"],
-          "description": "How strictly the agent must follow a user-provided prototype / mockup / design system. Consumed by the design-fidelity rule. strict = build 1:1, every visible deviation needs confirmation; structural = structure locked, silent gaps fillable with a stated assumption; hard-floor = any deviation is never autonomous."
+          "enum": ["ticket-scope", "ticket-conventional"],
+          "description": "Where a ticket id goes in a commit subject. ticket-scope (default) = `feat(DEV-1234): …`; ticket-conventional = `DEV-1234 feat(area): …`, a ticket is never a scope."
+        },
+        "branch_pattern": {
+          "type": "string",
+          "description": "Shape of a branch name the agent creates. Placeholders {type}, {ticket}, {slug}. Default {type}/{slug}."
+        },
+        "update_strategy": {
+          "type": "string",
+          "enum": ["merge", "rebase"],
+          "description": "How a feature branch is brought up to date with its base. merge (default) = merge the base in; rebase = rebase onto origin/<base> and push with --force-with-lease, still asked for each time per git-history-discipline."
         }
       }
     },
-    "consistency": {
+    "design": {
       "type": "object",
       "additionalProperties": true,
       "properties": {
-        "cross_source": {
+        "fidelity_mode": {
           "type": "string",
-          "enum": ["on", "auto", "off"],
-          "description": "Consumed by the cross-source-consistency rule. When the agent works from multiple sources (ticket text, an attached image/mockup, the spec, the codebase) it checks them against each other and asks before proceeding on a discrepancy. on (default) = surface every real cross-source contradiction / silent-scope-expansion as one question; auto = surface only high-confidence contradictions, state low-confidence as an assumption; off = no cross-source checking."
+          "enum": ["strict", "structural", "hard-floor"],
+          "description": "How strictly the agent must follow a user-provided prototype / mockup / design system. Consumed by the design-fidelity rule. strict = build 1:1, every visible deviation needs confirmation; structural = structure locked, silent gaps fillable with a stated assumption; hard-floor = any deviation is never autonomous."
         }
       }
     },
@@ -158,18 +156,6 @@
         }
       }
     },
-    "tokens": {
-      "type": "object",
-      "additionalProperties": true,
-      "description": "Token-spend governance for skills marked token_budget_class: rich. See token-budget-discipline rule.",
-      "properties": {
-        "rich_skills": {
-          "type": "string",
-          "enum": ["on", "ask", "off"],
-          "description": "Controls whether skills marked token_budget_class: rich may load in full (exempt from telegraph-speak and thin-projector trimming). on = allowed (default); off = fall back to standard condensed behavior; ask = surface an estimated token delta (tokens, not dollars) and ask the user once per session before loading."
-        }
-      }
-    },
     "commands": {
       "type": "object",
       "additionalProperties": true,