@event4u/agent-config 10.1.0 → 10.3.0

package/src/config/gate-violation-baselines.json

@@ -1,6 +1,12 @@
 {
   "$comment": "Violation ratchet for gates whose dead scan root was repaired. A repair REVEALS pre-existing debt; it does not create it. Each entry records the count revealed at repair time — the gate fails only when its count RISES. Lowering a count is a normal commit; raising one is a defect. Entries expire: a baseline that has not dropped within 56 days of `landed` (or of `reaffirmed.date`) fails its gate, because a number that never moves is suppression with extra steps. Mechanism + rationale: src/scripts/_lib/gate_baseline.ts. Decision: AI council 2026-08-02, roadmap road-to-gates-that-can-fail blocker `dead-gate-finding-triage`.",
   "gates": {
+    "ci-parity:local-only": {
+      "count": 167,
+      "landed": "2026-08-13",
+      "note": "Gates that `task ci` runs and no workflow does — the direction this manifest's own header calls the one that let real defects merge (16 stale index rows reached the trunk behind a local-only check-index). Revealed, not created, by repairing the checker's extraction: check_ci_local_parity built its CI-side set by regexing RAW workflow text for `task <name>` and expanding each closure, comments included. Several workflow comments contain the literal string `task ci` while stating that no workflow invokes it, so `ci` was read as an invocation and its full 247-gate closure entered the 'runs in CI' set. The count was therefore 0 BY CONSTRUCTION, and the prose documenting the gap was what suppressed it. Measured at the repair: CI-side 273 → 106, undeclared_local_only 0 → 167 of 247 local gates (68%). Baselined rather than hard-failed because 167 findings nobody can clear in the change that reveals them is the gate-that-lands-as-N-instant-blockers failure this repository has refused before; shrink-only keeps the property that matters, namely that a NEW gate registered in `task ci` with no workflow reds immediately. Lowering happens by wiring gates into workflows or declaring them under `local_only:` with a reason. Note the punchline, because it bounds the risk of this entry: check_ci_local_parity ITSELF runs in no workflow, so it is its own finding and this ratchet has no remote reach either — clearing the backlog is what gives it teeth.",
+      "falsifier": "./scripts-run src/scripts/check_ci_local_parity"
+    },
     "check_no_new_legacy_path:hardcoded-scan-roots": {
       "count": 48,
       "landed": "2026-08-09",
@@ -22,9 +28,9 @@
       "note": "Markdown links between source artefacts that cross a pack boundary the source pack's `requires` graph does not reach — revealed when the scan root moved off the deleted packages/ tree to the live corpus (0 -> 753 artefacts scanned). 82 distinct pack pairs across 131 source files; largest single class is engineering-base -> meta (73), skills in a consumer-installable pack citing this package's own maintenance skills. Each is a link that dangles for a consumer who installs the source pack without the target's. Judged real drift rather than an over-strict gate because it is long-tailed — top bucket 22%, no single systematic cause — unlike the lint_artefact_frontmatter case, where one required shape had 0-of-288 adoption. Fix per finding: add the edge to packs.yml requires, retarget the link, or move the artefact."
     },
     "check_gate_completeness": {
-      "count": 217,
-      "landed": "2026-08-05",
-      "note": "Ledger adoption ratchet. 217 of 221 CI-registered gates do not yet carry per-target completeness accounting (`_lib/gate_ledger.ts`) or a `// ledger-exempt:` marker. This is deliberately NOT a sweep: road-to-skill-ecosystem-gate-integrity Phase 1 adopts exactly three gates (lint_framework_leakage, check_references, lint_roadmap_complexity) plus the checker itself to prove the interface, and the remainder migrates as gates are touched. Shrink-only from here — the number may not grow, so a NEW gate must adopt or exempt.",
+      "count": 216,
+      "landed": "2026-08-12",
+      "note": "Ledger adoption ratchet. 216 of 244 registered gates do not yet carry per-target completeness accounting (`_lib/gate_ledger.ts`) or a `// ledger-exempt:` marker. This is deliberately NOT a sweep: road-to-skill-ecosystem-gate-integrity Phase 1 adopts exactly three gates (lint_framework_leakage, check_references, lint_roadmap_complexity) plus the checker itself to prove the interface, and the remainder migrates as gates are touched. Shrink-only from here — the number may not grow, so a NEW gate must adopt or exempt.",
       "falsifier": "./scripts-run src/scripts/check_gate_completeness"
     },
     "check_depth_budget": {
@@ -37,6 +43,12 @@
       "landed": "2026-08-06",
       "note": "Self-test adoption ratchet, expressed as a shrink-only NON-adopter count. 24 of the 32 gates registered enforced in gate-coverage.yml carry neither a `--self-test` (`_lib/gate_self_test.ts`) nor a `// self-test-exempt: <reason>` marker, so nothing proves they DISCRIMINATE — an enforced `scanned:` floor proves a gate read something, only a self-test proves the reading changes the verdict. Deliberately NOT an adoption column ratcheted upward: check_gate_coverage.ts's own report_hardening_ratchet rejects that shape in this same file (\"grades the solution instead of the problem\"), and the sibling adoption ratchet (check_gate_completeness) is already a non-adopter count. Population is the manifest, not every script under src/scripts: padding the manifest to move this number would mean adding a floor per row. Shrink-only from here — a NEW registered gate must adopt or exempt. Migration mechanism, same as the ledger ratchet above: gates adopt as they are touched, not in a sweep — the eight current adopters were each added alongside a real change to that gate. The 56-day non-stagnation clause applies unchanged, so a count parked here fails on its own.",
       "falsifier": "./scripts-run src/scripts/check_gate_coverage"
+    },
+    "lint_settings_classes:derivable-surface": {
+      "count": 83,
+      "landed": "2026-08-12",
+      "note": "Anti-regrowth ratchet for the settings disposition axis. 83 of 134 template leaves are classified `derivable` — the mechanism can decide from the situation, so the key should not exist — and each names the replacement that would decide instead (`lint_settings_classes` rejects the bare label, which is what keeps the class from becoming a synonym for \"inconvenient to keep\"). This is a DELETION QUEUE, not 83 deletions: a row stays until the mechanism it names actually exists, and deleting a key ahead of its mechanism is a silently-changed default rather than a simplification. Shrink-only from here, which is the anti-regrowth half — a NEW key classified `derivable` raises the number and reds, so a key whose answer the situation already carries cannot be added at all. The 56-day non-stagnation clause is the other half and is wanted here rather than tolerated: a queue that never drains is a stated direction nobody is walking. The queue opened at 88 of 140 on 2026-08-12 and drained to 83 of 134 the same day: six keys had no reader whatsoever (telegraph.speak_scope, chat_history.max_size_kb, chat_history.on_overflow, quality.wait_for_remote_ci, screenshots.data_bearing_gate, legal_review_prep.consented_at), five of them `derivable` and one a `consent` row reclassified because a published-egress confirmation is a Hard Floor no setting may lift. An unread key is the only deletion that cannot silently change a default, which is why that batch went first. The classification itself is docs/contracts/settings-classes.md.",
+      "falsifier": "./scripts-run src/scripts/lint_settings_classes"
     }
   }
 }

