@event4u/agent-config 14.6.0 → 14.7.0

package/dist/scripts/condense.js

@@ -227,7 +227,11 @@ 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 { isExclusivelyPackageOnly, partitionActive, setPartitionAnnounce } from '../install/partitionEligibility.js'; // ADR-236
+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 +260,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,
@@ -1004,6 +1009,7 @@ 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));
 }
@@ -1188,34 +1194,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 +1233,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.
  *
@@ -1652,6 +1495,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 +1509,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)) {
@@ -1812,6 +1659,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;