@event4u/agent-config 14.21.0 → 14.23.0

package/dist/scripts/condense.js

@@ -39,7 +39,7 @@ import { _domains_command_logical, artefact_roots as _agent_src_artefact_roots,
 // 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 { normalizeLeanProjectionMode, writesThinFiles } from './_lib/lean_projection_mode.js';
+import { describeDroppedHosts, normalizeLeanProjectionMode, resolveLeanProjectionHosts, thinsHost, writesThinFiles } 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';
 import { rule_is_compile_enabled } from './_lib/compile_time_toggles.js';
@@ -232,9 +232,9 @@ export { rule_in_scope } from '../install/ruleInScope.js';
 export { CLAUDE_PATHS_PATTERN_BUDGET, _claude_paths_plan, _escape_claude_bracket, _expanded_pattern_count, _has_non_path_trigger, _is_unresolved_placeholder, derive_trigger_globs, } from '../install/claudePathsPlan.js';
 import { rule_in_scope } from '../install/ruleInScope.js';
 import { pruneEmptyDirs } from './_lib/prune_empty_dirs.js';
-import { commandsWithheld, partitionActive, personaPartition, setPartitionAnnounce } from '../install/partitionEligibility.js'; // ADR-236
+import { claudeLayerHolds, commandWithheld, keepInProjectLayer, personaPartition } from '../install/partitionEligibility.js'; // ADR-236
 import { dedupableRules, partitionRulesForDir } from '../install/ruleLayerPartition.js'; // ADR-236, per-host evidence
-import { _claude_paths_plan, derive_trigger_globs } from '../install/claudePathsPlan.js';
+import { _claude_paths_plan, applies_when, derive_trigger_globs } from '../install/claudePathsPlan.js';
 const _HERE = path.dirname(fileURLToPath(import.meta.url)); // <repo>/src/scripts
 const _DEFAULT_PROJECT_ROOT = path.resolve(_HERE, '..', '..');
 function _deriveState(root) {
@@ -263,7 +263,6 @@ function _deriveState(root) {
     };
 }
 export const MODULE_STATE = _deriveState(_DEFAULT_PROJECT_ROOT);
-setPartitionAnnounce(success); // ADR-236: the mode line must be visible at the default level
 /**
  * Test seam — reassign one or more module-state fields, mirroring the pytest
  * monkeypatch of `condense.<NAME> = ...`. When `PROJECT_ROOT` is overridden,
@@ -384,13 +383,16 @@ function _read_projection_scope_dedup() {
     }
     return false;
 }
-function _lean_projection_mode() {
+function _lean_projection_settings() {
     const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
     const lean = data['lean_projection'];
-    const raw = typeof lean === 'object' && lean !== null && !Array.isArray(lean)
-        ? lean['mode']
-        : '';
-    return normalizeLeanProjectionMode(raw);
+    const obj = typeof lean === 'object' && lean !== null && !Array.isArray(lean)
+        ? lean
+        : {};
+    return {
+        mode: normalizeLeanProjectionMode(obj['mode'] ?? ''),
+        hosts: resolveLeanProjectionHosts(obj['hosts']),
+    };
 }
 // --- hashing -----------------------------------------------------------------
 export function apply_path_rewriter(relative_path) {
@@ -986,20 +988,17 @@ export function projected_rule_trees(user_home = process.env['HOME'] ?? os.homed
 export function generate_rule_symlinks() {
     const rules = _scoped_rule_basenames();
     const tool_dirs = _filter_tool_dirs(TOOL_DIRS);
+    const lean = _lean_projection_settings();
+    for (const warning of describeDroppedHosts(lean.hosts))
+        _print(`  ⚠️  ${warning}`);
     let thin_files = null;
-    if (writesThinFiles(_lean_projection_mode())) {
-        // DEAD-SWITCH REPAIR (road-to-renewal-foundation Phase 2). This branch
-        // used to THROW: the port was skipped as "out of scope, not exercised by
-        // golden parity", which left a documented, settings-selectable mode that
-        // could only ever crash. `build_thin` was ported and has been present the
-        // whole time — the wiring was the only thing missing.
-        //
-        // Scope note: this repairs the SWITCH only. The default stays
-        // `eager-all`. Flipping it is parked behind the thin-projection honest
-        // null (thin win-rate 36.2% < the 48% pre-registered threshold), and
-        // nothing here disturbs that verdict — but a mode that throws cannot
-        // even be re-measured, which is why the repair earns its place alone.
-        thin_files = Object.fromEntries(build_thin(MODULE_STATE.RULES_SOURCE, _read_rule_workspaces()));
+    if (writesThinFiles(lean.mode)) {
+        // `thin` stays parked behind the thin-projection honest null (win-rate
+        // 36.2% against a 48% pre-registered threshold, ADR-202). `delivery` is
+        // NOT gated by that null and citing it as one is K7: delivery re-delivers
+        // identical bytes, is licensed by `docs/CLAIMS.md:365` on delivery
+        // equivalence and cost, and needs a recall floor rather than a judge.
+        thin_files = Object.fromEntries(build_thin(MODULE_STATE.RULES_SOURCE, _read_rule_workspaces(), (m) => _print(`  ⚠️  ${m}`)));
     }
     const user_home = process.env['HOME'] ?? os.homedir();
     // Read the emit plan from the exported function rather than recomputing the
@@ -1045,7 +1044,7 @@ export function generate_rule_symlinks() {
             if (_existsOrSymlink(link)) {
                 fs.unlinkSync(link);
             }
-            if (thin_files !== null) {
+            if (thin_files !== null && thinsHost(lean.mode, lean.hosts.hosts, _DIR_TOOL_ID[tool_dir] ?? '')) {
                 _writeText(link, thin_files[rule]);
             }
             else if (tool_dir === '.claude/rules') {
@@ -1149,7 +1148,7 @@ export function _emit_cursor_mdc(source, target) {
     const globs = always_apply ? [] : derive_trigger_globs(meta);
     const lines = [
         '---',
-        `description: ${_yaml_scalar(description)}`,
+        `description: ${_yaml_scalar(always_apply ? description : applies_when(description, meta))}`,
         `globs: ${globs.join(',')}`,
         `alwaysApply: ${always_apply ? 'true' : 'false'}`,
         '---',
@@ -1170,7 +1169,7 @@ export function _emit_windsurf_rule(source, target) {
     const lines = [
         '---',
         `trigger: ${trigger}`,
-        `description: ${_yaml_scalar(description)}`,
+        `description: ${_yaml_scalar(always_apply ? description : applies_when(description, meta))}`,
         `globs: ${globs.join(',')}`,
         '---',
         '',
@@ -1448,23 +1447,21 @@ function _render_native_model_md(src_md, tier) {
     return text.replace(_MODEL_TIER_RE, `model: ${model}`);
 }
 export function generate_claude_skills(active_skill_names = null) {
-    if (partitionActive(MODULE_STATE.PROJECT_ROOT))
-        active_skill_names = new Set();
     if (!_exists(MODULE_STATE.SKILLS_SOURCE)) {
         process.stderr.write('  ⚠️  dist/agent-src/skills/ not found — skipping skills\n');
         return 0;
     }
-    let skills = _iterdirSorted(MODULE_STATE.SKILLS_SOURCE)
+    const all_skills = _iterdirSorted(MODULE_STATE.SKILLS_SOURCE)
         .filter((p) => _isDir(p))
         .map((p) => path.basename(p))
         .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    // ADR-236: withhold every skill `~/.claude/skills` holds — see `keepInProjectLayer`.
+    let skills = keepInProjectLayer('skills', all_skills);
     if (active_skill_names !== null) {
         skills = skills.filter((s) => active_skill_names.has(s));
     }
     const skill_set = new Set(skills);
-    const command_slugs = partitionActive(MODULE_STATE.PROJECT_ROOT)
-        ? new Set()
-        : new Set([...iterCommands()].map(([, slug]) => slug));
+    const command_slugs = _emitted_wrapper_slugs(new Set(all_skills));
     _mkdirp(MODULE_STATE.CLAUDE_SKILLS_DIR);
     const auto = _read_model_auto_switch() === 'auto';
     for (const item of _iterdirSorted(MODULE_STATE.CLAUDE_SKILLS_DIR)) {
@@ -1549,6 +1546,17 @@ function _nested_command_subpath(source_file) {
     const sub = logical.slice('commands/'.length).replace(/\.md$/, '');
     return sub.includes('/') ? sub : null;
 }
+/** The emitter's four skips, in one place — see `emittedWrapperSlugs`. */
+const _wrapper_is_emitted = (f, s, skills) => !skills.has(s) &&
+    _nested_command_subpath(f) === null &&
+    !is_claude_builtin_name(s) &&
+    !claudeLayerHolds('skills', s);
+/** Wrapper slugs the command emitter really writes — see `emittedWrapperSlugs`. */
+function _emitted_wrapper_slugs(skill_names) {
+    return new Set([...iterCommands()]
+        .filter(([f, s]) => _wrapper_is_emitted(f, s, skill_names))
+        .map(([, slug]) => slug));
+}
 /**
  * Project-scope `.claude/commands/<cluster>/<sub>.md` — the colon form.
  *
@@ -1561,15 +1569,12 @@ function _nested_command_subpath(source_file) {
  *
  * Emitting the nested form here lets `generate_claude_commands` stop wrapping
  * the clustered commands: one listing, same reachability, and reachability no
- * longer depends on a global deploy. Dedup AND precedence: `commandsWithheld`.
+ * longer depends on a global deploy. Dedup AND precedence: `commandWithheld`.
  *
  * ADR-003 (colon canonical for clusters) and ADR-044 (flat commands stay
  * hyphenated) both hold: flat commands are untouched and keep their wrapper.
  */
 export function generate_claude_project_commands(active_command_slugs = null) {
-    if (commandsWithheld(MODULE_STATE.PROJECT_ROOT))
-        active_command_slugs = new Set();
-    // Returns before the stale sweep — invariant, see `commandsWithheld`.
     if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
         return 0;
     }
@@ -1579,7 +1584,7 @@ export function generate_claude_project_commands(active_command_slugs = null) {
             continue;
         }
         const sub = _nested_command_subpath(source_file);
-        if (sub !== null) {
+        if (sub !== null && !commandWithheld(`${sub}.md`)) {
             nested.push([source_file, sub]);
         }
     }
@@ -1613,8 +1618,6 @@ export function generate_claude_project_commands(active_command_slugs = null) {
     return count;
 }
 export function generate_claude_commands(active_command_slugs = null) {
-    if (partitionActive(MODULE_STATE.PROJECT_ROOT))
-        active_command_slugs = new Set();
     if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
         process.stderr.write('  ⚠️  src/domains/ not found — skipping commands\n');
         return 0;
@@ -1630,6 +1633,7 @@ export function generate_claude_commands(active_command_slugs = null) {
     let count = 0;
     let skipped = 0;
     let reserved = 0;
+    let withheld = 0;
     let rendered = 0;
     const auto = _read_model_auto_switch() === 'auto';
     for (const [source_file, slug] of iterCommands()) {
@@ -1658,6 +1662,12 @@ export function generate_claude_commands(active_command_slugs = null) {
             reserved += 1;
             continue;
         }
+        // ADR-236 per-name: the INSTALLER re-projects visible flat commands as
+        // `~/.claude/skills/<slug>/SKILL.md` (install.ts:_apply_claude_flat_command_wrappers).
+        if (claudeLayerHolds('skills', slug)) {
+            withheld += 1;
+            continue;
+        }
         current_slugs.add(slug);
         const skill_dir = path.join(MODULE_STATE.CLAUDE_SKILLS_DIR, slug);
         _mkdirp(skill_dir);
@@ -1706,6 +1716,9 @@ export function generate_claude_commands(active_command_slugs = null) {
     if (reserved) {
         msg += ` (${reserved} withheld — Claude Code built-in name)`;
     }
+    if (withheld > 0) {
+        msg += ` (${withheld} withheld — ~/.claude/skills carries the wrapper)`;
+    }
     if (removed_dirs) {
         msg += ` (${removed_dirs} stale dirs removed)`;
     }
@@ -2019,19 +2032,13 @@ export function generate_persona_symlinks() {
         _print('  ⚠️  dist/agent-src/personas/ not found — skipping personas');
         return 0;
     }
-    const personas = _rglobSorted(MODULE_STATE.PERSONAS_SOURCE, '*.md')
-        .filter((p) => _isFile(p) && path.basename(p, '.md') !== 'README')
-        .map((p) => path.basename(p))
-        // glob('*.md') is non-recursive in Python; mirror that — only top level.
-        .filter((name) => _isFile(path.join(MODULE_STATE.PERSONAS_SOURCE, name)));
     // Python uses PERSONAS_SOURCE.glob("*.md") (non-recursive). Re-derive
     // from a direct listing to match exactly.
     const direct = _iterdirSorted(MODULE_STATE.PERSONAS_SOURCE)
         .filter((p) => p.endsWith('.md') && _isFile(p) && path.basename(p, '.md') !== 'README')
         .map((p) => path.basename(p))
         .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
-    void personas;
-    const partition = personaPartition(MODULE_STATE.PROJECT_ROOT, direct);
+    const partition = personaPartition(direct);
     const tool_dirs = _filter_tool_dirs(PERSONA_TOOL_DIRS);
     let total = 0;
     for (const [tool_dir, rel_prefix] of Object.entries(tool_dirs)) {

package/dist/scripts/project_thin_rules.js

@@ -19,7 +19,7 @@
  * `.augment/` projections.
  *
  * NOTE (faithful literal): the thin-entry pointer keeps the verbatim
- * `Body: [`{rule_id}`](../../.agent-src.uncondensed/rules/{rule_id}.md)`
+ * `Body: [`{rule_id}`](../../dist/agent-src/rules/{rule_id}.md)`
  * Markdown link from the retired Python implementation. The same-basename `.py` twin
  * carries that literal, so the ADR-051 legacy-path guard exempts this `.ts`
  * file by twin-parity.
@@ -34,6 +34,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { pathOnlyRuleIds, triggerlessRuleIds, } from './_lib/rule_injection.js';
 import * as token_count from './_lib/token_count.js';
 const _HERE = fileURLToPath(import.meta.url);
 // REPO_ROOT = Path(__file__).resolve().parent.parent.parent — three dirs up
@@ -72,21 +73,85 @@ export function kernel_ids() {
  * visible instead of being absorbed into the pointer count
  * (road-to-trigger-delivered-rule-bodies 1.3).
  */
+/**
+ * Rules whose ONLY triggers are path-shaped — reachable from `pre_tool_use`
+ * and from no other slot (road-to-delivery-for-every-host 3.2).
+ *
+ * They must never be thinned while the delivery concern is NOT bound on
+ * `pre_tool_use`, because a stub plus a slot nobody listens on is a rule that
+ * reaches the model at no scope at all. This is the same failure the
+ * `no_trigger_ids` exemption prevents, one step out: there the rule has nothing
+ * to match on, here it has nothing to match ON.
+ *
+ * Stated as a PROPERTY rather than a list of ids. If the concern is ever bound
+ * on `pre_tool_use` again, this exemption is what should be reconsidered — not
+ * three names someone has to remember.
+ *
+ * WHAT THIS EXEMPTION DOES **NOT** COVER — recorded 2026-09-08, R2 finding 1,
+ * because the silence read as coverage. The predicate is `every` trigger
+ * path-shaped. A rule with BOTH path and non-path triggers is therefore THINNED,
+ * and its path-shaped half then has no carrier at all: the stub carries no
+ * frontmatter (`condense.ts` writes it with `_writeText`, bypassing
+ * `_emit_claude_rule`'s host-native `paths:` key), `pre_tool_use` lost the
+ * binding under owner ruling E2, and `user_prompt_submit` never populates
+ * `openFiles`. Measured over the current `dist/router.json`: **18 such rules**,
+ * all non-kernel and all thinned — augment-edit-discipline, design-fidelity,
+ * doc-screenshot-hygiene, domain-adoption-policy,
+ * framework-neutrality-in-generic-skills, image-likeness-and-rights,
+ * laravel-translations, lethal-trifecta-guard, linked-projects-onboarding-gate,
+ * low-impact-corpus-privacy-floor, markdown-safe-codeblocks, onboarding-gate,
+ * persona-governance, php-coding, provider-lifecycle-discipline,
+ * roadmap-ci-steps-policy, roadmap-progress-sync, settings-ask-protocol.
+ *
+ * They do NOT reach the model at no scope: every non-path route
+ * (keyword / phrase / command) still delivers the body through the concern, and
+ * on `claude-code` they never had a separate host-native path route to lose —
+ * `_claude_paths_plan` emits no `paths:` for a mixed-trigger rule on purpose, so
+ * under `eager-all` they loaded UNCONDITIONALLY. What is lost is the difference
+ * between unconditional and prompt-triggered: a session that touches a matching
+ * file and says nothing that matches gets nothing.
+ *
+ * The labelled corpus cannot see this and the endpoint says so rather than
+ * implying otherwise — `model_rule_injection --endpoints` (b) now publishes the
+ * shipped `user_prompt_submit` reach beside the pre-registered reading, and
+ * every one of these 18 has at least one prompt-matching positive, so none
+ * appears in its "reachable only via a path trigger" column.
+ *
+ * WHY THIS IS NOT WIDENED TO `some` HERE. Measured: exempting all 18 moves the
+ * thin rule layer 23,592 -> 39,921 GPT tok (+16,329, +69 %), which is a budget
+ * move of a magnitude no agent may take, and it would erase most of the saving
+ * the flip is licensed on. Restoring a path route needs either that exemption
+ * under a re-anchored baseline or a `pre_tool_use` binding under a raised slot
+ * cap — both owner-reserved, so the closure is tracked rather than taken here.
+ * ADR-267's Consequences section names the receiver.
+ */
+/**
+ * ONE spelling of the router-derived sets, shared with the injector (R2
+ * finding 11).
+ *
+ * `path_only_ids` and `no_trigger_ids` were each a second, hand-rolled
+ * implementation of `_lib/rule_injection.ts::pathOnlyRuleIds` /
+ * `triggerlessRuleIds` — verified identical over the current router at the time
+ * (symmetric difference empty), so drift risk rather than a live defect. It is
+ * exactly the hazard `THIN_ENTRY_MARKER`'s own comment argues against one
+ * screen below ("a gate that re-spelled this string would drift from the writer
+ * silently"), and the two consumers here are the PROJECTOR's exemption set and
+ * the INJECTOR's reachability set: they must not be able to disagree about which
+ * rules the delivery path can reach.
+ *
+ * The finding named `path_only_ids`. The defect-pattern sweep found the SECOND
+ * instance one function down — `no_trigger_ids` against `triggerlessRuleIds` —
+ * and it is delegated in the same change. Count: 2 of 2 duplicated
+ * router-derived sets in this file, 0 remaining.
+ */
+function _router() {
+    return JSON.parse(fs.readFileSync(ROUTER, 'utf-8'));
+}
+export function path_only_ids() {
+    return pathOnlyRuleIds(_router());
+}
 export function no_trigger_ids() {
-    const data = JSON.parse(fs.readFileSync(ROUTER, 'utf-8'));
-    const out = new Set();
-    for (const tier of ['tier_1', 'tier_2']) {
-        const entries = data[tier];
-        if (!Array.isArray(entries))
-            continue;
-        for (const e of entries) {
-            const obj = e;
-            const t = obj.triggers;
-            if (!Array.isArray(t) || t.length === 0)
-                out.add(String(obj.id));
-        }
-    }
-    return out;
+    return new Set(triggerlessRuleIds(_router()));
 }
 /**
  * id → workspaces for every non-kernel router entry (router.json schema v2,
@@ -179,6 +244,42 @@ function _trigger_hint(fm) {
 function _title(s) {
     return s.replace(/[A-Za-z]+/g, (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase());
 }
+/**
+ * The marker that makes a projected entry recognisable as a stub.
+ *
+ * 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.
+ */
+export const THIN_ENTRY_MARKER = '> Routed rule — load the body on trigger-match.';
+/** Is this projected entry a pointer stub rather than a rule body? */
+export function is_thin_entry(text) {
+    return text.includes(THIN_ENTRY_MARKER);
+}
+/**
+ * Where a stub tells a reader the body actually is.
+ *
+ * FIXED 2026-09-07: this pointed into the uncondensed source tree ADR-051
+ * retired — the literal path is deliberately NOT reproduced here, because
+ * `check_no_uncondensed_refs` matches the string and cannot tell a repair
+ * record from a live reference; `git log -S` on this file finds the old value.
+ * It exists in no checkout, so EVERY stub's fallback pointer
+ * resolved to nothing — invisible under `delivery`, where the hook loads the
+ * body from `dist/agent-src/rules` and never follows this link, and total under
+ * `thin`, where the pointer is the only path to the body there is.
+ *
+ * KNOWN LIMIT, stated rather than discovered later: one relative prefix cannot
+ * be right for every tree, because they sit at different depths — `.claude/rules`
+ * and `.cursor/rules` are two levels below the repo root and `.clinerules` is
+ * one. `../../` is correct for the first two, which are the only trees the
+ * shipped `lean_projection.hosts` default can thin. A stub in `.clinerules`
+ * needs an operator to have added `cline` to that list, and its pointer is off
+ * by one level. That is strictly better than the previous state, where the
+ * pointer was dead in all three, and it is recorded here so the remaining case
+ * is a known limit rather than a surprise.
+ */
+const BODY_LINK_PREFIX = '../../dist/agent-src/rules/';
 /** Build the minimal progressive-disclosure pointer for a non-kernel rule. */
 export function thin_entry(rule_id, text) {
     const [fm] = split_frontmatter(text);
@@ -187,13 +288,25 @@ export function thin_entry(rule_id, text) {
     const title = _title(rule_id.replace(/-/g, ' '));
     const fires = hint ? ` Fires on: ${hint}.` : '';
     return (`## ${title}\n` +
-        `> Routed rule — load the body on trigger-match.${fires} ${desc} ` +
-        `Body: [\`${rule_id}\`](../../.agent-src.uncondensed/rules/${rule_id}.md)\n`);
+        `${THIN_ENTRY_MARKER}${fires} ${desc} ` +
+        `Body: [\`${rule_id}\`](${BODY_LINK_PREFIX}${rule_id}.md)\n`);
 }
 /** Map {filename: thin_or_full_text} for every rule. Kernel stays full. */
-export function build_thin(rules_dir = RULES_SOURCE, scope = null) {
+export function build_thin(rules_dir = RULES_SOURCE, scope = null, 
+/**
+ * Optional sink for the D3 diagnostic
+ * (road-to-delivery-for-every-host 2.2).
+ *
+ * An `auto` rule the router gives NO trigger is already kept full-bodied by
+ * `noTrigger` below, which is the substantive protection and predates this
+ * roadmap. What did not exist is any way to SEE it happen: the rule is
+ * silently exempted, so an author who removes a rule's last trigger gets a
+ * silently eager rule and no signal. The line makes the exemption audible.
+ */
+announce = null) {
     const kernel = kernel_ids();
     const noTrigger = no_trigger_ids();
+    const pathOnly = path_only_ids();
     const wsMap = scope !== null ? rule_workspaces_map() : new Map();
     const out = new Map();
     for (const p of _globSortedMd(rules_dir)) {
@@ -202,7 +315,14 @@ export function build_thin(rules_dir = RULES_SOURCE, scope = null) {
         if (!id_in_scope(stem, scope, kernel, wsMap, fm_workspaces(text))) {
             continue; // out of workspace scope — no body, no pointer line
         }
-        const full = kernel.has(stem) || noTrigger.has(stem);
+        const full = kernel.has(stem) || noTrigger.has(stem) || pathOnly.has(stem);
+        if (announce !== null && noTrigger.has(stem) && !kernel.has(stem)) {
+            announce(`D3: trigger-less auto rule ${path.basename(p)} — kept full-bodied, never thinned`);
+        }
+        if (announce !== null && pathOnly.has(stem) && !kernel.has(stem) && !noTrigger.has(stem)) {
+            announce(`E2: path-only auto rule ${path.basename(p)} — kept full-bodied; its only triggers ` +
+                `are path-shaped and the delivery concern is not bound on pre_tool_use`);
+        }
         out.set(path.basename(p), full ? text : thin_entry(stem, text));
     }
     return out;

package/dist/server/schemas/settings.js

@@ -29,7 +29,8 @@ const confidenceBand = z.enum(['off', 'low', 'medium', 'high']);
 const onBlock = z.enum(['stop', 'ask', 'warn']);
 const onBlockFallback = z.enum(['stop', 'warn']);
 const modelAutoSwitch = z.enum(['auto', 'suggest', 'off']);
-const leanProjectionMode = z.enum(['eager-all', 'thin']);
+const leanProjectionMode = z.enum(['eager-all', 'thin', 'delivery']);
+const leanProjectionHost = z.enum(['claude-code', 'cursor', 'cline']);
 const projectionMode = z.enum(['legacy-all', 'scoped']);
 const memoryCadence = z.enum(['auto', 'always', 'never']);
 const projectAudience = z.enum(['self', 'internal', 'client', 'public']);
@@ -46,8 +47,16 @@ export const settingsSchema = z.object({
     rule_loading_tier: ruleLoadingTier.default('balanced').describe('Master switch for which rule tiers load and how cautiously the agent spends tokens. minimal = only the 9 kernel rules (cheapest, fewest guardrails). balanced = kernel + tier-1 (recommended default). full = kernel + tier-1 + tier-2 (most guardrails, highest token cost). custom = roll your own in agents/overrides/. LEGACY: superseded by discipline_profile — when that key is set it wins (mapping: minimal→off, balanced→essential, full→full).'),
     discipline_profile: disciplineProfile.optional().describe('The ONE runtime knob for the discipline-rule tier (successor of rule_loading_tier; council 2026-07-07). off = kernel only (~1x tokens). essential = kernel + the measured lift-carrying rules (~3.3x, keeps the weak-host discipline lift). full = everything (~11.7x, EXPERIMENTAL — residual lift over essential not established). auto = resolve per session against the evidence-gated NULL-lift disable-list in src/config/host-capabilities.yml (measured-null host → off, otherwise → essential). Optional and opt-in until the P1/P2 evidence gates pass (agents/roadmaps/road-to-discipline-profile-tiering.md); absent = legacy rule_loading_tier applies.'),
     lean_projection: z.object({
-        mode: leanProjectionMode.default('eager-all').describe('How the per-tool projector emits the rule layer. eager-all = every rule body inlined into every projection (default, safe). thin = kernel rules full-bodied + non-kernel rules as router-resolved pointers (~45k GPT-tok lighter per session). EXPERIMENTAL: validate with the live A/B before flipping; one-flip revert to eager-all.'),
-    }).default({ mode: 'eager-all' }),
+        mode: leanProjectionMode.default('eager-all').describe('How the per-tool projector emits the rule layer. eager-all = every rule body inlined into every projection (safe; what an ABSENT key still resolves to, per ADR-267 decision point 4). thin = kernel rules full-bodied + non-kernel rules as router-resolved pointers (~45k GPT-tok lighter per session), with no delivery mechanism. delivery = thin stubs PLUS the rule-inject hook concern, which delivers a body back on a trigger match; this is the value the SHIPPED TEMPLATE carries for Claude Code since ADR-267, and the activation charge for it is paid in src/config/hook-token-budget.json (user_prompt_submit slot sum 4,096 -> 16,384).'),
+        hosts: z.array(leanProjectionHost).default(['claude-code']).describe('Which hosts a thinning mode may thin (ADR-267). Absent resolves to [claude-code]. '
+            + 'Only the three hosts with a per-rule rule tree are accepted, and this enum is the '
+            + 'AUTHORING layer: an id outside it is a hard validation FAILURE here and under '
+            + 'validate_agent_settings, never a warning. resolveLeanProjectionHosts is the '
+            + 'READ-TIME backstop for a hand-edited .agent-settings.yml that passed neither, and '
+            + 'THERE the id is dropped with a warning (R2 finding 6 — the two layers answer '
+            + 'differently and neither said so). Every host outside this list receives exactly '
+            + 'what eager-all writes, asserted byte-for-byte by check_host_tree_parity.'),
+    }).default({ mode: 'eager-all', hosts: ['claude-code'] }),
     cost: z.object({
         budgets: z.object({
             daily: z.number().min(0).default(0).describe('Daily USD ceiling across all model calls. The agent warns at 50% / 75% / 90% and either stops or warns at 100% depending on cost.enforcement. Set 0 to disable the daily budget entirely.'),
@@ -229,6 +238,10 @@ export const settingsSchema = z.object({
             api_paths: z.array(z.string()).default([]).describe('Optional glob list that makes API-endpoint detection explicit instead of heuristic (e.g. ["app/Http/Controllers/Api/**", "src/pages/api/**"]). Empty (default) = a light path/extension heuristic that fails open.'),
         }),
     }),
+    continuity: z.object({
+        auto_record: z.enum(['on', 'off']).default('off').describe('Deterministic continuity-record writer at session end (road-to-continuity-writer-activation Phase 1). on = the session-eol concern writes the continuity_record capsule variant on Stop for a substantive session that has claimed a roadmap; every field is computed from on-disk state, with no model spend and no subprocess. off (default) = no automatic record — while session:recycle is still the normal path, a second producer on it before the parity evidence is in would be unverified.'),
+        run_checkpoints: z.enum(['on', 'off']).default('on').describe('Deterministic run-checkpoint production at session end (road-to-continuity-writer-activation Phase 1.4). on (default) = a session above the recycle threshold and inside a running roadmap contract leaves agents/runtime/state/checkpoints/<run>.json, so a killed run resumes from a derived checkpoint rather than from bookkeeping. off = no checkpoint; continuity writing, the recycle advisory and the context-fill surface are unaffected. Default ON because it is the behaviour the tree already had — the switch exists to make the three session-end handlers independently disableable, not to change what ships.'),
+    }),
     memory: z.object({
         cadence: memoryCadence.default('always').describe('Cadence of the 🧠 memory-visibility line after a memory-consulting step. always (default) = show whenever a memory type was asked; auto = show only when 3+ types were consulted (less noise); never = suppress. Distinct from rule_loading_tier — owns its own key since the 2026-06-01 untangle.'),
         review_threshold: z.number().int().min(0).default(10).describe('Maximum number of memory entries /memory:load surfaces inline before falling back to a summary view. Default 10 keeps the chat readable. Raise to see more candidates, lower to keep the context tight.'),

package/docs/MIGRATION.md

@@ -17,7 +17,7 @@ releaser here on every `release:major`.
 | Surface | Committed | Deprecation notice due | Removal due | Reversal condition |
 |---|---|---|---|---|
 | Free-text `compatibility` skill-frontmatter field (`src/scripts/schemas/skill.schema.json`) | 2026-08-14 | shipped 2026-08-14 — `deprecated: true` + superseded-by note in the schema; `harness_compat` lands beside it, additively | next major after the notice — **not pinned here** (removal date is maintainer-owned, same stance as the manifest `tier` entry, whose `sunset` shipped `null`) | The public Agent-Skills spec makes `compatibility` load-bearing for cross-host portability, or an external consumer is found reading it. `harness_compat` is package-local; `compatibility` mirrors the public spec, so keeping the mirror stays cheaply reversible. Superseded by `harness_compat` (class) + `runtime_requires` (probeable detail); both users (`docx-authoring`, `pdf-tools`) already carry both fields, so nothing breaks on removal day. |
-| `code_graph` native code-graph engine (`code_graph.enabled`, the `code-intelligence` skill's native arm, `code_graph_nudge_hook`) | 2026-07-28 | next major after 9.x | **REVISED 2026-08-15 — no removal date; see below** | A consumer case the graph answers and disciplined grep cannot. Measured null: recall 0.365 vs grep 0.797 (`docs/CLAIMS.md` `code-graph-retrieval-null`), measured 2026-07-28 against a build predating the 2026-08-22 extractor repair. `enabled: false` stays the DEFAULT — "permanent" is retracted here on 2026-08-26, because this row's own revision below withdraws the removal commitment and a withdrawn schedule cannot leave a permanence behind it. **Revision (ADR-232 track, maintainer decision 2026-08-15).** The original row committed removal to 11.0; the tree reached 12.0.0 with the runtime paths still registered, i.e. the commitment was missed. Rather than quietly re-dating it, the commitment is withdrawn with its reason recorded, because the measurement changed what removal is worth: **the payload this deprecation existed for has already shipped** — the parser pair (`web-tree-sitter@0.24.7` / `tree-sitter-wasms@0.1.13`, ~51 MB unpacked) moved from `dependencies` to `devDependencies` ahead of schedule, so no consumer installs it. What source removal would still free is ~112 K against a 27 M tree (0.4 %). Against that it costs a breaking change across four consumer-visible surfaces (CLI verb, `code-intelligence` skill, `external-code-graph-interop` rule, `hooks.code_graph.enabled`) plus one surface that is re-plumbing rather than deletion: `_lib/auto_dispatch.ts` routes the `definition` / `references` lookup classes to `primitive: 'code-graph-query'`, and `_lib/judgment_ladder.ts` calls that live at Rung 0. There is also no cheap middle — `code_graph/detect.ts` handles the `consumer` / `scip` / `native` source kinds in one type union, so stripping only the native engine while keeping consumer-index interop is a redesign. **New commitment:** the surfaces stay registered and disabled; removal happens when a concrete reason appears (a maintenance cost that bites, a conflicting redesign, or a consumer asking), not on a date. This row stays in the table so the decision is visible rather than forgotten — a withdrawn commitment recorded is not the folklore this table exists to prevent; an unrecorded one would be. |
+| `code_graph` native code-graph engine (`code_graph.enabled`, the `code-intelligence` skill's native arm, `code_graph_nudge_hook`) | 2026-07-28 | next major after 9.x | **REVISED 2026-08-15 — no removal date; see below** | A consumer case the graph answers and disciplined grep cannot. Measured null: recall 0.365 vs grep 0.797 (`docs/CLAIMS.md` `code-graph-retrieval-null`), measured 2026-07-28 against a build predating the 2026-08-22 extractor repair. `enabled: false` stays the DEFAULT — "permanent" is retracted here on 2026-08-26, because this row's own revision below withdraws the removal commitment and a withdrawn schedule cannot leave a permanence behind it. **Revision (ADR-232 track, maintainer decision 2026-08-15).** The original row committed removal to 11.0; the tree reached 12.0.0 with the runtime paths still registered, i.e. the commitment was missed. Rather than quietly re-dating it, the commitment is withdrawn with its reason recorded, because the measurement changed what removal is worth: **the payload this deprecation existed for has already shipped** — the parser pair (`web-tree-sitter@0.24.7` / `tree-sitter-wasms@0.1.13`, ~51 MB unpacked) moved from `dependencies` to `devDependencies` ahead of schedule, so no consumer installed it. **REVERSED 2026-09-07 by ADR-259 (as amended) — this clause no longer holds and is kept only so the reversal is legible.** Delivery and measurement are decoupled: `web-tree-sitter` is a runtime `dependency` again and the three loadable grammars are vendored at `src/vendor/grammars/`, so a consumer now DOES install the engine. The measured null above is untouched and `enabled: false` stays the default — what changed is that the reopen trigger ("a consumer case the graph answers") became reachable at all, which it was not while no consumer could receive the engine. The install delta is recorded below under "14.21.x — the code-graph engine ships to consumers". What source removal would still free is ~112 K against a 27 M tree (0.4 %). Against that it costs a breaking change across four consumer-visible surfaces (CLI verb, `code-intelligence` skill, `external-code-graph-interop` rule, `hooks.code_graph.enabled`) plus one surface that is re-plumbing rather than deletion: `_lib/auto_dispatch.ts` routes the `definition` / `references` lookup classes to `primitive: 'code-graph-query'`, and `_lib/judgment_ladder.ts` calls that live at Rung 0. There is also no cheap middle — `code_graph/detect.ts` handles the `consumer` / `scip` / `native` source kinds in one type union, so stripping only the native engine while keeping consumer-index interop is a redesign. **New commitment:** the surfaces stay registered and disabled; removal happens when a concrete reason appears (a maintenance cost that bites, a conflicting redesign, or a consumer asking), not on a date. This row stays in the table so the decision is visible rather than forgotten — a withdrawn commitment recorded is not the folklore this table exists to prevent; an unrecorded one would be. |
 | `telegraph-speak` condenser (`telegraph.speak`, `src/rules/telegraph-speak.md`, `src/scripts/_lib/compile_time_toggles.ts`, `src/scripts/validate_telegraph_carveouts.ts`) | 2026-07-29 | shipped 2026-07-29 — dormant by default, `speak` defaults `false` | **not pinned here** — removal is authorized in principle and deliberately not executed (ADR `telegraph/0002` § Decision part 3), pending a `prose_only` bench (~$0.80). The date is maintainer-owned, same stance as the `compatibility` row above | An output-side bench clears the kill-criterion bar, at which point `telegraph.speak: true` restores the feature intact. Measured basis for dormancy: median vs_terse **−9.27 %** (API) / −5.47 % (exact `cl100k_base`) — the condenser emits MORE than a plain "be terse". Tracked as a row rather than left dormant-and-unlisted: dormancy without a row is untracked in *both* directions, neither scheduled nor recorded as a keep. Deliberately NOT a due version (that would invent a commitment ADR 0002 declined to make) and NOT a permanent keep (that would contradict its authorized removal). |
 
 ### Row status — what is currently late, and who owns it
@@ -42,6 +42,110 @@ reason, which no arithmetic can.
 or that promises a future breaking removal, gets a row here in the same commit
 that makes the promise. A promise with no row is not tracked and will be missed.
 
+## 14.22.x — the code-graph engine gets readers, and the MCP install hint changes
+
+💡 advisory · 🔄 automatic — **one exception, below.**
+
+The 14.21.x entry above shipped the engine to consumers. This one ships the
+things that read it (`road-to-a-graph-that-is-shipped`, Phases 3 and 4).
+
+### Additive — nothing to do
+
+- **Four new `code-graph` subcommands**, all answering questions about a DIFF
+  rather than a symbol: `impact --diff <rev>`, `tests-for <symbol>`,
+  `untested --diff <rev>`, `dead`. Each prints the resolution mechanisms it
+  accepted, the mechanisms it refused, and the graph's three-state staleness.
+  No existing subcommand changed, and no new top-level verb was added.
+- **Five new MCP tools** on the existing stdio server — `graph_impact`,
+  `graph_tests_for`, `graph_dead`, `graph_query`, `graph_path` — taking the
+  catalogue from 31 tools to 36. Four are read-only; `graph_impact` runs
+  `git diff --name-only` to resolve its rev and declares `side_effect: shell`
+  for that reason.
+- **A new `tests` edge relation**, derived in the build pass from a test file's
+  imports. `SCHEMA_VERSION` 3 → 4 and `GRAPH_STORE_VERSION` 3 → 4, so an
+  existing cache and its SQLite twin are refused and rebuilt on the next
+  `code-graph build`. The cache is derived and disposable
+  (ADR-129) — there is nothing to migrate, and a rebuild takes seconds.
+
+### The one thing to check — `dead` refuses by default
+
+`agent-config code-graph dead` exits **1** with an empty list unless you either
+supply an entry-point list (`--entry-points <file>`) or accept the gap
+(`--accept-missing-exports`). That is deliberate: this engine records no
+exportedness, so without a supplied list an exported-but-not-yet-imported public
+symbol is indistinguishable from a dead one, and a confident false "dead" invites
+a deletion the graph cannot justify. If you wire `dead` into a script, handle the
+refusal — an exit 1 here is not a crash, and treating it as an empty dead list
+is the false negative the refusal exists to prevent.
+
+### One consumer-visible string changed
+
+`install_hint_stdio` in the published MCP tool catalogue was
+`npx -y @event4u/agent-config mcp-server` and is now **`agent-config mcp-server`**
+— the installed-binary form the setup docs already lead with. It resolves no
+dist-tag, so the server you run is the version you installed rather than
+whatever the registry served most recently. **It assumes `agent-config` is on
+PATH.** If you read that field programmatically and rely on `npx`, keep using
+the pinned form from [`mcp-server.md`](mcp-server.md) —
+`npx -y @event4u/agent-config@<version> mcp-server` — which is unchanged and
+still the documented client configuration.
+
+### Standing context cost
+
+Registering the stdio MCP server now costs **4,876 tokens** of standing context
+per session, up from 3,886 — the five graph tools measure 993 between them. It
+remains roughly 4x under the ~20,000-token Tool Search deferral threshold at a
+200k window, so the surface still loads upfront. Measured, with the prior reading
+kept: `agents/evidence/metrics/mcp-tool-standing-cost.jsonl`.
+
+## 14.21.x — the code-graph engine ships to consumers
+
+💡 advisory · 🔄 automatic — no action required.
+
+`npm install @event4u/agent-config` now carries everything the native
+code-graph engine needs, so `agent-config code-graph build` works on the next
+command with no manual parser install (ADR-259, as amended 2026-09-07).
+
+### What changed
+
+- `web-tree-sitter@0.24.7` moved from `devDependencies` to `dependencies`.
+- Three compiled tree-sitter grammars are **vendored** in the published tarball
+  at `src/vendor/grammars/` — php, typescript (which also serves `.tsx`), and
+  javascript. These are the three `GRAMMAR_WASM` entries the engine can load.
+- `tree-sitter-wasms` stays a `devDependency`. It is the source the vendored
+  copies are refreshed from, not a runtime dependency, so consumers do **not**
+  receive the 36-grammar pack.
+
+### Install delta, measured
+
+Measured on 2026-09-07 with `npm pack --dry-run --json --ignore-scripts`,
+against the same tree with the vendored directory excluded from `files[]`:
+
+| Axis | Before | After | Delta |
+|---|---|---|---|
+| Compressed tarball | 9,821,600 B | 10,195,522 B | **+373,922 B** (+0.357 MiB) |
+| Vendored grammars, on disk | 0 B | 3,802,618 B | **+3,802,618 B** (+3.63 MiB) |
+| `web-tree-sitter` in `node_modules` | 0 B (dev-only) | ~389,120 B | **+~380 KiB** |
+
+Per-grammar, uncompressed: `tree-sitter-php.wasm` 812,594 B ·
+`tree-sitter-typescript.wasm` 2,342,690 B · `tree-sitter-javascript.wasm`
+647,334 B.
+
+For contrast, the two rejected shapes: depending on `tree-sitter-wasms`
+directly would have delivered all 36 grammars (51,765,657 B apparent, 49 MiB on
+disk), and the 13-grammar set ADR-259 originally named measures 9,085,798 B
+apparent / 1,016,804 B compressed — the latter would have put the tarball at
+~10.84 MB. Only three grammars are loadable today, so the other ten would have
+been payload with no reader.
+
+### Rolling back
+
+Set `hooks.code_graph.enabled: false` — which is already the default; the
+engine ships disabled. Nothing runs the parsers unless you build a graph. To
+drop the payload entirely, remove `src/vendor/grammars/` from `files[]` and
+move `web-tree-sitter` back to `devDependencies`; the loader falls back to the
+`tree-sitter-wasms` pack, which is this repository's own dev path.
+
 ## 8.x → 9.0.0 — consumer rule projection scoped by default
 
 9.0.0 flips the consumer rule-projection default to **scoped**: fresh