package/src/config/profiles/balanced.ini

@@ -17,5 +17,3 @@ discipline_profile=auto
 
 ; Chat history (crash recovery) — balanced = phase-level traceability
 chat_history_frequency=per_phase
-chat_history_max_size_kb=256
-chat_history_on_overflow=rotate

package/src/config/profiles/full.ini

@@ -13,7 +13,5 @@ rule_loading_tier=full
 ; via the legacy mapping (minimal->off, balanced->essential, full->full).
 discipline_profile=full
 
-; Chat history (crash recovery) — full = tool-level traceability + summarize on overflow
+; Chat history (crash recovery) — full = tool-level traceability
 chat_history_frequency=per_tool
-chat_history_max_size_kb=512
-chat_history_on_overflow=condense

package/src/config/profiles/minimal.ini

@@ -15,5 +15,3 @@ discipline_profile=off
 
 ; Chat history (crash recovery) — minimal = lightest footprint
 chat_history_frequency=per_turn
-chat_history_max_size_kb=128
-chat_history_on_overflow=rotate

package/src/config/review-prompt-binding-baseline.json

@@ -0,0 +1,19 @@
+{
+  "$schema_note": "Consumed by src/scripts/check_review_prompt_binding.ts. An entry EXEMPTS one committed review prompt from the sha256(prompt.md) == prompt_hash check. Both hashes are pinned on purpose: if either moves, the entry stops matching and the gate reds, so a later repair and a further corruption are equally visible. A pre-loaded verdict is NEVER suppressed by the hash exemption alone — it needs its own `steered_ack` block on the entry, which pins the exact matched phrase, so growth of the shared steering predicate cannot turn committed prompts into permanent unfixable blocks and cannot be waved through silently either.",
+  "entries": [
+    {
+      "slug": "zcs-close-2026-08-09",
+      "declared": "48eae5ad829b375c4667fcd72ecc482cbd62ae90788134ca46a81eacce267d49",
+      "actual": "f83ee959abb7f8c333bc89f117d3dee93f0e7b2a816c4593471aeda9b18c302d",
+      "reason": "Explained and closed at the cause: the archival sweep rewrote a roadmap path INSIDE this committed reviewer prompt while migrating inbound references. The cause was fixed on 2026-08-11 by _FROZEN_RECORD_PREFIXES in the sweep. Not repaired because repair is not available here: the recorded hash was produced by the ORIGINAL prompt text, so rewriting the hash to match the corrupted text would fabricate a binding that never existed, and restoring the text from history would erase the only evidence that the sweep reached inside a committed round at all. An earlier revision of this entry cited section 2.7 as forbidding the edit; that citation was wrong and is corrected here, because section 2.7 says the rename is an archival step and never an edit ban on a live artefact.",
+      "falsifier": "npx tsx src/scripts/check_review_prompt_binding.ts --json  # the recorded actual hash stops matching the committed prompt.md, i.e. the record moved after all"
+    },
+    {
+      "slug": "feat-parallel-session-collision-hardening",
+      "declared": "d996e8e86a6e21a7cad66963f70219e59fe8cb96bca0bd1adceeea7ad2565c4b",
+      "actual": "dae1f14e90be94e71415e520b08222ea819488188d670de280d874803de1035c",
+      "reason": "Current and UNEXPLAINED, and it is the empirical justification for this gate. The prompt.md has a single commit dated 2026-08-12, after the sweep fix, so the sweep did not cause it; the declared hash never matched the committed text. CRLF/LF and trailing-newline variants were all tried and none reproduces the declared hash. Not repaired because no repair is knowable: with the cause unidentified, neither side can be established as the correct one, and editing either to make them agree would assert a binding nobody has evidence for. Recording it keeps the discrepancy visible until someone can explain it.",
+      "falsifier": "npx tsx src/scripts/check_review_prompt_binding.ts --json  # a cause is found and the entry is replaced by the repair, or the recorded actual hash stops matching"
+    }
+  ]
+}

