@event4u/agent-config 16.3.0 → 16.4.0

package/src/scripts/_lib/settings_removed_keys.ts

@@ -0,0 +1,173 @@
+/**
+ * The registry of DELETED settings keys, and the once-per-run notice a leftover
+ * value gets. Extracted from `agent_settings.ts`, which sits at the 1500-line
+ * source ceiling — every retirement batch adds entries here, and here they cost
+ * no ratchet. `agent_settings.ts` re-exports `REMOVED_KEYS` so existing
+ * importers (the loader, `lint_settings_classes`) are unchanged.
+ */
+
+type SettingsDict = Record<string, unknown>;
+
+/**
+ * Settings keys this package has DELETED. A leftover value from an older
+ * install is ignored — never applied by any reader — and surfaced with ONE
+ * deprecation line per key per process run (stderr; the exit code never
+ * changes).
+ *
+ * The map carries a per-key REASON rather than one shared sentence, because
+ * the list now spans more than one deletion doctrine and a single blanket
+ * phrase would mis-attribute every future entry. A reader who hits the line
+ * should learn why the key went, not just that it did.
+ *
+ * `subagents.*` — the always-on-orchestration doctrine
+ * (road-to-always-on-orchestration Phase 1): the layer has no per-layer
+ * on/off setting any more. `ai_team.enabled` joined in Step 1.3 — the
+ * `/team` family's availability is a codex-CLI/auth FACT
+ * (`src/scripts/ai_team/availability.ts`), not a flag; the `ai_team` config
+ * loader (`src/scripts/ai_team/config.ts`) separately accepts a leftover
+ * `enabled` key without failing closed, so this warning is the only surfaced
+ * signal of that deletion.
+ *
+ * `hooks.turn_end_gate.*` — the turn-end gate is always armed (2026-08-12).
+ * A default-off safety gate cannot soak, so the switch protecting the soak
+ * made the soak impossible; whether the gate fires is now decided by each
+ * detector's own trigger conditions. See `turn_end_gate_hook.ts` § "Always
+ * armed".
+ *
+ * The five `derivable` leaves below (2026-08-12, road-to-zero-settings Phase
+ * 2.1) are a different case from every entry above them, and the difference is
+ * the whole safety argument: no code path ever *consulted* them. Each appeared
+ * in the template, the schema and the reference page, and several in the setup
+ * wizard, while the decision they looked like they governed was taken
+ * elsewhere. A key nothing reads cannot change a default by leaving — so this
+ * is the one deletion batch that needs no replacement mechanism, only the
+ * per-key statement of what already decides.
+ *
+ * A sixth unread key, `screenshots.data_bearing_gate`, was found in the same
+ * pass and deliberately NOT deleted — it is `consent`, and the open question is
+ * whether the repair is to build its missing reader or to delete a promise a
+ * Hard Floor can never honour. See `settings-classes.md` § The six unread keys.
+ *
+ * `worktrees.mode` (2026-08-13, ADR-229) is a third doctrine again: not
+ * always-on, not unread. It WAS read, and the reader honoured all three values —
+ * the deletion says the decision was never the agent's to make. `ask` bought a
+ * round trip per spawn, `on` let the agent start parallel work unprompted, and
+ * `off` described the wanted behavior, so `off` became the hardcoded rule and
+ * the switch went. What decides instead is the user's own sentence in the chat.
+ *
+ * The 2026-10-09 batch (road-to-settings-classes-derivable-surface-stagnation
+ * Phase 2) is a fourth doctrine: `derivable` keys whose shipped default is the
+ * only behavior the package supports. Each WAS read — by code or by rule and
+ * command prose — and every reader was rewritten to state the old default as
+ * fixed behavior in the same change, so retiring the key changes no effective
+ * default; what a consumer who had set a non-default value loses is named by
+ * the reason.
+ *
+ * Every reason string must name what decides INSTEAD, never just "removed".
+ * Exported so `lint_settings_classes` can check the deletion side of the
+ * surface: a reason that names no replacement, or an entry whose key is live in
+ * the template again, is a contradiction the loader itself cannot notice.
+ */
+export const REMOVED_KEYS: ReadonlyMap<string, string> = new Map([
+    ['subagents.enabled', 'always-on orchestration'],
+    ['subagents.auto', 'always-on orchestration'],
+    ['subagents.host_capabilities', 'always-on orchestration'],
+    ['subagents.budget_routing', 'always-on orchestration'],
+    ['ai_team.enabled', 'always-on orchestration'],
+    ['hooks.turn_end_gate.enabled', 'the turn-end gate is always armed'],
+    ['hooks.turn_end_gate.promissory', 'the turn-end gate is always armed'],
+    ['hooks.turn_end_gate.language', 'the turn-end gate is always armed'],
+    ['hooks.turn_end_gate.verification', 'the turn-end gate is always armed'],
+    ['telegraph.speak_scope', 'the rule body states its own scope; compile_time_toggles decides whether the rule ships'],
+    ['chat_history.max_size_kb', 'the rotate command takes --max-kb from argv; session-count pruning bounds the file'],
+    ['chat_history.on_overflow', 'the overflow mode comes from the rotate command --mode argv'],
+    ['quality.wait_for_remote_ci', 'whether to poll follows from the push plus a detectable remote pipeline'],
+    ['legal_review_prep.consented_at', 'the provenance sidecar settings:set writes and consentVerdict reads'],
+    ['worktrees.mode', 'the user asking for a worktree in the chat; creation is instruction-only and hardcoded'],
+    // 2026-10-09 — output and tone
+    ['personal.minimal_output', 'direct-answers Iron Law 3 mandates terse replies; there is no verbose mode'],
+    ['personal.play_by_play', 'direct-answers: no narration unless the user asks for it in the turn'],
+    ['personal.pr_comment_bot_icon', 'no-decorative-emojis-in-git-surfaces forbids the 🤖 prefix'],
+    ['verbosity.intent_announcements', 'direct-answers: act and emit the result, no "Let me…" openers'],
+    ['verbosity.preview_artifacts', 'generated content is used directly; preview-on-error and the Iron-Law gates decide when a preview shows'],
+    ['verbosity.routine_confirmations', 'the no-cheap-questions Pre-Send Self-Check; Iron-Law gates always ask'],
+    ['verbosity.post_action_reports', 'direct-answers Iron Law 3: a one-line confirmation and one end-summary'],
+    ['telegraph.speak', 'the telegraph-speak predicate in compile_time_toggles.ts; the bench verdict is package-level (ADR telegraph/0002)'],
+    ['tokens.rich_skills', "the skill's own token_budget_class: rich plus the lint_token_budget_discipline ceiling"],
+    // 2026-10-09 — reasoning protocol switches
+    ['reasoning.auto_gate', 'the RDP gate task signal plus the host self-assessment in rdp-gate.md'],
+    ['reasoning.components.orchestrator', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    ['reasoning.components.notes_first', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    ['reasoning.components.grounding', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    ['reasoning.components.intent', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    ['reasoning.components.complexity_first', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    ['reasoning.components.verifier_default', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    ['reasoning.components.prediction_tracking', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    ['reasoning.components.decision_ledger', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    ['reasoning.components.uncertainty_budget', 'the RDP gate task and host signals decide per component; reasoning.enabled stays the hard off'],
+    // 2026-10-09 — roadmap cadence
+    ['roadmap.skip_pre_run_gate', 'the command name names the scope; only an ambiguous roadmap or an unresolvable conflict shows the gate'],
+    ['roadmap.dashboard_regen_cadence', 'a fixed cadence: every 5th closed step, every phase boundary, reply end and any file-shape touch'],
+    // 2026-10-09 — command suggestion and PR creation
+    ['commands.auto_detect', "an orchestrator's own auto_detect front-matter and the --no-auto-detect flag"],
+    ['commands.suggestion.enabled', 'the suggester match-score floor and cooldown; /command-suggestion-off silences one conversation'],
+    ['commands.suggestion.confidence_floor', "the suggester's fixed 0.6 floor; a command's own suggestion frontmatter can tighten it"],
+    ['commands.suggestion.cooldown_seconds', "the suggester's fixed 600-second cooldown; a command's own suggestion frontmatter can lengthen it"],
+    ['commands.suggestion.max_options', 'the fixed cap of 4 suggestions plus the always-present as-is option'],
+    ['commands.create_pr.api_examples', "/create-pr's grounding rule: an example only from a real source, otherwise a one-line pointer"],
+    ['commands.create_pr.ui_paths', "/create-pr's light frontend heuristic, which fails open"],
+    ['commands.create_pr.api_paths', "/create-pr's light API-endpoint heuristic, which fails open"],
+    // 2026-10-09 — memory and knowledge sharing
+    ['memory.cadence', 'a fixed cadence: the memory line renders whenever a memory type was asked; memory.visibility: off still silences it'],
+    ['memory.review_threshold', "/memory load's fixed preview threshold of 10 unreviewed intake signals"],
+    ['knowledge.global_sharing.redaction.enabled', 'the write-time redaction scan, which always runs before a card goes global'],
+    ['knowledge.global_sharing.redaction.halt_on_trigger', 'the redaction gate, which always halts on a confidential-pattern hit'],
+    ['knowledge.global_sharing.auto_promote_threshold', 'the fixed two-repo sighting count that triggers a promotion suggestion'],
+    ['knowledge.global_sharing.freshness.hypothesis_after_days', "the card's age over last_verified against the fixed 90-day lead-only window"],
+    ['knowledge.global_sharing.freshness.stale_after_days', "the card's age over last_verified against the fixed 180-day skip window"],
+    // 2026-10-09 — hooks and engine
+    ['hooks.concern_budget.max_per_event', "the concern-budget gate's own constant of 8 per (platform, event) cell"],
+    ['hooks.concern_budget.hard_fail', "the concern-budget gate's --strict argv; without it the gate warns"],
+    ['decision_engine.surface_traces', 'nothing: the per-phase decision trace stays off, the old default'],
+    ['decision_engine.on_block_fallback', 'the fail-safe: an on_block ask that times out always stops'],
+    ['explain.enable_last', 'the presence of a work-state trace; explain last always renders it'],
+    // 2026-10-09 — remaining
+    ['project.pr_template', '/create-pr, which reads .github/pull_request_template.md'],
+    ['pipelines.skill_improvement', 'the skill-improvement-trigger rule; the capture is a proposal the user confirms'],
+    ['consistency.cross_source', 'the cross-source-consistency rule, always on; batching and the no-cheap-questions floor bound the noise'],
+    ['subagents.downshift', 'the model_tier each sub-task declares; downshift is always on'],
+    ['ai_team.suppress_setup_hint', 'nothing: the one-line team-mode setup hint is always shown'],
+]);
+
+/** Keys already warned about in THIS process — the "once per run" dedupe. */
+const _warnedRemovedKeys = new Set<string>();
+
+/** Read one dotted path out of a merged settings tree; `undefined` when absent. */
+function _readDotted(root: SettingsDict, dotted: string): unknown {
+    let node: unknown = root;
+    for (const part of dotted.split('.')) {
+        if (typeof node !== 'object' || node === null || Array.isArray(node)) {
+            return undefined;
+        }
+        node = (node as SettingsDict)[part];
+    }
+    return node;
+}
+
+/**
+ * Warn once per process, on stderr, for every {@link REMOVED_KEYS} entry still
+ * present in a resolved settings tree. Never throws, never changes what the
+ * caller does with `merged` — a pure notification side effect.
+ */
+export function warnRemovedKeys(merged: SettingsDict): void {
+    for (const [key, reason] of REMOVED_KEYS) {
+        if (_warnedRemovedKeys.has(key)) {
+            continue;
+        }
+        if (_readDotted(merged, key) === undefined) {
+            continue;
+        }
+        _warnedRemovedKeys.add(key);
+        process.stderr.write(`${key} was removed (${reason}); ignored.\n`);
+    }
+}

package/src/scripts/_lib/test_red_state.ts

@@ -10,6 +10,11 @@
  * This module is that emission, so the registry entry moves in the same change
  * rather than being left describing a gap that closed.
  *
+ * DATED 2026-10-06. The emission exists and is tested, but nothing calls it:
+ * this writer has no production caller, so the registry row was corrected back
+ * to `degraded` the same day. The caller belongs to the stub that owns it —
+ * whoever lands it sets the row back to `available`.
+ *
  * WHAT IT IS NOT. It is not a test runner, and it does not decide whether a
  * failure is a legitimate RED. The failure CLASSES belong to the TDD skill
  * (`src/skills/test-driven-development/SKILL.md`, Test-Red row) and this module

package/src/scripts/_lib/thin_rules.ts

@@ -284,15 +284,95 @@ function _title(s: string): string {
  * Exported so the WRITER and every DETECTOR share one definition. A gate that
  * re-spelled this string would drift from the writer silently, and the failure
  * would be invisible in exactly the direction that matters: a stub the gate
- * fails to recognise reads as a complete rule body.
+ * fails to recognise reads as a complete rule body. Two gates had done exactly
+ * that until step 2.1 of `road-to-a-thinned-layer-measured-in-one-unit`; both
+ * import this now.
+ *
+ * SHORTENED 2026-10-06 from 47 characters to 27 (step 2.2). It is paid once per
+ * stub and there were 89 stubs on the measured layer, so the sentence cost
+ * 4,183 characters of a 97,496-character standing total; at 27 it costs 2,403,
+ * a saving of 1,780 = 20 x 89.
+ *
+ * WHAT THE SHORTENING WAS NOT ALLOWED TO DO: drop the instruction. This is the
+ * only standing text in the whole layer that says what a stub is FOR — "load
+ * the body" occurs in no kernel rule and in neither root instruction file — so
+ * a bare token like `> thin` would have saved more and left nothing that could
+ * be followed. The decision record (D2, K6) rejected that explicitly: nothing
+ * in this repository can check whether an instruction nobody states is still
+ * obeyed.
+ *
+ * WHY IT MUST STAY LONG ENOUGH TO BE UNIQUE: {@link is_thin_entry} is a
+ * substring test over the whole file, so a marker short or generic enough to
+ * occur inside ordinary rule prose would make that rule read as a stub — and
+ * nine rule files carry blockquote lines. `thin_marker_unique_in_corpus.test.ts`
+ * runs the constant against every rule body in `src/rules/` and against every
+ * entry `build_thin` emits, in both directions, which is the check that bounds
+ * any further shortening.
  */
-export const THIN_ENTRY_MARKER = '> Routed rule — load the body on trigger-match.';
+export const THIN_ENTRY_MARKER = '> Load the body on a match.';
 
 /** Is this projected entry a pointer stub rather than a rule body? */
 export function is_thin_entry(text: string): boolean {
     return text.includes(THIN_ENTRY_MARKER);
 }
 
+/**
+ * What introduces a stub's body pointer. One writer, one reader.
+ *
+ * A BARE PATH SINCE 2026-10-06 (step 2.3 of
+ * `road-to-a-thinned-layer-measured-in-one-unit`). The pointer used to be a
+ * markdown link, ``Body: [`<id>`](<prefix><id>.md)``, whose link TEXT repeated
+ * the rule id the target already ends in. That cost `6 + len(id)` per stub over
+ * the bare form — 2,359 characters across the 89 stubs of the measured layer,
+ * 534 of it pure syntax and the rest the id written a second time.
+ *
+ * Nothing followed the link as a link. Under `delivery` the hook loads the body
+ * and never reads the pointer at all; under `thin` an agent reads the path. A
+ * markdown link renders in neither case, so the syntax bought rendering nobody
+ * was doing.
+ */
+export const THIN_BODY_POINTER_PREFIX = 'Body: ';
+
+/**
+ * The pointer, as the WRITER emits it — exported so a detector cannot re-spell
+ * it, which is the same drift {@link THIN_ENTRY_MARKER} documents one screen up
+ * and which two gates had already committed there.
+ *
+ * WHAT IT CAPTURES is the whole tail of the line from `Body: ` to its end, and
+ * that is the intended semantic rather than an accident of greediness: the
+ * writer emits the pointer LAST on its line, so the tail IS the path. A review
+ * round proposed a lazy `(.+?\.md)` to stop at the first `.md`; measured, it
+ * changes nothing, because `\s*$` forces the match to reach end of line either
+ * way and a lazy quantifier simply backtracks forward to the same place. The
+ * greedy form is kept and the property is pinned by a test, so the next reader
+ * meets the measurement instead of repeating the proposal.
+ *
+ * ANCHORED TO END OF LINE, NOT `\S+`. The pointer is the last thing on its
+ * line, and a package root may contain spaces; `\S+` would silently stop at the
+ * first one and report a well-formed pointer as missing.
+ *
+ * COMPOSED FROM {@link THIN_BODY_POINTER_PREFIX} rather than re-spelling it.
+ * The constant exists so a reader cannot hold its own copy, and a pattern six
+ * lines below it holding a literal `Body: ` would have broken that invariant in
+ * the file that states it.
+ */
+export const THIN_BODY_POINTER_RE = (() => {
+    const lit = THIN_BODY_POINTER_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // THE LAST PREFIX ON THE LINE, NOT THE FIRST. `thin_entry` puts the rule's
+    // own `description` on the SAME line ahead of the pointer, so a description
+    // containing the literal `Body: ` used to start the match inside the
+    // description and capture it as part of the path — `has_body_pointer` stayed
+    // true while the extraction was wrong, which is a wrong assertion rather
+    // than a visible failure. Forbidding a second prefix inside the capture
+    // makes the first viable start the last occurrence, which is the pointer.
+    return new RegExp(`${lit}((?:(?!${lit}).)+\\.md)\\s*$`, 'm');
+})();
+
+/** Does this entry carry a body pointer the writer would recognise? */
+export function has_body_pointer(text: string): boolean {
+    return THIN_BODY_POINTER_RE.test(text);
+}
+
 /**
  * Where a stub tells a reader the body actually is.
  *
@@ -356,7 +436,7 @@ export function thin_entry(
     return (
         `## ${title}\n` +
         `${THIN_ENTRY_MARKER}${fires} ${desc} ` +
-        `Body: [\`${rule_id}\`](${bodyLinkPrefix}${rule_id}.md)\n`
+        `${THIN_BODY_POINTER_PREFIX}${bodyLinkPrefix}${rule_id}.md\n`
     );
 }
 

package/src/scripts/_lib/touched_file_quality.ts

@@ -89,6 +89,22 @@ export interface QualityRun {
     readonly output_head: readonly string[];
     readonly skipped: SkipReason | null;
     readonly files: readonly string[];
+    /**
+     * Matched files the tool reported it declined to look at. A run where EVERY
+     * matched file is listed here and the tool exited 0 is a verdict about
+     * nothing, so `exit_code` is `null` for it — the readings page § 5(a) found
+     * that row recorded `0, skipped: null`, the exact shape of a pass. A field
+     * rather than a fifth `SkipReason` (D2): a partly-ignored run keeps its real
+     * exit code, and a skip reason cannot sit beside a verdict.
+     */
+    readonly ignored_files: readonly string[];
+    /**
+     * Type-check commands the resolver emitted that produced no verdict on this
+     * turn — unscoped, absent or mutating. Identical on every record of the turn,
+     * so ANY single row says that a `0` beside it was a lint verdict and not a
+     * type verdict (§ 5(b): `tsc --noEmit` is unscoped on every stop).
+     */
+    readonly typecheck_not_run: readonly string[];
     readonly at: string;
 }
 
@@ -112,8 +128,21 @@ interface ToolSpec {
      * the resolver's by exactly the flag that makes it read-only.
      */
     readonly check_form: boolean;
+    /**
+     * A line the tool prints, exit 0, for an input its own config ignores. Per
+     * row because the wording is the tool's (D1); a row without one reads no
+     * output as an ignore, which keeps the pre-existing behaviour rather than
+     * guessing at a message the tool might print.
+     */
+    readonly ignored_signal?: RegExp;
 }
 
+/**
+ * ESLint 9's stylish report for an ignored input: the absolute path on its own
+ * line, then this indented warning. Pinned verbatim by the ignored-file fixture.
+ */
+const ESLINT_IGNORED = /^\s+\d+:\d+\s+warning\s+File ignored because of a matching ignore pattern\b/;
+
 const JS_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts'] as const;
 
 /**
@@ -124,7 +153,15 @@ const JS_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.c
  * and absence is what produces `skipped: unscoped`.
  */
 const SCOPED_FORMS: ReadonlyMap<string, ToolSpec> = new Map<string, ToolSpec>([
-    ['npx eslint .', { argv: ['npx', 'eslint'], extensions: JS_EXTENSIONS, check_form: false }],
+    [
+        'npx eslint .',
+        {
+            argv: ['npx', 'eslint'],
+            extensions: JS_EXTENSIONS,
+            check_form: false,
+            ignored_signal: ESLINT_IGNORED,
+        },
+    ],
     [
         'vendor/bin/phpstan analyse',
         { argv: ['vendor/bin/phpstan', 'analyse'], extensions: ['.php'], check_form: false },
@@ -153,6 +190,38 @@ const SCOPED_FORMS: ReadonlyMap<string, ToolSpec> = new Map<string, ToolSpec>([
  */
 const MUTATING_WITHOUT_CHECK_FORM: ReadonlySet<string> = new Set<string>([]);
 
+/**
+ * Resolver commands with no file-scoped form, unscoped ON PURPOSE (rule 3).
+ *
+ * Named so the parity test can tell a deliberate absence from `SCOPED_FORMS`
+ * apart from a resolver command nobody classified: every command the resolver
+ * emits is a scoped key, a mutating key, or on this list — or a test is red.
+ */
+export const UNSCOPED_ON_PURPOSE: readonly string[] = [
+    'npx tsc --noEmit',
+    'go vet ./...',
+    'cargo clippy',
+];
+
+/** The keys of `SCOPED_FORMS`, for the parity test. */
+export const SCOPED_FORM_COMMANDS: readonly string[] = [...SCOPED_FORMS.keys()];
+
+/** The keys of `MUTATING_WITHOUT_CHECK_FORM`, for the parity test. */
+export const MUTATING_COMMANDS: readonly string[] = [...MUTATING_WITHOUT_CHECK_FORM];
+
+/**
+ * Resolver commands whose verdict is a type verdict. `go vet` and `cargo clippy`
+ * both compile the package, so a type error stops them; ESLint, ruff and pint do
+ * not type-check, which is the whole of § 5(b).
+ */
+export const TYPE_CHECK_COMMANDS: ReadonlySet<string> = new Set<string>([
+    'npx tsc --noEmit',
+    'vendor/bin/phpstan analyse',
+    'mypy .',
+    'go vet ./...',
+    'cargo clippy',
+]);
+
 function extensionOf(file: string): string {
     const base = path.basename(file);
     const dot = base.lastIndexOf('.');
@@ -253,7 +322,7 @@ function defaultSpawn(
 export function runTouchedFileQuality(opts: RunOptions): QualityRun[] {
     const timeout_ms = opts.timeout_ms ?? DEFAULT_TIMEOUT_MS;
     const spawn = opts.spawn ?? defaultSpawn;
-    const out: QualityRun[] = [];
+    const out: Omit<QualityRun, 'typecheck_not_run'>[] = [];
     for (const plan of planQualityRuns(opts.commands, opts.files)) {
         if (plan.argv === null) {
             out.push({
@@ -263,6 +332,7 @@ export function runTouchedFileQuality(opts: RunOptions): QualityRun[] {
                 output_head: [],
                 skipped: plan.skipped,
                 files: [],
+                ignored_files: [],
                 at: now(),
             });
             continue;
@@ -282,17 +352,69 @@ export function runTouchedFileQuality(opts: RunOptions): QualityRun[] {
         // tool is a wrapper script whose own dependency is missing. Same meaning
         // as ENOENT for this module's purposes, and the same bucket in 2.1.
         const absent = enoent || status === 127;
+        const signal = SCOPED_FORMS.get(plan.source_command)?.ignored_signal;
+        const ignored =
+            absent || signal === undefined ? [] : ignoredFiles(output, signal, plan.files);
+        // Every matched file ignored AND exit 0: the tool looked at nothing, so
+        // there is no verdict to record. A non-zero exit over the same set stays,
+        // because a red the tool raised (a config crash, say) is real.
+        const nothingLooked = ignored.length === plan.files.length && status === 0;
         out.push({
             command: renderCommand(plan.argv),
             source_command: plan.source_command,
-            exit_code: absent ? null : status,
+            exit_code: absent || nothingLooked ? null : status,
             output_head: absent ? [] : headLines(output, OUTPUT_HEAD_LINES),
             skipped: absent ? 'absent' : null,
             files: plan.files,
+            ignored_files: ignored,
             at: now(),
         });
     }
-    return out;
+    // `no_files` is excluded: no file the type checker reads was touched, so
+    // there was nothing on this turn for it to have caught.
+    const typecheck_not_run = out
+        .filter(
+            (r) =>
+                TYPE_CHECK_COMMANDS.has(r.source_command) &&
+                r.exit_code === null &&
+                r.skipped !== 'no_files' &&
+                r.skipped !== null,
+        )
+        .map((r) => r.source_command);
+    return out.map((r) => ({ ...r, typecheck_not_run: [...typecheck_not_run] }));
+}
+
+/**
+ * The matched files the tool's output reports as ignored.
+ *
+ * The stylish report names the file on an unindented line and the warning on
+ * the indented lines under it, so a signal line is attributed to the last path
+ * line above it. A signal that cannot be attributed is attributed to the one
+ * matched file only when there is exactly one; otherwise it is dropped, so an
+ * unreadable report keeps today's behaviour instead of inventing an ignore.
+ */
+export function ignoredFiles(
+    output: string,
+    signal: RegExp,
+    files: readonly string[],
+): string[] {
+    const reported: string[] = [];
+    let unattributed = false;
+    let current: string | null = null;
+    for (const line of output.split(/\r\n|\r|\n/)) {
+        if (signal.test(line)) {
+            if (current === null) unattributed = true;
+            else reported.push(normalizePath(current));
+            continue;
+        }
+        if (line !== '' && !/^\s/.test(line)) current = line.trim();
+    }
+    const hit = files.filter((f) => {
+        const want = normalizePath(f);
+        return reported.some((r) => r === want || r.endsWith(`/${want}`));
+    });
+    if (hit.length === 0 && unattributed && files.length === 1) return [...files];
+    return hit;
 }
 
 /**
@@ -306,11 +428,25 @@ export function runTouchedFileQuality(opts: RunOptions): QualityRun[] {
 export const WARN_LINE_MAX_BYTES = 200;
 
 export function advisoryLine(runs: readonly QualityRun[]): string | null {
+    const ignored = [...new Set(runs.flatMap((r) => r.ignored_files))];
+    const ignoredPart =
+        ignored.length === 0
+            ? ''
+            : `ignored ${ignored[0] ?? ''}${ignored.length > 1 ? ` (+${String(ignored.length - 1)} more)` : ''}`;
     const failed = runs.find((r) => r.skipped === null && r.exit_code !== null && r.exit_code !== 0);
-    if (failed === undefined) return null;
+    if (failed === undefined) {
+        // Nothing failed. Silence is right when every file was looked at; when a
+        // file was ignored, silence would read as clean, so say what was not seen.
+        if (ignored.length === 0) return null;
+        return truncateToBytes(
+            `touched-file quality: no verdict, ${ignoredPart}`,
+            WARN_LINE_MAX_BYTES,
+        );
+    }
     const file = failed.files[0] ?? '(no file)';
     const more = failed.files.length > 1 ? ` (+${String(failed.files.length - 1)} more)` : '';
-    const line = `touched-file quality: ${failed.source_command} exited ${String(failed.exit_code)} on ${file}${more}`;
+    const tail = ignoredPart === '' ? '' : `; ${ignoredPart}`;
+    const line = `touched-file quality: ${failed.source_command} exited ${String(failed.exit_code)} on ${file}${more}${tail}`;
     return truncateToBytes(line, WARN_LINE_MAX_BYTES);
 }
 

package/src/scripts/_lib/worker_budget.ts

@@ -9,7 +9,7 @@
  * error on the wrong rung, not diligence.
  *
  * Composes with — replaces nothing:
- * - the N=3 validation-loop budget (`autonomous-execution`),
+ * - the `execution.fix_loop_max` validation-loop budget (`autonomous-execution`),
  * - the ADR-109 / `subagent-response-contract` body + 4-status envelope
  *   (`subagent-steering`): the partial result rides as the body of a
  *   `BLOCKED` envelope with `budget_hit: true` as the escalation flag.

package/src/scripts/adr/regenerate_index.ts

@@ -187,11 +187,26 @@ export function scan(d: string): [Row[], Row[], string[]] {
  * A scope with no refs renders as `—`: a qualifier on nothing is not a
  * supersession, and printing the prose alone would read as one.
  */
+/**
+ * Escape a `|` for safety inside a Markdown table cell. The free-text scope
+ * fields this feeds (`supersedes_scope` / `superseded_scope`) routinely quote
+ * a table row from the record they describe — and a quoted row has its own
+ * `|` column separators, verbatim, in the frontmatter prose. Unescaped, that
+ * splits the generated row into extra columns rather than rendering the quote
+ * (found live in ADR-230's and ADR-279's own rows, both quoting the same
+ * table cell from ADR-230 § Decision). `refs` itself is never escaped: it is
+ * always an `ADR-NNN` token list this generator produces or validates, never
+ * free text.
+ */
+function escapeCell(text: string): string {
+    return text.replaceAll('|', '\\|');
+}
+
 export function supersessionCell(refs: string | undefined, scope: string | undefined): string {
     const r = (refs ?? '').trim();
     if (r === '' || r === '—') return '—';
     const s = (scope ?? '').trim();
-    return s === '' || s === '—' ? r : `${r} (${s})`;
+    return s === '' || s === '—' ? r : `${r} (${escapeCell(s)})`;
 }
 
 /** Mirror `row(r)`. */

package/src/scripts/ai_council/config.ts

@@ -291,8 +291,8 @@ export interface CostBudgetConfig {
     readonly max_output_tokens: number;
     readonly max_calls: number;
     readonly max_total_usd: number;
-    /** Rolling 24h cap. 0 disables it — and disabling it also disables the spend
-     * ledger, since the orchestrator only appends an entry while a cap is live. */
+    /** Rolling 24h cap. 0 disables it. The spend ledger is written either way
+     * (ADR-279); this value decides only whether the total is compared. */
     readonly daily_limit_usd: number;
 }
 
@@ -1020,7 +1020,7 @@ function _build_debate(d: Dict): DebateConfig {
     if (!_isDict(d)) {
         throw new CouncilConfigError('`debate` must be a mapping.');
     }
-    const cap = _pyFloat(_get(d, 'max_cost_usd', 5.0));
+    const cap = _pyFloat(_get(d, 'max_cost_usd', 0.0)); // 0 = no refusal cap (ADR-279)
     if (cap < 0) {
         throw new CouncilConfigError(
             `debate.max_cost_usd must be >= 0 (got ${_pyRepr(_f(cap))}; ` +
@@ -1671,10 +1671,10 @@ function _build_cost_budget(d: Dict): CostBudgetConfig {
         throw new CouncilConfigError('`cost_budget` must be a mapping.');
     }
     const cb: CostBudgetConfig = {
-        max_input_tokens: _pyInt(_get(d, 'max_input_tokens', 500_000)),
-        max_output_tokens: _pyInt(_get(d, 'max_output_tokens', 200_000)),
-        max_calls: _pyInt(_get(d, 'max_calls', 50)),
-        max_total_usd: _pyFloat(_get(d, 'max_total_usd', 20.0)),
+        max_input_tokens: _pyInt(_get(d, 'max_input_tokens', 0)), // 0 = unbounded (ADR-279)
+        max_output_tokens: _pyInt(_get(d, 'max_output_tokens', 0)), // 0 = unbounded (ADR-279)
+        max_calls: _pyInt(_get(d, 'max_calls', 50)), // fan-out, not money — kept
+        max_total_usd: _pyFloat(_get(d, 'max_total_usd', 0.0)), // 0 = unbounded (ADR-279)
         daily_limit_usd: _pyFloat(_get(d, 'daily_limit_usd', 0.0)),
     };
     const fields: Array<[keyof CostBudgetConfig, boolean]> = [