@event4u/agent-config 14.7.0 → 14.8.0

package/dist/scripts/_lib/prune_empty_dirs.js

@@ -0,0 +1,85 @@
+/**
+ * Remove empty directories under a root, deepest first.
+ *
+ * ## Why this exists as a shared helper
+ *
+ * A generator that stops writing into a tree leaves the tree's DIRECTORIES
+ * behind. Measured 2026-08-21 while extending the ADR-236 partition to the
+ * colon-form commands: after the generator was gated, `.claude/commands/`
+ * held **0 `.md` files and 40 empty cluster directories** — and
+ * `check_single_delivery` counts directory NAMES, so it still reported 40
+ * overlapping commands against a layer that delivered none. A partition that
+ * stops the writes and leaves the shape is invisible to the gate that is
+ * supposed to confirm it.
+ *
+ * `condense.ts` already carried this loop inline for the skills tree. It is
+ * lifted here rather than copied because the second caller is what turns an
+ * inline block into a shape two producers must agree on — and because
+ * `condense.ts` sits above `check_source_size_budget`'s ceiling, where a
+ * shrink-only ratchet refuses even a small addition.
+ *
+ * Best-effort by construction: a race or a permission error on one directory is
+ * swallowed, matching the inline original. Pruning is cleanup, never a gate.
+ *
+ * ## Symlinks: MEASURED, because a neutral review split on it
+ *
+ * One seat called an unguarded recursion a merge blocker (a directory symlink
+ * pointing at an ancestor would loop forever); the other called the finding
+ * false, on the grounds that `Dirent.isDirectory()` does not follow the target.
+ * A vote cannot settle that, so it was probed — `readdirSync(dir, {withFileTypes:
+ * true})` over a real symlink-to-directory on darwin, Node 26:
+ *
+ *     link  isDirectory=false  isSymbolicLink=true
+ *     real  isDirectory=true   isSymbolicLink=false
+ *
+ * `Dirent` carries `lstat` semantics, so the walk below cannot descend into a
+ * symlink at all and no loop is reachable — and no inode set is needed. The
+ * second seat was right. Recorded rather than fixed, so the next reader does not
+ * re-raise it: a defensive `!e.isSymbolicLink()` here would be dead code
+ * asserting something the type already guarantees.
+ *
+ * The same property is why this is safe on a tree of symlinks: `.claude/commands`
+ * holds symlinks into `src/domains/**`, and pruning must not follow one out of
+ * the tree it was pointed at.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** @returns the number of directories removed. */
+export function pruneEmptyDirs(root) {
+    let removed = 0;
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.isDirectory())
+                walk(path.join(dir, e.name));
+        }
+        try {
+            if (fs.readdirSync(dir).length === 0) {
+                fs.rmdirSync(dir);
+                removed += 1;
+            }
+        }
+        catch {
+            /* race or permission — cleanup is best-effort, mirrors the inline original */
+        }
+    };
+    let top;
+    try {
+        top = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    for (const e of top) {
+        if (e.isDirectory())
+            walk(path.join(root, e.name));
+    }
+    return removed;
+}
+//# sourceMappingURL=prune_empty_dirs.js.map

package/dist/scripts/_lib/prune_empty_dirs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune_empty_dirs.js","sourceRoot":"","sources":["../../../src/scripts/_lib/prune_empty_dirs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,kDAAkD;AAClD,MAAM,UAAU,cAAc,CAAC,IAAY;IACvC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,MAAM,IAAI,GAAG,CAAC,GAAW,EAAQ,EAAE;QAC/B,IAAI,OAAoB,CAAC;QACzB,IAAI,CAAC;YACD,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3D,CAAC;QAAC,MAAM,CAAC;YACL,OAAO;QACX,CAAC;QACD,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACtB,IAAI,CAAC,CAAC,WAAW,EAAE;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACtD,CAAC;QACD,IAAI,CAAC;YACD,IAAI,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACnC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;gBAClB,OAAO,IAAI,CAAC,CAAC;YACjB,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACL,8EAA8E;QAClF,CAAC;IACL,CAAC,CAAC;IACF,IAAI,GAAgB,CAAC;IACrB,IAAI,CAAC;QACD,GAAG,GAAG,EAAE,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACL,OAAO,CAAC,CAAC;IACb,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,CAAC,WAAW,EAAE;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IACvD,CAAC;IACD,OAAO,OAAO,CAAC;AACnB,CAAC"}

package/dist/scripts/condense.js

@@ -230,7 +230,9 @@ 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 { isExclusivelyPackageOnly, partitionActive, setPartitionAnnounce } from '../install/partitionEligibility.js'; // ADR-236
+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, '..', '..');
@@ -366,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'];
@@ -389,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'];
@@ -1009,10 +946,16 @@ function _scoped_rule_basenames() {
         // is its fourth consumer, after the router compiler, the dist writer, and
         // check_sync. Same predicate in all four; that is the point.
         .filter((p) => !skip_compile_disabled_rule(`rules/${path.basename(p)}`))
-        .filter((p) => !partitionActive(MODULE_STATE.PROJECT_ROOT) || isExclusivelyPackageOnly(p))
         .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.
@@ -1035,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;
 }
@@ -1143,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);
@@ -1298,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`),
@@ -1319,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) {
@@ -1599,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;
     }
@@ -1631,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);
@@ -1640,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) {
@@ -2077,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)) {
@@ -2085,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)) {
@@ -2099,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() {
@@ -2272,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)) {