@event4u/agent-config 14.6.0 → 14.8.0

package/dist/scripts/condense.js

@@ -227,7 +227,13 @@ function _stripChars(s, chars) {
 // module-level CLI self-invoke into its bundle. Re-exported here because four
 // in-repo consumers import it from `condense.js`.
 export { rule_in_scope } from '../install/ruleInScope.js';
+// Re-exported for in-repo consumers; definitions moved beside emit_host_rules_cli.ts (Phase 5).
+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 { dedupableRules, partitionRulesForDir } from '../install/ruleLayerPartition.js'; // ADR-236, per-host evidence
+import { _claude_paths_plan, 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) {
@@ -256,6 +262,7 @@ 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,
@@ -361,14 +368,6 @@ function _read_augment_rules_use_symlinks() {
     }
     return false;
 }
-/**
- * Per-tool user-scope rule directory, for the scope-dedup below. Only tools
- * whose host reads a user-scope rules directory can have a redundant twin;
- * everything else has nothing to de-duplicate against.
- */
-const USER_SCOPE_RULE_DIRS = {
-    '.claude/rules': path.join('.claude', 'rules'),
-};
 function _read_projection_scope_dedup() {
     const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
     const projection = data['projection'];
@@ -384,63 +383,6 @@ function _read_projection_scope_dedup() {
     }
     return false;
 }
-/**
- * Rules whose user-scope twin is BYTE-IDENTICAL to the source, i.e. safe to
- * skip at project scope: the host still loads the same text, once instead of
- * twice, so nothing the model sees changes.
- *
- * Byte-identity is the whole safety argument and is not negotiable. Keying on
- * the filename alone would silently let a stale globally-installed copy win
- * whenever the two scopes hold different versions — which is the NORMAL state
- * while developing the package (measured: 110/110 shared filenames differing in
- * bytes). This is deliberately not the thin-projection mechanism: no rule
- * becomes trigger-gated, so the quality floor that disabled thin projection
- * does not apply here.
- */
-function _dedupable_rules(tool_dir, rules, userHome) {
-    const relative = USER_SCOPE_RULE_DIRS[tool_dir];
-    if (relative === undefined) {
-        return new Set();
-    }
-    // A hostile or simply absent $HOME must make the dedup inert, not
-    // adventurous. In a container `$HOME` is often unset (so `homedir()` can
-    // resolve to `/`) or world-writable, and this function decides which rules
-    // to STOP emitting — reading an unexpected tree there is how a projection
-    // silently loses a rule. Council review of PR #1055 raised exactly this.
-    let userDirStat;
-    const userDir = path.join(userHome, relative);
-    try {
-        userDirStat = fs.statSync(userDir);
-    }
-    catch {
-        return new Set();
-    }
-    if (!userDirStat.isDirectory()) {
-        return new Set();
-    }
-    // World-writable user scope: anyone on the box could plant a byte-identical
-    // twin and thereby delete a rule from the project projection. Refuse.
-    if ((userDirStat.mode & 0o002) !== 0) {
-        _print(`  ⚠️  ${tool_dir}: user-scope rules dir is world-writable — scope-dedup skipped`);
-        return new Set();
-    }
-    const skip = new Set();
-    for (const rule of rules) {
-        const twin = path.join(userDir, rule);
-        const source = path.join(MODULE_STATE.RULES_SOURCE, rule);
-        try {
-            if (!_isFile(twin) || !_isFile(source))
-                continue;
-            if (fs.readFileSync(twin).equals(fs.readFileSync(source))) {
-                skip.add(rule);
-            }
-        }
-        catch {
-            // An unreadable twin is simply not de-duplicable — emit the project copy.
-        }
-    }
-    return skip;
-}
 function _lean_projection_mode() {
     const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
     const lean = data['lean_projection'];
@@ -1007,6 +949,13 @@ function _scoped_rule_basenames() {
         .map((p) => path.basename(p))
         .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
 }
+/** Adapter over {@link partitionRulesForDir}; that module carries the reasoning. */
+export function partition_rules_for_dir(tool_dir, rules, user_home = process.env['HOME'] ?? os.homedir()) {
+    return partitionRulesForDir({
+        toolDir: tool_dir, rules, userHome: user_home, announce: _print,
+        projectRoot: MODULE_STATE.PROJECT_ROOT, rulesSource: MODULE_STATE.RULES_SOURCE,
+    });
+}
 /**
  * The emit plan of {@link generate_rule_symlinks}: active tool dir → the exact
  * rule basenames it projects there.
@@ -1029,8 +978,12 @@ export function projected_rule_trees(user_home = process.env['HOME'] ?? os.homed
     const dedup_on = _read_projection_scope_dedup();
     const out = {};
     for (const tool_dir of Object.keys(_filter_tool_dirs(TOOL_DIRS))) {
-        const skip = dedup_on ? _dedupable_rules(tool_dir, rules, user_home) : new Set();
-        out[tool_dir] = rules.filter((r) => !skip.has(r));
+        const skip = dedup_on
+            ? dedupableRules({ toolDir: tool_dir, rules, userHome: user_home,
+                rulesSource: MODULE_STATE.RULES_SOURCE, announce: _print })
+            : new Set();
+        const kept = rules.filter((r) => !skip.has(r));
+        out[tool_dir] = partition_rules_for_dir(tool_dir, kept, user_home);
     }
     return out;
 }
@@ -1137,7 +1090,10 @@ export function generate_rule_symlinks() {
     return total;
 }
 export function generate_windsurfrules() {
-    const rules = _scoped_rule_basenames();
+    // Windsurf's LEGACY single-file surface — same host, so the same evidence, keyed
+    // 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);
@@ -1188,34 +1144,6 @@ export function _parse_frontmatter(content) {
 function _yaml_scalar(value) {
     return JSON.stringify(value);
 }
-/**
- * Derive host-native activation globs from a rule's `triggers:` frontmatter
- * (road-to-request-scoped-rule-load Phase 2). `file_pattern` triggers map
- * verbatim; `path_prefix` triggers map to `<prefix>**`. Keyword / phrase /
- * command triggers produce no glob — those rules stay
- * description-activated (Cursor Agent-Requested / Windsurf model_decision).
- */
-export function derive_trigger_globs(meta) {
-    const triggers = meta['triggers'];
-    if (!Array.isArray(triggers)) {
-        return [];
-    }
-    const globs = [];
-    for (const t of triggers) {
-        if (t === null || typeof t !== 'object' || Array.isArray(t))
-            continue;
-        const obj = t;
-        if (typeof obj['file_pattern'] === 'string' && obj['file_pattern']) {
-            globs.push(obj['file_pattern']);
-        }
-        else if (typeof obj['path_prefix'] === 'string' && obj['path_prefix']) {
-            const prefix = obj['path_prefix'];
-            globs.push(prefix.endsWith('/') ? `${prefix}**` : `${prefix}**`);
-        }
-    }
-    // De-dup, keep declaration order (deterministic output).
-    return [...new Set(globs)];
-}
 export function _emit_cursor_mdc(source, target) {
     const [meta, body] = _parse_frontmatter(_readText(source));
     const description = _strip(String(meta['description'] ?? '').replace(/\n/g, ' '));
@@ -1255,141 +1183,6 @@ export function _emit_windsurf_rule(source, target) {
     _mkdirp(path.dirname(target));
     _writeText(target, lines.join('\n'));
 }
-/**
- * A brace group the host expands, versus an agent-config placeholder that only
- * LOOKS like one.
- *
- * `path_prefix: "{module_root}/"` in `roadmap-ci-steps-policy` is resolved by
- * this suite from `modules.root_paths`. Emitted verbatim into a host `paths:`
- * list it is a brace group with no comma, which the host expands to the literal
- * string `{module_root}` — a pattern that matches no file. The rule would then
- * reach the model **never** instead of on-demand, and nothing would say so: the
- * probed contract records this exact degradation as silent
- * (`claude-code-rules-dir-contract.md` § constraints).
- *
- * Dropping the pattern is fail-safe in the one direction that matters. A rule
- * left with no pattern at all carries no `paths:` key and loads
- * unconditionally — the status quo, not a regression. A rule carrying a
- * no-op pattern is invisible.
- *
- * The discriminator is the comma, not a placeholder allowlist: `{ts,tsx}` is a
- * real alternation, `{module_root}` cannot be one.
- */
-export function _is_unresolved_placeholder(pattern) {
-    for (const m of pattern.matchAll(/\{([^}]*)\}/g)) {
-        if (!m[1].includes(',')) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * `[` opens a bracket expression for the host. An unparseable one makes that
- * pattern match nothing while the rule's other patterns keep working — so a
- * literal `[` in a trigger is escaped rather than trusted.
- */
-export function _escape_claude_bracket(pattern) {
-    return pattern.replace(/\[/g, '\\[');
-}
-/**
- * Expanded-pattern cost of one glob: the product of its brace alternations.
- * The host budgets a rule's whole `paths:` list at 1,000 expanded patterns and
- * 4 MiB, and a list over budget is used UNEXPANDED — braces then match
- * literally, i.e. nothing. Counting keeps the emitter under the cliff instead
- * of discovering it as a silent no-op.
- */
-export function _expanded_pattern_count(pattern) {
-    let n = 1;
-    for (const m of pattern.matchAll(/\{([^}]*)\}/g)) {
-        n *= m[1].split(',').length;
-    }
-    return n;
-}
-/** Host-documented budget for one rule's whole `paths:` list. */
-export const CLAUDE_PATHS_PATTERN_BUDGET = 1000;
-/**
- * Does this rule declare any trigger that is NOT path-shaped?
- *
- * Load-bearing for `_claude_paths_plan` below, because one `triggers:` list
- * means two different things on two hosts. Cursor and Windsurf treat globs as
- * ADDITIVE — a rule with empty globs still reaches the agent through its
- * description (see `_emit_cursor_mdc`'s own comment). Claude Code treats
- * `paths:` as EXCLUSIVE: with it the rule loads on a path match; without it the
- * rule loads unconditionally. The emitter fed both semantics from one list, so
- * a rule that declared keywords *and* one path glob silently became
- * path-gated-only on Claude.
- */
-export function _has_non_path_trigger(meta) {
-    const triggers = meta['triggers'];
-    if (!Array.isArray(triggers))
-        return false;
-    for (const t of triggers) {
-        if (t === null || typeof t !== 'object' || Array.isArray(t))
-            continue;
-        const obj = t;
-        if (typeof obj['keyword'] === 'string' && obj['keyword'])
-            return true;
-        if (typeof obj['phrase'] === 'string' && obj['phrase'])
-            return true;
-    }
-    return false;
-}
-/**
- * Derive the host's `paths:` list for one rule, with every drop recorded.
- *
- * Kernel / always-apply rules get an EMPTY list on purpose: absent `paths:` is
- * how this host says "load unconditionally", which is exactly what an Iron-Law
- * rule needs. Scoping one would be a correctness regression dressed as a byte
- * saving — and the same contract notes path-scoped rules are not re-injected
- * after `/compact`, so an obligation that must survive compaction cannot be
- * path-scoped at all.
- */
-export function _claude_paths_plan(meta) {
-    const always_apply = Boolean(meta['alwaysApply'] || meta['type'] === 'always');
-    if (always_apply) {
-        return { globs: [], dropped: [] };
-    }
-    const globs = [];
-    const dropped = [];
-    // A rule that ALSO declares keyword / phrase triggers gets no `paths:` at
-    // all, and therefore keeps loading unconditionally on Claude Code.
-    //
-    // Emitting `paths:` here would narrow the rule to a path match and discard
-    // every keyword the author wrote, because this host reads the list as the
-    // whole gate rather than as one way in. Measured before this guard: 25 of
-    // 110 projected rules carried `paths:` and 19 of them also carried keyword
-    // triggers — `design-fidelity` lost 21 of them, in exactly the pasted-
-    // screenshot and capability-URL handovers its own routing section names as
-    // the classes it exists to catch. Nothing in the tree recorded a decision
-    // to make that trade, which is why it is treated as a defect.
-    //
-    // The drop is REPORTED rather than silent, so a rule whose obligation
-    // really is path-bound is visible as a candidate for removing its keyword
-    // triggers — the narrowing then becomes an authoring decision instead of an
-    // emitter side effect. Cursor and Windsurf are untouched: globs are
-    // additive there, so the same rule keeps both routes.
-    if (_has_non_path_trigger(meta)) {
-        for (const raw of derive_trigger_globs(meta)) {
-            dropped.push({ pattern: raw, reason: 'mixed-triggers' });
-        }
-        return { globs, dropped };
-    }
-    let spent = 0;
-    for (const raw of derive_trigger_globs(meta)) {
-        if (_is_unresolved_placeholder(raw)) {
-            dropped.push({ pattern: raw, reason: 'unresolved-placeholder' });
-            continue;
-        }
-        const cost = _expanded_pattern_count(raw);
-        if (spent + cost > CLAUDE_PATHS_PATTERN_BUDGET) {
-            dropped.push({ pattern: raw, reason: 'over-budget' });
-            continue;
-        }
-        spent += cost;
-        globs.push(_escape_claude_bracket(raw));
-    }
-    return { globs, dropped };
-}
 /**
  * Emit a Claude Code rule carrying the host's OWN activation key.
  *
@@ -1455,12 +1248,16 @@ function _clean_modern_dir(target_dir, valid_names) {
 export function generate_cursor_mdc_rules() {
     const scope = _read_rule_workspaces();
     const pack_scope = _read_rule_packs();
-    const rules = _rglobSorted(MODULE_STATE.RULES_SOURCE, '*.md')
+    let rules = _rglobSorted(MODULE_STATE.RULES_SOURCE, '*.md')
         .filter((p) => _isFile(p))
         .filter((p) => rule_in_scope(p, scope, pack_scope))
         // ADR-004 manual rules are reference-only — never auto-injected into a
         // per-tool tree. Same predicate as generate_rule_symlinks.
         .filter((p) => !_is_manual_rule(p));
+    // ADR-236 per-host partition (src/install/ruleLayerPartition.ts). Narrowing the
+    // list is a REMOVAL, because `_clean_modern_dir` below sweeps to `valid`.
+    const kept = new Set(partition_rules_for_dir('.cursor/rules', rules.map((r) => path.basename(r))));
+    rules = rules.filter((r) => kept.has(path.basename(r)));
     const stems = rules.map((r) => path.basename(r, '.md'));
     const valid = new Set([
         ...stems.map((s) => `${s}.mdc`),
@@ -1476,12 +1273,15 @@ export function generate_cursor_mdc_rules() {
 export function generate_windsurf_modern_rules() {
     const scope = _read_rule_workspaces();
     const pack_scope = _read_rule_packs();
-    const rules = _rglobSorted(MODULE_STATE.RULES_SOURCE, '*.md')
+    let rules = _rglobSorted(MODULE_STATE.RULES_SOURCE, '*.md')
         .filter((p) => _isFile(p))
         .filter((p) => rule_in_scope(p, scope, pack_scope))
         // ADR-004 manual rules are reference-only — never auto-injected into a
         // per-tool tree. Same predicate as generate_rule_symlinks.
         .filter((p) => !_is_manual_rule(p));
+    // ADR-236 per-host partition — same shape as the cursor emitter above.
+    const kept = new Set(partition_rules_for_dir('.windsurf/rules', rules.map((r) => path.basename(r))));
+    rules = rules.filter((r) => kept.has(path.basename(r)));
     const valid = new Set(rules.map((r) => path.basename(r)));
     _clean_modern_dir(_WINDSURF_RULES_DIR(), valid);
     for (const rule of rules) {
@@ -1652,6 +1452,8 @@ 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;
@@ -1664,7 +1466,9 @@ export function generate_claude_skills(active_skill_names = null) {
         skills = skills.filter((s) => active_skill_names.has(s));
     }
     const skill_set = new Set(skills);
-    const command_slugs = new Set([...iterCommands()].map(([, slug]) => slug));
+    const command_slugs = partitionActive(MODULE_STATE.PROJECT_ROOT)
+        ? new Set()
+        : new Set([...iterCommands()].map(([, slug]) => slug));
     _mkdirp(MODULE_STATE.CLAUDE_SKILLS_DIR);
     const auto = _read_model_auto_switch() === 'auto';
     for (const item of _iterdirSorted(MODULE_STATE.CLAUDE_SKILLS_DIR)) {
@@ -1752,23 +1556,24 @@ function _nested_command_subpath(source_file) {
 /**
  * Project-scope `.claude/commands/<cluster>/<sub>.md` — the colon form.
  *
- * Before this, the package repo's own `.claude/` carried NO commands
- * directory: every command reached Claude Code as a hyphen-named skill
- * wrapper in `.claude/skills/`, while the colon form existed only in the
- * user-global tree written by `install.ts`. Every clustered command was
- * therefore listed TWICE for anyone with a global install
- * (`roadmap-process-full` AND `roadmap:process-full`), costing 4,214 GPT tok
- * of always-loaded catalog for zero added reach — measured 2026-08-02.
+ * Before this, the package repo's own `.claude/` carried NO commands directory:
+ * every command reached Claude Code as a hyphen-named skill wrapper in
+ * `.claude/skills/`, while the colon form existed only in the user-global tree
+ * written by `install.ts`. Every clustered command was therefore listed TWICE
+ * for anyone with a global install (`roadmap-process-full` AND
+ * `roadmap:process-full`), costing 4,214 GPT tok of catalog — measured 2026-08-02.
  *
  * 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 having run. Claude Code dedupes project
- * and user scope by name, so the two copies of `/cluster:sub` collapse.
+ * longer depends on a global deploy. Dedup AND precedence: `commandsWithheld`.
  *
  * 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;
     }
@@ -1784,8 +1589,7 @@ export function generate_claude_project_commands(active_command_slugs = null) {
     }
     const target_root = _CLAUDE_COMMANDS_DIR();
     const valid = new Set(nested.map(([, sub]) => `${sub}.md`));
-    // Sweep stale links first: a renamed or deleted command must not linger as
-    // a dangling `/cluster:sub`.
+    // Sweep stale links first — a renamed, deleted or WITHHELD command must not linger.
     if (_exists(target_root)) {
         for (const item of _rglobSorted(target_root, '*.md')) {
             const rel = _relativeToPosix(item, target_root);
@@ -1793,6 +1597,7 @@ export function generate_claude_project_commands(active_command_slugs = null) {
                 fs.unlinkSync(item);
             }
         }
+        pruneEmptyDirs(target_root); // else the gate counts 40 empty cluster dirs as 40 commands
     }
     let count = 0;
     for (const [source_file, sub] of nested) {
@@ -1812,6 +1617,8 @@ 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;
@@ -2228,7 +2035,7 @@ export function generate_persona_symlinks() {
         .map((p) => path.basename(p))
         .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
     void personas;
-    const list = direct;
+    const partition = personaPartition(MODULE_STATE.PROJECT_ROOT, direct);
     const tool_dirs = _filter_tool_dirs(PERSONA_TOOL_DIRS);
     let total = 0;
     for (const [tool_dir, rel_prefix] of Object.entries(tool_dirs)) {
@@ -2236,11 +2043,11 @@ export function generate_persona_symlinks() {
         _mkdirp(target_dir);
         for (const item of _iterdirSorted(target_dir)) {
             const name = path.basename(item);
-            if (_isSymlink(item) && !list.includes(name) && name !== 'README.md') {
+            if (_isSymlink(item) && !partition.listFor(tool_dir).includes(name) && name !== 'README.md') {
                 fs.unlinkSync(item);
             }
         }
-        for (const persona of list) {
+        for (const persona of partition.listFor(tool_dir)) {
             const link = path.join(target_dir, persona);
             const target = path.join(rel_prefix, persona);
             if (_existsOrSymlink(link)) {
@@ -2250,7 +2057,8 @@ export function generate_persona_symlinks() {
             total += 1;
         }
     }
-    info(`  ✅  Created ${total} persona symlinks across ${Object.keys(tool_dirs).length} tool directories (${list.length} personas each)`);
+    const per_dir = Object.keys(tool_dirs).map((d) => `${d}=${partition.countFor(d)}`);
+    info(`  ✅  Created ${total} persona symlinks — ${per_dir.join(' · ')}${partition.note}`);
     return total;
 }
 export function generate_user_type_symlinks() {
@@ -2423,10 +2231,14 @@ export function project_to_augment() {
     const current = new Set();
     let written = 0;
     if (_exists(src_rules)) {
-        const rules = _iterdirSorted(src_rules)
+        // ADR-236 per-host partition, ahead of the `use_symlinks` branch so both
+        // writers narrow; the `existing` minus `current` sweep below makes it a
+        // removal. This emitter never had the scope or ADR-004 manual filters
+        // either — why its count is 15 and the symlink trees' 13. Pre-existing.
+        const rules = partition_rules_for_dir('.augment/rules', _iterdirSorted(src_rules)
             .filter((p) => p.endsWith('.md') && _isFile(p))
             .map((p) => path.basename(p))
-            .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+            .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)));
         for (const rule of rules) {
             const target = path.join(dst_rules, rule);
             if (_isSymlink(target) || _existsOrSymlink(target)) {