@event4u/agent-config 16.2.0 → 16.4.0

package/src/scripts/command_suggester/settings.ts

@@ -1,16 +1,17 @@
 /**
- * Read `commands.suggestion.*` from `.agent-settings.yml` into `Settings`.
+ * Read `commands.suggestion.blocklist` from `.agent-settings.yml` into `Settings`.
  *
  * Ported from the retired Python `src/scripts/command_suggester/settings.py`
  * (ADR-200 py2ts). Mirror of the chat-history pattern:
  *
- *  - Default-permissive: a missing file or missing section returns
- *    `Settings()` defaults (suggestion layer enabled). Only an explicit
- *    `enabled: false` flips the master switch off.
+ *  - The blocklist is the only suggestion key a project still sets. The
+ *    master switch, floor, cooldown and option cap are engine constants in
+ *    `Settings`: their keys were retired with those defaults as the fixed
+ *    behavior, so a leftover value is warned about by the loader and never
+ *    read here.
  *  - Malformed YAML / unreadable file → defaults; the suggester degrades
  *    silently rather than crashing the turn.
- *  - Type-coerces with bounded fallbacks (floors clamped 0.0-1.0, ints
- *    non-negative, blocklist forced to an array of strings).
+ *  - The blocklist is forced to an array of non-empty strings.
  *
  * The Python module reads the YAML via the shared `agent_settings`
  * loader; this twin delegates to the ported `agent_settings.ts`.
@@ -61,54 +62,7 @@ function _read_section(path: string): Record<string, unknown> | null {
 }
 
 function _settings_from_raw(raw: Record<string, unknown>): Settings {
-    return new Settings({
-        enabled: _coerce_bool(raw.enabled, _DEFAULT.enabled),
-        confidence_floor: _coerce_floor(raw.confidence_floor, _DEFAULT.confidence_floor),
-        cooldown_seconds: _coerce_nonneg_int(raw.cooldown_seconds, _DEFAULT.cooldown_seconds),
-        max_options: _coerce_nonneg_int(raw.max_options, _DEFAULT.max_options),
-        blocklist: _coerce_str_tuple(raw.blocklist),
-    });
-}
-
-function _coerce_bool(value: unknown, defaultValue: boolean): boolean {
-    if (typeof value === 'boolean') {
-        return value;
-    }
-    if (value === null || value === undefined) {
-        return defaultValue;
-    }
-    if (typeof value === 'string') {
-        const s = value.trim().toLowerCase();
-        if (['true', 'yes', 'on', '1'].includes(s)) {
-            return true;
-        }
-        if (['false', 'no', 'off', '0'].includes(s)) {
-            return false;
-        }
-    }
-    return defaultValue;
-}
-
-function _coerce_floor(value: unknown, defaultValue: number): number {
-    const f = _pyFloat(value);
-    if (f === null) {
-        return defaultValue;
-    }
-    if (f < 0.0) {
-        return 0.0;
-    }
-    if (f > 1.0) {
-        return 1.0;
-    }
-    return f;
-}
-
-function _coerce_nonneg_int(value: unknown, defaultValue: number): number {
-    const i = _pyInt(value);
-    if (i === null) {
-        return defaultValue;
-    }
-    return i >= 0 ? i : defaultValue;
+    return new Settings({ blocklist: _coerce_str_tuple(raw.blocklist) });
 }
 
 function _coerce_str_tuple(value: unknown): string[] {
@@ -127,60 +81,6 @@ function _coerce_str_tuple(value: unknown): string[] {
     return out;
 }
 
-/**
- * Mirror of Python `float(value)`, returning null where Python raises
- * `TypeError` / `ValueError` (the coercion catches those and falls
- * back to the default).
- */
-function _pyFloat(value: unknown): number | null {
-    if (typeof value === 'boolean') {
-        return value ? 1.0 : 0.0;
-    }
-    if (typeof value === 'number') {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const s = value.trim();
-        if (s === '') {
-            return null;
-        }
-        const n = Number(s);
-        return Number.isNaN(n) ? null : n;
-    }
-    return null;
-}
-
-/**
- * Mirror of Python `int(value)` for the YAML scalar types, returning
- * null where Python raises.
- *
- *  - bool → 1 / 0.
- *  - int  → itself.
- *  - float → truncated toward zero (Python `int(3.9) == 3`).
- *  - string → `int(str, 10)` semantics: an optional sign + digits,
- *    surrounding whitespace allowed; a float-shaped string raises in
- *    Python, so it maps to null.
- */
-function _pyInt(value: unknown): number | null {
-    if (typeof value === 'boolean') {
-        return value ? 1 : 0;
-    }
-    if (typeof value === 'number') {
-        if (Number.isNaN(value) || !Number.isFinite(value)) {
-            return null;
-        }
-        return Math.trunc(value);
-    }
-    if (typeof value === 'string') {
-        const s = value.trim();
-        if (!/^[+-]?\d+$/.test(s)) {
-            return null;
-        }
-        return parseInt(s, 10);
-    }
-    return null;
-}
-
 function _isPlainObject(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/src/scripts/command_suggester/types.ts

@@ -98,11 +98,10 @@ export class Match {
 }
 
 /**
- * Runtime knobs read from `.agent-settings.yml`.
- *
- * Defaults match the "open decisions" leans in the roadmap.
- * Per-command frontmatter values override the global floor /
- * cooldown.
+ * Engine knobs. Only `blocklist` comes from `.agent-settings.yml`; the
+ * other four are fixed defaults (their settings keys were retired), still
+ * overridable by a caller that constructs `Settings` directly.
+ * Per-command frontmatter values override the floor / cooldown.
  *
  * Mirrors `@dataclass(frozen=True)`. The Python default `blocklist`
  * is an empty tuple; here it is a readonly string array, canonicalized

package/src/scripts/compile_hook_manifest.ts

@@ -79,12 +79,44 @@ const TABLES = {
 
 export type TableName = keyof typeof TABLES;
 
+/**
+ * The TWO labels a compiled table carries, and why one was not enough.
+ *
+ * `fingerprint` binds the file to its YAML SOURCE — it answers "is this
+ * compiled from the YAML as it stands". `body_fingerprint` binds the file to
+ * ITSELF: it is the fingerprint of the exact body bytes this writer emitted,
+ * and it answers "is the body a reader is about to serve the body that was
+ * compiled".
+ *
+ * road-to-blocking-severities 2.3. The source label alone left a real hole,
+ * and it is the one the roadmap measured: edit a cell of the compiled `table`
+ * and leave `fingerprint` alone, and it still equals the YAML's fingerprint,
+ * so the reader serves the edited body — and since both readers prefer the
+ * compiled form, the edited cell is what every host is told while the reviewed
+ * YAML beside it says something else.
+ *
+ * WHAT THIS DOES NOT CLAIM. Someone who edits the body can recompute this
+ * label as easily as the writer does; it is an integrity check against a
+ * PARTIAL edit — a hand edit, a bad merge, a truncated write — not a signature.
+ * That is the same honesty the source label already owed: neither resists an
+ * author, and resisting an author is what the tool-call deny (2.2) and the
+ * ratification record (2.1) are for. Three cheap mechanisms over one expensive
+ * one, each named for what it actually covers.
+ *
+ * The body text is `JSON.stringify` of the parsed document, which is exactly
+ * what lands in the file, so a reader recovers it by re-stringifying what it
+ * parsed. A test pins that round trip rather than assuming it.
+ */
 export function compile(yamlText: string, table: TableName = 'manifest'): string {
     const spec = TABLES[table];
     const doc = (spec.yamlVersion === undefined
         ? parseYaml(yamlText)
         : parseYaml(yamlText, { version: spec.yamlVersion })) as unknown;
-    return JSON.stringify({ fingerprint: tableFingerprint(yamlText), [spec.key]: doc });
+    return JSON.stringify({
+        fingerprint: tableFingerprint(yamlText),
+        body_fingerprint: tableFingerprint(JSON.stringify(doc)),
+        [spec.key]: doc,
+    });
 }
 
 export function main(argv: readonly string[] = process.argv.slice(2)): number {

package/src/scripts/condense.ts

@@ -42,6 +42,7 @@ import {
     strip_source_prefix,
 } from './_lib/agent_src.js';
 import { rewriteProjectedBodyLinks } from './_lib/guidelines_lane.js';
+import { render_windsurfrules, strip_frontmatter } from './_lib/windsurf_render.js';
 // Import-safety note: `project_thin_rules` guards its CLI entry
 // (`_isCliEntry()` before `process.exit(main())`), so importing it here is
 // side-effect-free. condense.ts is bundled into the installer, where a bare
@@ -49,7 +50,7 @@ import { rewriteProjectedBodyLinks } from './_lib/guidelines_lane.js';
 // bundled-CLI-entry-guard landmine. Verified before wiring, not assumed.
 import { build_thin } from './project_thin_rules.js';
 import { build_claude_hook_matrix } from './_lib/claude_settings_hooks.js';
-import { describeDroppedHosts, normalizeLeanProjectionMode, resolveLeanProjectionHosts, thinsHost,
+import { describeDroppedHosts, resolveLeanProjection, thinsHost,
     writesThinFiles, type LeanProjectionHosts, type LeanProjectionMode } from './_lib/lean_projection_mode.js';
 import { is_claude_builtin_name } from './_lib/claude_builtin_names.js';
 import { project_settings_path, load_agent_settings } from './_lib/agent_settings.js';
@@ -461,16 +462,14 @@ function _read_projection_scope_dedup(): boolean {
 
 
 function _lean_projection_settings(): { mode: LeanProjectionMode; hosts: LeanProjectionHosts } {
-    const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
-    const lean = data['lean_projection'];
-    const obj =
-        typeof lean === 'object' && lean !== null && !Array.isArray(lean)
-            ? (lean as Record<string, unknown>)
-            : {};
-    return {
-        mode: normalizeLeanProjectionMode(obj['mode'] ?? ''),
-        hosts: resolveLeanProjectionHosts(obj['hosts']),
-    };
+    // Step 1.2 of `road-to-a-rule-carrier-that-works-outside-the-repo`: this is
+    // now the shared resolver rather than one of three private readers. The
+    // INPUT is unchanged — `MODULE_STATE.SETTINGS_FILE` is still the file, so
+    // the projector's answer is the answer it always gave — and only the code
+    // that interprets it is shared. That is risk 2 of the roadmap's register
+    // ("making the hook agree with the projector could also move the
+    // projector") discharged by construction instead of by a test alone.
+    return resolveLeanProjection({ settingsPath: MODULE_STATE.SETTINGS_FILE });
 }
 
 // --- hashing -----------------------------------------------------------------
@@ -778,15 +777,9 @@ function _filter_tool_dirs(mapping: Record<string, string>): Record<string, stri
     return out;
 }
 
-export function strip_frontmatter(content: string): string {
-    if (content.startsWith('---')) {
-        const end = content.indexOf('---', 3);
-        if (end !== -1) {
-            content = _lstripNewlines(content.slice(end + 3));
-        }
-    }
-    return content;
-}
+// Moved to `_lib/windsurf_render.ts` beside its one remaining caller here and
+// the census that renders through it; re-exported so every importer's path holds.
+export { strip_frontmatter };
 
 // ── Path rewriter (P1 of road-to-path-fixes.md) ───────────────────────────
 // Kept byte-identical to check_condensation.ts::_rewritePaths (the two MUST
@@ -1229,14 +1222,8 @@ export function generate_windsurfrules(): number {
     // on `.windsurf/rules`. Without this line removing the per-run filter regressed
     // it 13 → 113: the per-run filter had been covering it by accident.
     const rules = partition_rules_for_dir('.windsurf/rules', _scoped_rule_basenames());
-    const parts = ['# Auto-generated from dist/agent-src/rules/ — do not edit directly\n'];
-    for (const rule of rules) {
-        const p = path.join(MODULE_STATE.RULES_SOURCE, rule);
-        const content = strip_frontmatter(_readText(p));
-        parts.push(`---\n\n${_strip(content)}\n`);
-    }
     const output = path.join(MODULE_STATE.PROJECT_ROOT, '.windsurfrules');
-    _writeText(output, parts.join('\n') + '\n');
+    _writeText(output, render_windsurfrules(MODULE_STATE.RULES_SOURCE, rules));
     info(`  ✅  Generated .windsurfrules (${rules.length} rules)`);
     return rules.length;
 }

package/src/scripts/consumer_matrix.ts

@@ -515,6 +515,107 @@ function legProjections(ctx: Ctx): string {
     return 'cursor + windsurf + claude projection trees present in global scope';
 }
 
+// ── git-convention leg ─────────────────────────────────────────────
+//
+// A consumer project has neither `scripts-run` nor `node_modules`, so the only
+// code an installed command can reach is the `agent-config` binary. `/pr:merge`
+// reads the update strategy through `git:convention show`; this leg runs that
+// verb from the packed install in a repository that commits a
+// `.git-convention.yml` and pushes it to an `origin`, so the strategy resolves
+// at a real target commit.
+
+const GIT_CONVENTION_CARRIER = 'git:\n  commit_format: ticket-conventional\n  update_strategy: rebase\n';
+
+/** The verdict on `git:convention show --json`; throws with the reason on any miss. */
+export function checkGitConventionShow(status: number, stdout: string, stderr = ''): string {
+    if (status !== 0) throw new Error(`git:convention show exit ${status}: ${(stdout + stderr).slice(-400)}`);
+    let parsed: { keys?: Record<string, { value?: unknown; state?: unknown; source?: unknown }> };
+    try {
+        parsed = JSON.parse(stdout) as typeof parsed;
+    } catch {
+        throw new Error(`git:convention show --json printed output that is not JSON: ${stdout.slice(0, 200)}`);
+    }
+    const expected: Record<string, string> = { commit_format: 'ticket-conventional', update_strategy: 'rebase' };
+    for (const [key, value] of Object.entries(expected)) {
+        const r = parsed.keys?.[key];
+        const fromCarrier = typeof r?.source === 'string' && r.source.includes('.git-convention.yml');
+        if (r?.value !== value || r.state !== 'valid' || !fromCarrier) {
+            throw new Error(`git.${key} did not resolve from the committed carrier: ${JSON.stringify(r ?? null)}`);
+        }
+    }
+    return 'commit_format=ticket-conventional, update_strategy=rebase, both from the committed .git-convention.yml';
+}
+
+/**
+ * The verdict on `git:convention subject` from the packed install: a valid
+ * subject resolves (exit 0), and a ticket inside a compound scope is rejected
+ * (exit 1) under the committed `ticket-conventional`.
+ */
+export function checkGitConventionSubject(
+    valid: { status: number; stdout: string; stderr?: string },
+    compound: { status: number; stdout: string; stderr?: string },
+): string {
+    if (valid.status !== 0) {
+        throw new Error(`git:convention subject rejected a valid subject, exit ${valid.status}: ${(valid.stdout + (valid.stderr ?? '')).slice(-400)}`);
+    }
+    if (compound.status !== 1 || !compound.stdout.includes('inside the scope')) {
+        throw new Error(`git:convention subject did not reject a ticket inside a compound scope, exit ${compound.status}: ${compound.stdout.slice(-400)}`);
+    }
+    return 'a valid subject resolves; a ticket inside a compound scope is rejected';
+}
+
+/**
+ * The verdict on `git:convention sync` from the packed install: the update
+ * `/pr:merge` § 2 runs. A current branch exits 0; a behind one is refused with
+ * exit 3 under the committed `rebase`, never merged.
+ */
+export function checkGitConventionSync(
+    current: { status: number; stdout: string; stderr?: string },
+    behind: { status: number; stdout: string; stderr?: string },
+): string {
+    if (current.status !== 0) {
+        throw new Error(`git:convention sync did not pass a current branch, exit ${current.status}: ${(current.stdout + (current.stderr ?? '')).slice(-400)}`);
+    }
+    if (behind.status !== 3 || !behind.stdout.includes('git.update_strategy is `rebase`')) {
+        throw new Error(`git:convention sync did not refuse a behind branch under rebase, exit ${behind.status}: ${behind.stdout.slice(-400)}`);
+    }
+    return 'sync passes a current branch and refuses a behind one with exit 3';
+}
+
+function legGitConvention(ctx: Ctx): string {
+    const env = binEnv(ctx);
+    const remote = path.join(ctx.tmpRoot, 'git-convention-origin.git');
+    const repo = path.join(ctx.tmpRoot, 'git-convention-project');
+    const git = (cwd: string, ...args: string[]): void => {
+        const r = run('git', ['-c', 'user.name=matrix', '-c', 'user.email=matrix@example.com', '-c', 'commit.gpgsign=false', ...args], {
+            cwd,
+            env,
+        });
+        if (r.status !== 0) throw new Error(`git ${args[0] ?? ''} failed: ${r.stderr.slice(-300)}`);
+    };
+    git(ctx.tmpRoot, 'init', '-q', '--bare', '-b', 'main', remote);
+    git(ctx.tmpRoot, 'init', '-q', '-b', 'main', repo);
+    fs.writeFileSync(path.join(repo, '.git-convention.yml'), GIT_CONVENTION_CARRIER);
+    git(repo, 'add', '.git-convention.yml');
+    git(repo, 'commit', '-q', '-m', 'declare the git convention');
+    git(repo, 'remote', 'add', 'origin', remote);
+    git(repo, 'push', '-q', '-u', 'origin', 'main');
+    const r = run(ctx.bin, ['git:convention', 'show', '--json', '--base', 'origin/main'], { cwd: repo, env });
+    const shown = checkGitConventionShow(r.status, r.stdout, r.stderr);
+    const subject = (line: string) => run(ctx.bin, ['git:convention', 'subject'], { cwd: repo, env, input: `${line}\n` });
+    const subjects = checkGitConventionSubject(subject('DEV-1 feat(api): add x'), subject('DEV-1 feat(api,DEV-1): add x'));
+    const sync = () => run(ctx.bin, ['git:convention', 'sync', '--base', 'origin/main'], { cwd: repo, env });
+    git(repo, 'switch', '-q', '-c', 'feature');
+    const current = sync();
+    git(repo, 'switch', '-q', 'main');
+    fs.writeFileSync(path.join(repo, 'advance.txt'), 'advance\n');
+    git(repo, 'add', 'advance.txt');
+    git(repo, 'commit', '-q', '-m', 'advance main');
+    git(repo, 'push', '-q', 'origin', 'main');
+    git(repo, 'switch', '-q', 'feature');
+    return `${shown}; ${subjects}; ${checkGitConventionSync(current, sync())}`;
+}
+
 function legUninstall(ctx: Ctx): string {
     const r = run(ctx.bin, ['uninstall', '--global', '--tools=claude-code,cursor,windsurf', '--force'], {
         cwd: ctx.projectDir,
@@ -570,6 +671,7 @@ const LEGS: Array<{ name: string; fn: (ctx: Ctx) => string | Promise<string> }>
     { name: 'hooks', fn: legHooks },
     { name: 'hook-lifecycle', fn: legHookLifecycle },
     { name: 'projections', fn: legProjections },
+    { name: 'git-convention', fn: legGitConvention },
     { name: 'uninstall', fn: legUninstall },
     { name: 'upgrade', fn: legUpgrade },
 ];

package/src/scripts/context_hygiene_hook.ts

@@ -7,21 +7,25 @@
  * module exactly (snake_case kept deliberately — fidelity over TS idiom).
  *
  * Maintains a deterministic state file the rule body cites for the
- * freshness threshold, the 3-failure stop, and tool-loop detection. The
- * agent's job shrinks from "remember three counters" to "read this file
- * before responding".
+ * freshness threshold and the 3-failure stop. The agent's job shrinks from
+ * "remember counters" to "read this file before responding".
  *
  * Output: `agents/state/context-hygiene.json`
  *   {
  *     "tool_calls": <int>,                 // running PostToolUse count
- *     "consecutive_same_tool": <int>,      // includes the latest call
- *     "last_tool": "<name>",
  *     "tool_history": [..., last 5 names],
- *     "loop_detected": <bool>,             // ≥ 3 same tool in a row
  *     "freshness_threshold": <int|null>,   // 20/40/60 milestone hit
  *     "checked_at": "<iso8601>"
  *   }
  *
+ * No same-tool-repeat ("loop") field: a same-tool-name counter fires on
+ * ordinary, non-looping work (an enumerated sweep over distinct targets
+ * calls the same tool repeatedly by design — the rule's own text says
+ * "'similar parameters' is the load-bearing word"), reaches no model (its
+ * only emission was a verbose stderr line), and had two readers, one of
+ * which read a path nothing wrote. Removed rather than repaired —
+ * road-to-signals-that-mean-what-they-say D1.
+ *
  * Exit code is always 0.
  *
  * CLI:
@@ -33,8 +37,9 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 // Re-use the shared atomic-write helper so concerns honour the single
-// `agents/runtime/state/.dispatcher.lock` discipline (hook-architecture-v1.md
-// § Concurrency, Phase 7.4).
+// `agents/state/.dispatcher.lock` discipline (hook-architecture-v1.md,
+// Concurrency, Phase 7.4) — the lock sits beside THIS hook's own target, not
+// the fixed `agents/runtime/state/` path the discipline cites generally.
 import { atomic_write_json } from "./hooks/state_io.js";
 import { readHookStdin } from "./hooks/hook_stdin.js";
 
@@ -45,7 +50,6 @@ import { readHookStdin } from "./hooks/hook_stdin.js";
 export const STATE_DIR = path.join("agents", "state");
 export const STATE_FILE = path.join(STATE_DIR, "context-hygiene.json");
 
-export const LOOP_THRESHOLD = 3; // 3+ consecutive same-tool calls
 export const HISTORY_DEPTH = 5;
 export const FRESHNESS_MILESTONES = [20, 40, 60] as const;
 
@@ -56,10 +60,7 @@ type StateDict = Record<string, unknown>;
 function _empty_state(): StateDict {
   return {
     tool_calls: 0,
-    consecutive_same_tool: 0,
-    last_tool: null,
     tool_history: [],
-    loop_detected: false,
     freshness_threshold: null,
   };
 }
@@ -134,14 +135,6 @@ function _update(state: StateDict, tool: string | null): StateDict {
   const curr_count = prev_count + 1;
   state["tool_calls"] = curr_count;
 
-  const last = state["last_tool"];
-  if (last === tool) {
-    state["consecutive_same_tool"] = _asInt(state["consecutive_same_tool"]) + 1;
-  } else {
-    state["consecutive_same_tool"] = 1;
-  }
-  state["last_tool"] = tool;
-
   let hist = state["tool_history"];
   if (!Array.isArray(hist)) {
     hist = [];
@@ -149,8 +142,6 @@ function _update(state: StateDict, tool: string | null): StateDict {
   (hist as unknown[]).push(tool);
   state["tool_history"] = (hist as unknown[]).slice(-HISTORY_DEPTH);
 
-  state["loop_detected"] = _asInt(state["consecutive_same_tool"]) >= LOOP_THRESHOLD;
-
   const ms = _milestone_hit(prev_count, curr_count);
   if (ms !== null) {
     state["freshness_threshold"] = ms;
@@ -211,7 +202,6 @@ export function run(
   if (verbose) {
     process.stderr.write(
       `context-hygiene-hook: tool_calls=${pyRepr(state["tool_calls"])} ` +
-        `loop=${pyRepr(state["loop_detected"])} ` +
         `threshold=${pyRepr(state["freshness_threshold"])}\n`,
     );
   }

package/src/scripts/cost/preflight.mjs

@@ -11,12 +11,23 @@
 // turn: `task cost:preflight` or `node scripts/cost/preflight.mjs`.
 
 import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 
 const QUIET = process.env.PREFLIGHT_QUIET === '1';
 
+// budget.mjs is this file's SIBLING, so resolve it from here rather than from
+// the working directory. A cwd-relative 'scripts/cost/budget.mjs' resolved to
+// nothing in this tree (the scripts live under src/scripts/), spawnSync
+// returned empty stdout, and empty stdout is read below as "no budget
+// configured" — so the hard stop silently exited 0 on a spent budget from
+// every working directory. Sibling resolution also survives the consumer
+// install, where the pair lands under a different prefix together.
+const BUDGET_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), 'budget.mjs');
+
 function runBudgetCheck() {
   const env = { ...process.env, BUDGET_QUIET: '1' };
-  const r = spawnSync('node', ['scripts/cost/budget.mjs', 'check'], { env, encoding: 'utf-8' });
+  const r = spawnSync('node', [BUDGET_SCRIPT, 'check'], { env, encoding: 'utf-8' });
   if (r.error) return { ok: false, fatal: true, msg: String(r.error) };
   const out = (r.stdout || '').trim();
   if (!out) return { ok: true, unbudgeted: true };

package/src/scripts/council_cli.ts

@@ -2127,7 +2127,7 @@ function _ljust(s: string, width: number): string {
 
 function _debate_refusal_cap(ai_cfg: Dict): number {
     const debate_block = (ai_cfg['debate'] as Dict) || {};
-    return _pyFloat(debate_block['max_cost_usd'] ?? 5.0, 5.0) || 0.0;
+    return _pyFloat(debate_block['max_cost_usd'] ?? 0.0, 0.0) || 0.0; // 0 = no cap (ADR-279)
 }
 
 function _emit_shadow_slo_banner(): void {
@@ -2560,9 +2560,9 @@ function cmd_run(
 
     const cost_cfg = (ai_cfg['cost_budget'] as Dict) || {};
     const budget = new CostBudget({
-        max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 50_000, 50_000),
-        max_output_tokens: _pyInt(cost_cfg['max_output_tokens'] ?? 20_000, 20_000),
-        max_calls: _pyInt(cost_cfg['max_calls'] ?? 10, 10),
+        max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 0, 0), // 0 = unbounded (ADR-279)
+        max_output_tokens: _pyInt(cost_cfg['max_output_tokens'] ?? 0, 0), // 0 = unbounded (ADR-279)
+        max_calls: _pyInt(cost_cfg['max_calls'] ?? 10, 10), // a call count, not money — kept
         max_total_usd: _pyFloat(cost_cfg['max_total_usd'] ?? 0.0, 0.0) || 0.0,
         // Rolling 24h cap. Unwired until now: the field existed on CostBudget and
         // gated the spend-ledger append, but no caller ever passed it, so the
@@ -3076,9 +3076,9 @@ function cmd_debate(
 
     const cost_cfg = (ai_cfg['cost_budget'] as Dict) || {};
     const budget = new CostBudget({
-        max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 50_000, 50_000),
-        max_output_tokens: _pyInt(cost_cfg['max_output_tokens'] ?? 20_000, 20_000),
-        max_calls: _pyInt(cost_cfg['max_calls'] ?? 10, 10),
+        max_input_tokens: _pyInt(cost_cfg['max_input_tokens'] ?? 0, 0), // 0 = unbounded (ADR-279)
+        max_output_tokens: _pyInt(cost_cfg['max_output_tokens'] ?? 0, 0), // 0 = unbounded (ADR-279)
+        max_calls: _pyInt(cost_cfg['max_calls'] ?? 10, 10), // a call count, not money — kept
         max_total_usd: _pyFloat(cost_cfg['max_total_usd'] ?? 0.0, 0.0) || 0.0,
         // Rolling 24h cap. Unwired until now: the field existed on CostBudget and
         // gated the spend-ledger append, but no caller ever passed it, so the

package/src/scripts/dispatch_r2_reviewer.ts

@@ -738,6 +738,29 @@ export const RETURN_ENVELOPE_POINTER =
     'write-to-disk-first rule: contexts/execution/subagent-response-contract.md. ' +
     'The findings table stays a file.';
 
+/**
+ * Two-line header prepended, verbatim and at byte offset 0, to every
+ * `<slug>.review-input/roadmap.md` snapshot this dispatcher writes.
+ *
+ * Its NAMED job is `check_references`'s file-level skip marker
+ * (`check_references.ts` `FILE_SKIP_MARKER`): the snapshot sits under a
+ * tree that gate walks, while the LIVE roadmap layer is deliberately
+ * excluded from it — so a roadmap that legitimately quotes a nonexistent
+ * path (e.g. documenting a hallucinated council citation) would red CI
+ * through its own review snapshot.
+ *
+ * That is its only job. It used to carry a second, unnamed one — pushing the
+ * frontmatter fence off byte offset 0 kept `check_agent_artifact_location`
+ * from reading the snapshot as a misplaced roadmap. That gate now exempts the
+ * snapshot path by name (`isReviewInputRoadmapSnapshot`), so this header may
+ * change without that gate noticing. Tested in
+ * `check_agent_artifact_location.test.ts` (describe: "review-input snapshot
+ * convention").
+ */
+export const REVIEW_INPUT_ROADMAP_HEADER =
+    '<!-- check-refs: skip -->\n' +
+    '<!-- verbatim roadmap snapshot for the R2 reviewer; the live roadmap layer is excluded from check_references, and a snapshot must not fail a gate its source is exempt from -->\n';
+
 function reviewerPrompt(args: {
     slug: string;
     headSha: string;
@@ -1288,19 +1311,9 @@ function runDispatch(args: Args): number {
 
     redactions += writeRedacted(path.join(inputDirAbs, 'diff.patch'), scopeDiffText, denyPatterns);
     if (roadmapText !== null) {
-        // The snapshot lands under agents/evidence/, which check_references
-        // walks, while the live roadmap layer is deliberately excluded from
-        // that gate — so a roadmap that legitimately quotes a nonexistent
-        // path (e.g. documenting a hallucinated council citation) would red
-        // CI through its own review snapshot. The header exemption keeps the
-        // snapshot verbatim below the marker; roadmap_hash binds the LIVE
-        // file and is unaffected. Found by the zcs-close CI run, 2026-08-09.
-        const snapshotHeader =
-            '<!-- check-refs: skip -->\n' +
-            '<!-- verbatim roadmap snapshot for the R2 reviewer; the live roadmap layer is excluded from check_references, and a snapshot must not fail a gate its source is exempt from -->\n';
         redactions += writeRedacted(
             path.join(inputDirAbs, 'roadmap.md'),
-            snapshotHeader + roadmapText,
+            REVIEW_INPUT_ROADMAP_HEADER + roadmapText,
             denyPatterns,
         );
     }