package/src/config/rule-enforcement-baseline.json

@@ -1,5 +1,4 @@
 [
-  "active-remediation.md",
   "agent-authority.md",
   "analysis-skill-routing.md",
   "architecture.md",

package/src/scripts/_cli/cmd_session_recycle.ts

@@ -20,6 +20,7 @@
  *   agent-config session:recycle --file <envelope.json>   # read from file
  *   agent-config session:recycle < envelope.json          # read from stdin
  *   agent-config session:recycle --template               # print a skeleton
+ *   agent-config session:recycle --project <path>         # name the repo explicitly
  *
  * Exit codes: 0 written (or template printed) · 1 invalid / refused · 2 usage.
  */
@@ -29,7 +30,7 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
-import { resolve_project_root } from '../_lib/agent_settings.js';
+import { ORIGIN_CWD_FALLBACK, resolve_project_root } from '../_lib/agent_settings.js';
 import {
     RECYCLE_ENVELOPE_MAX_BYTES,
     RECYCLE_ENVELOPE_REL,
@@ -77,6 +78,7 @@ interface ParsedArgv {
     ok: boolean;
     message?: string;
     file?: string;
+    project?: string;
     template?: boolean;
     verify?: boolean;
 }
@@ -94,6 +96,11 @@ export function parseArgv(argv: readonly string[]): ParsedArgv {
             if (!value) return { ok: false, message: '--file requires a path' };
             parsed.file = value;
             i += 1;
+        } else if (a === '--project') {
+            const value = argv[i + 1];
+            if (!value) return { ok: false, message: '--project requires a path' };
+            parsed.project = value;
+            i += 1;
         } else if (a === '-h' || a === '--help') {
             return { ok: false, message: 'usage' };
         } else {
@@ -110,11 +117,50 @@ export function parseArgv(argv: readonly string[]): ParsedArgv {
  */
 export function runSessionRecycle(
     input: string,
-    opts: { cwd: string; now?: Date; verify?: boolean },
+    opts: { cwd: string; now?: Date; verify?: boolean; project?: string },
 ): RecycleResult {
     const out: string[] = [];
     const err: string[] = [];
-    const [projectRoot] = resolve_project_root(null, { cwd: opts.cwd });
+
+    // `--project` is validated by the resolver (existence + directory), which
+    // signals by THROWING. Uncaught, that would surface as a stack trace from
+    // a command whose entire subject is legible failure.
+    let projectRoot: string;
+    let origin: string;
+    try {
+        [projectRoot, origin] = resolve_project_root(opts.project ?? null, { cwd: opts.cwd });
+    } catch (exc) {
+        return { code: 1, out, err: [`recycle envelope refused — ${String(exc)}`] };
+    }
+
+    // An unanchored cwd is the ONE case where a successful write is worse than
+    // a refusal. `resolve_project_root` falls back to the cwd itself when it
+    // reaches the filesystem root without finding an anchor, so a call from
+    // outside any repo — the shape a consumer with a toolchain pin is forced
+    // into — writes a valid envelope into a directory the successor session
+    // never looks at, and then prints a resume instruction whose next step is
+    // `/clear`. The exit code says it worked; the session is gone anyway.
+    //
+    // Refused BEFORE the parse: everything downstream reads this root, so a
+    // wrong one also produces a wrong `workspace` field and grounding read
+    // from the wrong git tree. `--verify` is refused too — validating against
+    // a root the write would not use answers a question nobody asked.
+    if (origin === ORIGIN_CWD_FALLBACK) {
+        return {
+            code: 1,
+            out,
+            err: [
+                `recycle envelope refused — no project anchor at or above ${projectRoot}`,
+                'Writing here would put the envelope where the successor session never reads it,',
+                'and the resume instruction would then advise /clear on a session that cannot resume.',
+                'Name the repository explicitly — it must be the WORKSPACE ROOT OF THE SESSION',
+                'that will resume, because that is the directory the successor reads the envelope',
+                'from; a path that merely happens to be a project is not enough:',
+                `  agent-config session:recycle --project <session-workspace-root> …`,
+                `  AGENT_CONFIG_PROJECT_ROOT=<session-workspace-root> agent-config session:recycle …`,
+            ],
+        };
+    }
 
     let parsed: unknown;
     try {
@@ -179,23 +225,28 @@ export function runSessionRecycle(
         };
     }
 
+    // Absolute, not `RECYCLE_ENVELOPE_REL`: the relative form is identical for
+    // every root, so it cannot tell the reader WHICH tree was written — the
+    // one thing in doubt at the moment this line is read.
+    const target = path.join(projectRoot, RECYCLE_ENVELOPE_REL);
+
     // `--verify` stops HERE: every rejection above has already run, and the
     // only thing skipped is the write. Validating through a different path
     // than the one that writes would make the check a second implementation
     // to keep in sync — the failure this suite refuses elsewhere.
     if (opts.verify === true) {
         out.push(`recycle envelope VALID — ${bytes} bytes, not written (--verify).`);
+        out.push(`Target would be: ${target}`);
         return { code: 0, out, err };
     }
 
-    const target = path.join(projectRoot, RECYCLE_ENVELOPE_REL);
     try {
         atomic_write_json(target, envelope);
     } catch (exc) {
         return { code: 1, out, err: [`could not write ${target}: ${String(exc)}`] };
     }
 
-    out.push(`recycle envelope written — ${RECYCLE_ENVELOPE_REL} (${bytes} bytes)`);
+    out.push(`recycle envelope written — ${target} (${bytes} bytes)`);
     out.push('');
     out.push('Resume instruction:');
     out.push('  1. End this session now: run /clear (or start a fresh session in this workspace).');
@@ -210,10 +261,15 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     const parsed = parseArgv(argv);
     if (!parsed.ok) {
         const usage = [
-            'usage: agent-config session:recycle [--file <envelope.json>] [--template] [--verify]',
-            '  --file <path>   read the envelope JSON from a file (default: stdin)',
-            '  --template      print a skeleton envelope and exit',
-            '  --verify        validate only — same rejections, no write',
+            'usage: agent-config session:recycle [--file <envelope.json>] [--project <path>] [--template] [--verify]',
+            '  --file <path>     read the envelope JSON from a file (default: stdin)',
+            '  --project <path>  the workspace root of the session that will resume — required',
+            '                    when the working directory is outside any project (the command',
+            '                    refuses rather than writing an envelope the successor cannot',
+            '                    find). The successor reads the envelope from ITS OWN workspace',
+            '                    root, so a path that is merely a valid project is not enough.',
+            '  --template        print a skeleton envelope and exit',
+            '  --verify          validate only — same rejections, no write',
         ].join('\n');
         if (parsed.message === 'usage') {
             process.stdout.write(`${usage}\n`);
@@ -246,6 +302,7 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     const result = runSessionRecycle(input, {
         cwd: process.cwd(),
         ...(parsed.verify === true ? { verify: true } : {}),
+        ...(parsed.project !== undefined ? { project: parsed.project } : {}),
     });
     for (const line of result.out) process.stdout.write(`${line}\n`);
     for (const line of result.err) process.stderr.write(`${line}\n`);

package/src/scripts/_cli/handoff_sessions.ts

@@ -30,6 +30,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 
+import { projectStoreSlug } from '../_lib/cc_transcript.js';
 import { derive_session_tag, list_sessions, read_entries } from '../chat_history.js';
 import { eolSessionKey, readEolCounters, type StoredEolCounters } from '../_lib/session_eol.js';
 
@@ -102,9 +103,9 @@ export interface ListOptions {
     workspaceRoot?: string;
 }
 
-/** Mirrors the Claude Code project-dir naming: `/` and `.` → `-`. */
+/** Mirrors the Claude Code project-dir naming — see `_lib/cc_transcript.projectStoreSlug`. */
 export function encode_project_path(cwd: string): string {
-    return cwd.replace(/[/.]/g, '-');
+    return projectStoreSlug(cwd);
 }
 
 function _snippet(text: string, max: number = SUMMARY_SNIPPET_CHARS): string {

package/src/scripts/_dispatch.bash

@@ -80,6 +80,7 @@ TS-shell native (run via the installed `agent-config` binary):
                              Names the degraded case (settings file without a
                              profile.id → zero packs) that nothing else reports.
   commands [ls|explain]      List/explain the command surface from the discovery manifest
+                             (ls --candidates: surface-reduction report, report-only)
   mcp-server                 Turnkey read-only stdio MCP server (no repo clone; ADR-085)
   doctor-shell               Probe the TS-shell environment
   rtk:detect                 rtk (Rust Token Killer) presence + identity readout (--json)

package/src/scripts/_lib/agent_settings.ts

@@ -283,7 +283,6 @@ export const MERGEABLE_KEYS: readonly string[] = [
     'personal.bot_icon',
     'personal.pr_comment_bot_icon',
     'personal.autonomy',
-    'telegraph.speak_scope',
     // Knowledge-card global cross-project sharing is a USER-GLOBAL setting
     // (ADR-100 / road-to-structure-grounding-v2). Whitelisted so the
     // ~/.event4u/agent-config/agent-settings.yml values are honoured.
@@ -908,8 +907,27 @@ export function load_agent_settings(
  * 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.
+ *
+ * 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.
  */
-const REMOVED_KEYS: ReadonlyMap<string, string> = new Map([
+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'],
@@ -919,6 +937,11 @@ const REMOVED_KEYS: ReadonlyMap<string, string> = new Map([
     ['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_router gates on telegraph.speak alone'],
+    ['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'],
 ]);
 
 /** Keys already warned about in THIS process — the "once per run" dedupe. */

package/src/scripts/_lib/bench_telegraph.ts

@@ -23,7 +23,7 @@ import YAML from 'yaml';
 
 // ── system prompts per arm ──────────────────────────────────────────────
 
-export const SYSTEM_PROMPT_CONDENSED = `You are speaking in TELEGRAPH-SPEAK mode (speak_scope=aggressive).
+export const SYSTEM_PROMPT_CONDENSED = `You are speaking in TELEGRAPH-SPEAK mode (condense aggressively).
 
 Condense all body prose to telegraph grammar:
 - Drop articles (the, a, an).

package/src/scripts/_lib/cc_transcript.ts

@@ -35,6 +35,31 @@ import { homedir } from 'node:os';
 /** Default base directory holding one subdirectory per Claude Code project. */
 export const DEFAULT_PROJECTS_ROOT = path.join(homedir(), '.claude', 'projects');
 
+/**
+ * The store directory name Claude Code derives from a working directory.
+ *
+ * Every character outside `[A-Za-z0-9-]` becomes `-`: `/Users/x/.claude` →
+ * `-Users-x--claude`, and a worktree `feat+turn-end-gate-always-on` →
+ * `feat-turn-end-gate-always-on`.
+ *
+ * This lives here because it was wrong in six places at once. The sweep on
+ * 2026-08-12 found `replace(/[/.]/g, '-')` copied across every transcript-reading
+ * report; each one computed a directory that does not exist for any path
+ * carrying a `+` and returned an empty corpus — indistinguishable from a clean
+ * result. One of those copies already carried a comment about the round BEFORE
+ * that, when only `/` was replaced and dotted segments missed. Widening the
+ * class by one character per incident is how a defect survives two fixes, so
+ * the class is closed instead: anything not `[A-Za-z0-9-]` is slugged.
+ */
+export function projectStoreSlug(cwd: string): string {
+  return cwd.replace(/[^A-Za-z0-9-]/g, '-');
+}
+
+/** Absolute path to a working directory's transcript store. */
+export function projectStoreDir(cwd: string, root: string = DEFAULT_PROJECTS_ROOT): string {
+  return path.join(root, projectStoreSlug(cwd));
+}
+
 export type TranscriptBucket = 'main' | 'subagent';
 
 /** The six token counters every downstream metric (cost, weight, share) is built from. */

package/src/scripts/_lib/compile_time_toggles.ts

@@ -60,9 +60,10 @@ export const COMPILE_TIME_TOGGLES: Record<string, (s: ToggleSettings) => boolean
     // family master switch, and flipping it would silence sibling telegraph settings
     // that were never measured negative.
     //
-    // This predicate deliberately does NOT read `speak_scope`. That key disables the
-    // rule's *behaviour* and never removed its token cost — the trap the measurement
-    // exposed.
+    // The predicate gates on `telegraph.speak` because that is the only lever that
+    // removes the rule's ~982-token body from the router and the projection. A knob
+    // that merely narrowed the grammar at runtime would leave the token cost in place
+    // — the trap the measurement exposed.
     'telegraph-speak': (s: ToggleSettings): boolean => {
         const tg = (s['telegraph'] as ToggleSettings | undefined) ?? {};
         const enabled = tg['enabled'] === undefined ? true : tg['enabled'];