@event4u/agent-config 14.6.0 → 14.8.0

package/src/scripts/condense.ts

@@ -251,7 +251,22 @@ function _stripChars(s: string, chars: string): string {
 // 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,
+    type ClaudePathsPlan,
+} 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, '..', '..');
@@ -304,6 +319,7 @@ function _deriveState(root: string): ModuleState {
 }
 
 export const MODULE_STATE: ModuleState = _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
@@ -425,15 +441,6 @@ function _read_augment_rules_use_symlinks(): boolean {
     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: Readonly<Record<string, string>> = {
-    '.claude/rules': path.join('.claude', 'rules'),
-};
-
 function _read_projection_scope_dedup(): boolean {
     const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
     const projection = data['projection'];
@@ -450,60 +457,6 @@ function _read_projection_scope_dedup(): boolean {
     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: string, rules: readonly string[], userHome: string): Set<string> {
-    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: fs.Stats;
-    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<string>();
-    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(): string {
     const data = load_agent_settings({ project_path: MODULE_STATE.SETTINGS_FILE });
@@ -1122,6 +1075,18 @@ function _scoped_rule_basenames(): string[] {
         .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: string,
+    rules: readonly string[],
+    user_home: string = process.env['HOME'] ?? os.homedir(),
+): string[] {
+    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.
@@ -1146,8 +1111,12 @@ export function projected_rule_trees(
     const dedup_on = _read_projection_scope_dedup();
     const out: Record<string, string[]> = {};
     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<string>();
-        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<string>();
+        const kept = rules.filter((r) => !skip.has(r));
+        out[tool_dir] = partition_rules_for_dir(tool_dir, kept, user_home);
     }
     return out;
 }
@@ -1266,7 +1235,10 @@ export function generate_rule_symlinks(): number {
 }
 
 export function generate_windsurfrules(): number {
-    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);
@@ -1322,32 +1294,6 @@ function _yaml_scalar(value: string): string {
     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: Record<string, unknown>): string[] {
-    const triggers = meta['triggers'];
-    if (!Array.isArray(triggers)) {
-        return [];
-    }
-    const globs: string[] = [];
-    for (const t of triggers) {
-        if (t === null || typeof t !== 'object' || Array.isArray(t)) continue;
-        const obj = t as Record<string, unknown>;
-        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'] as string;
-            globs.push(prefix.endsWith('/') ? `${prefix}**` : `${prefix}**`);
-        }
-    }
-    // De-dup, keep declaration order (deterministic output).
-    return [...new Set(globs)];
-}
 
 export function _emit_cursor_mdc(source: string, target: string): void {
     const [meta, body] = _parse_frontmatter(_readText(source));
@@ -1390,151 +1336,8 @@ export function _emit_windsurf_rule(source: string, target: string): void {
     _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: string): boolean {
-    for (const m of pattern.matchAll(/\{([^}]*)\}/g)) {
-        if (!(m[1] as string).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: string): string {
-    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: string): number {
-    let n = 1;
-    for (const m of pattern.matchAll(/\{([^}]*)\}/g)) {
-        n *= (m[1] as string).split(',').length;
-    }
-    return n;
-}
 
-/** Host-documented budget for one rule's whole `paths:` list. */
-export const CLAUDE_PATHS_PATTERN_BUDGET = 1000;
 
-export interface ClaudePathsPlan {
-    /** Patterns to emit under `paths:`, in declaration order. */
-    globs: string[];
-    /** Patterns deliberately not emitted, with the reason a reader can act on. */
-    dropped: { pattern: string; reason: 'unresolved-placeholder' | 'over-budget' | 'mixed-triggers' }[];
-}
-
-/**
- * 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: Record<string, unknown>): boolean {
-    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 as Record<string, unknown>;
-        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: Record<string, unknown>): ClaudePathsPlan {
-    const always_apply = Boolean(meta['alwaysApply'] || meta['type'] === 'always');
-    if (always_apply) {
-        return { globs: [], dropped: [] };
-    }
-    const globs: string[] = [];
-    const dropped: ClaudePathsPlan['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.
@@ -1605,12 +1408,16 @@ function _clean_modern_dir(target_dir: string, valid_names: ReadonlySet<string>)
 export function generate_cursor_mdc_rules(): number {
     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`),
@@ -1627,12 +1434,15 @@ export function generate_cursor_mdc_rules(): number {
 export function generate_windsurf_modern_rules(): number {
     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) {
@@ -1823,6 +1633,7 @@ function _render_native_model_md(src_md: string, tier: string): string {
 }
 
 export function generate_claude_skills(active_skill_names: ReadonlySet<string> | null = null): number {
+    if (partitionActive(MODULE_STATE.PROJECT_ROOT)) active_skill_names = new Set<string>();
     if (!_exists(MODULE_STATE.SKILLS_SOURCE)) {
         process.stderr.write('  ⚠️  dist/agent-src/skills/ not found — skipping skills\n');
         return 0;
@@ -1836,7 +1647,9 @@ export function generate_claude_skills(active_skill_names: ReadonlySet<string> |
         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<string>()
+        : new Set([...iterCommands()].map(([, slug]) => slug));
 
     _mkdirp(MODULE_STATE.CLAUDE_SKILLS_DIR);
     const auto = _read_model_auto_switch() === 'auto';
@@ -1932,18 +1745,16 @@ function _nested_command_subpath(source_file: string): string | null {
 /**
  * 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.
@@ -1951,6 +1762,8 @@ function _nested_command_subpath(source_file: string): string | null {
 export function generate_claude_project_commands(
     active_command_slugs: ReadonlySet<string> | null = null,
 ): number {
+    if (commandsWithheld(MODULE_STATE.PROJECT_ROOT)) active_command_slugs = new Set<string>();
+    // Returns before the stale sweep — invariant, see `commandsWithheld`.
     if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
         return 0;
     }
@@ -1967,8 +1780,7 @@ export function generate_claude_project_commands(
 
     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);
@@ -1976,6 +1788,7 @@ export function generate_claude_project_commands(
                 fs.unlinkSync(item);
             }
         }
+        pruneEmptyDirs(target_root); // else the gate counts 40 empty cluster dirs as 40 commands
     }
 
     let count = 0;
@@ -1997,6 +1810,7 @@ export function generate_claude_project_commands(
 }
 
 export function generate_claude_commands(active_command_slugs: ReadonlySet<string> | null = null): number {
+    if (partitionActive(MODULE_STATE.PROJECT_ROOT)) active_command_slugs = new Set<string>();
     if (!_isDir(path.join(MODULE_STATE.PROJECT_ROOT, 'src', 'domains'))) {
         process.stderr.write('  ⚠️  src/domains/ not found — skipping commands\n');
         return 0;
@@ -2447,7 +2261,7 @@ export function generate_persona_symlinks(): number {
         .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)) {
@@ -2455,11 +2269,11 @@ export function generate_persona_symlinks(): number {
         _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)) {
@@ -2469,9 +2283,8 @@ export function generate_persona_symlinks(): number {
             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;
 }
 
@@ -2671,10 +2484,17 @@ export function project_to_augment(): void {
     const current = new Set<string>();
     let written = 0;
     if (_exists(src_rules)) {
-        const 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));
+        // 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)),
+        );
         for (const rule of rules) {
             const target = path.join(dst_rules, rule);
             if (_isSymlink(target) || _existsOrSymlink(target)) {

package/src/scripts/council_cli.ts

@@ -63,6 +63,7 @@ import {
     plan_advisor_swap,
 } from './ai_council/advisors.js';
 import { format_install_hints } from './ai_council/cli_hints.js';
+import { renderSubHelp } from './ai_council/cli_help.js';
 import {
     type AdvisorConfig,
     type CouncilConfig,
@@ -2507,6 +2508,7 @@ function cmd_run(
     const [extra_calls, extra_usd] = _consensus_cost_delta(ai_cfg, question.mode, estimates, billable.length);
     const [ch_calls, ch_usd] = _chairman_cost_delta(ai_cfg, estimates);
     const [pr_extra_calls, pr_extra_usd] = _peer_review_cost_delta(ai_cfg, args, estimates, billable.length);
+    if (!args.confirm) _stdout('council:run · DRY PASS — estimate only, no seat is contacted. Add --confirm to run.\n');
     _stdout(
         `council:run · mode=${question.mode} · members=${members.length} ` +
             `(billable=${billable.length})\n`,
@@ -3728,10 +3730,8 @@ function _parseArgs(argv: string[]): Args {
     const rest = argv.slice(1);
     const usage = _usageFor(first);
     const { positionals, opts, requiredOpts } = _specsFor(first);
-
-    // Sub-help.
     if (rest.includes('-h') || rest.includes('--help')) {
-        _stdout(usage);
+        _stdout(renderSubHelp(first, usage, { positionals, opts, requiredOpts }));
         process.exitCode = 0;
         throw new _ArgExit();
     }

package/src/scripts/dispatch_r2_reviewer.ts

@@ -51,6 +51,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 // (validator → dispatcher for the scope hash, dispatcher → validator for
 // relevance) is safe: neither module calls the other at module-evaluation
 // time, and each CLI entry guard only fires for its own argv[1].
+import { isAcceptanceCriteriaHeading } from './_lib/ac_heading.js';
 import { gitEnv } from './_lib/git_env.js';
 import { completionReviewDisabled } from './_lib/planning_settings.js';
 import { artifactRelevance } from './check_completion_review.js';
@@ -492,20 +493,11 @@ export function extractAcceptanceCriteria(roadmapText: string): string {
     const lines = roadmapText.split('\n');
     let start = -1;
     for (let i = 0; i < lines.length; i++) {
-        // Case-insensitive, and NOT anchored at the end of the line.
-        //
-        // Case first: the tree carries both `## Acceptance Criteria` and
-        // `## Acceptance criteria`; a case-sensitive match silently extracted
-        // nothing for the latter (found by the zcs-close R2 review, 2026-08-09).
-        //
-        // The end-anchor was the same defect wearing a different mask, and it was
-        // LIVE: `\s*$` rejected a heading carrying a qualifier, so
-        // `## Acceptance criteria (per phase, on promotion to ready)` and
-        // `## Acceptance criteria (anti-dump — the review-s own rule)` extracted
-        // nothing. Two roadmaps, measured 2026-08-18 — and they had been counted
-        // as "declares no criteria" by the very census that motivated this fix,
-        // which is how a matcher tuned to its own measurement hides its misses.
-        if (/^##\s+acceptance criteria\b/i.test(lines[i] as string)) {
+        // Case-insensitive and NOT end-anchored — both of those were live misses
+        // here (case: zcs-close R2 review 2026-08-09; the `(per phase, …)` qualifier:
+        // measured 2026-08-18). The predicate now lives in `_lib/ac_heading`, which
+        // records all three instances of the defect and why it is shared.
+        if (isAcceptanceCriteriaHeading(lines[i] as string)) {
             start = i;
             break;
         }

package/src/scripts/external_sources_denylist.json

@@ -62,7 +62,10 @@
     "\\bagent-reach\\b",
     "panniantong",
     "virgiliojr94",
-    "book-to-skill"
+    "book-to-skill",
+    "project-codeguard",
+    "\\bcodeguard\\b",
+    "\\bcosai\\b"
   ],
   "skip_paths": [
     "src/scripts/check_no_external_sources.py",