@event4u/agent-config 14.6.0 → 14.8.0

package/dist/install/claudePathsPlan.js

@@ -0,0 +1,187 @@
+/**
+ * The Claude Code `paths:` emission plan — which globs a rule projects, and which
+ * it deliberately does not.
+ *
+ * Extracted from `condense.ts` on 2026-08-20 (road-to-single-delivery Phase 5).
+ * Two reasons, and the second is the one that made it worth doing now.
+ *
+ * It belongs here on its own merits: this is host-activation-key logic, the same
+ * subject as `emit_host_rules_cli.ts` beside it, and `condense.ts` is the
+ * orchestrator that calls it rather than the place it lives.
+ *
+ * And it pays for the phase that moved it. Phase 5.1 removed the path triggers
+ * from four package-only rules so they load unconditionally — a change ABOUT
+ * this plan — and wiring the delivery partition into `condense.ts` and
+ * `install.ts` added lines to two files already past the 1,500-line source
+ * ceiling, where `check_source_size_budget` counts every added line as a
+ * violation. That gate's own convention is that the total moves down through
+ * extraction and never up through a baseline raise, so the extraction is the fix
+ * rather than a favour: the plan lands in a module under the ceiling, and the
+ * ratchet sees a net improvement instead of a regression.
+ *
+ * Side-effect-free, no CLI entry, no `process.exit`.
+ */
+/**
+ * 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)];
+}
+/**
+ * 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 };
+}
+//# sourceMappingURL=claudePathsPlan.js.map

package/dist/install/claudePathsPlan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudePathsPlan.js","sourceRoot":"","sources":["../../src/install/claudePathsPlan.ts"],"names":[],"mappings":"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"}

package/dist/install/globalRuleLayers.js

@@ -0,0 +1,169 @@
+/**
+ * Where each host's GLOBAL rule layer lives on disk, and whether it carries a
+ * given set of rules.
+ *
+ * ## Why this module exists
+ *
+ * ADR-236 partitions rules between the global and the project layer: an artefact
+ * scoped to this package alone stays project-local, everything else is delivered
+ * globally and withheld from the project tree. `partitionEligibility.ts` decides
+ * WHETHER the partition is on, by verifying the claude host layer against
+ * `installed.lock`. Its own docstring then draws the only conclusion that
+ * evidence supports — it "says nothing about `~/.cursor`", so withholding a
+ * cursor artefact on the strength of a claude fingerprint "would deliver it
+ * nowhere".
+ *
+ * That reasoning is right and its scope was too narrow for rules. The rule
+ * filter sits in `condense.ts::_scoped_rule_basenames()`, which is per-RUN and
+ * not per-DIRECTORY, so it already withholds from `.clinerules` on a claude
+ * fingerprint — the exact extrapolation the docstring refuses. Measured
+ * 2026-08-22 in a freshly generated worktree with the partition active:
+ *
+ * ```
+ * .claude/rules      13 files, 13 package-only,   0 global-only
+ * .clinerules        14 files, 13 package-only,   0 global-only
+ * .cursor/rules     126 files, 26 package-only, 100 global-only
+ * .windsurf/rules   113 files, 13 package-only, 100 global-only
+ * .augment/rules    118 files, 15 package-only, 103 global-only
+ * ```
+ *
+ * Two hosts partition on borrowed evidence; three do not partition at all. This
+ * module supplies the evidence per host so neither case has to be guessed:
+ * {@link globalRuleLayerNames} reads the host's own global directory, and
+ * {@link hostLayerCarries} answers the one question a withhold depends on.
+ *
+ * ## Why the paths are written out rather than imported
+ *
+ * `USER_SCOPE_PATHS` in `src/scripts/install.ts` is the authority for a host's
+ * global scope ROOT, and it is the right authority. It is not imported here for
+ * two reasons: `install.ts` is a multi-thousand-line CLI entry point that pulls
+ * in the whole installer graph, and a scope root is not a rules path — cline's
+ * root already IS its rules directory (`~/Documents/Cline/Rules/`) while every
+ * other host appends a subdirectory. So the mapping is stated once here and
+ * PINNED against `USER_SCOPE_PATHS` by `tests/install/global_rule_layers.test.ts`,
+ * which fails if a root moves. A pinned restatement drifts loudly; an import
+ * would have cost the bundle.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+/**
+ * Tool id → its global rule directory, relative to the user's home.
+ *
+ * Keys are the ids `USER_SCOPE_PATHS` and `TOOL_SIGNALS` use, so a row here is
+ * traceable to the installer's own scope table rather than invented.
+ *
+ * The five hosts below are the ones that receive a projected rule TREE. A host
+ * whose rules arrive as a single concatenated file (`.windsurfrules`,
+ * `GEMINI.md`, copilot instructions) has no directory to compare and is
+ * deliberately absent: {@link globalRuleLayerPath} returns null for it, which
+ * reads as "no evidence" and keeps the full projection.
+ */
+export const GLOBAL_RULE_DIRS = {
+    'claude-code': '.claude/rules',
+    cursor: '.cursor/rules',
+    augment: '.augment/rules',
+    // Windsurf's scope root is `~/.codeium/windsurf/`, not `~/.windsurf/`.
+    windsurf: '.codeium/windsurf/rules',
+    // Cline's scope root IS the rules directory — no `rules/` suffix.
+    cline: 'Documents/Cline/Rules',
+};
+/**
+ * Project rule directory → the tool id whose global layer covers it.
+ *
+ * Five entries, because five directories receive a projected rule TREE. Two are
+ * symlink trees (`condense.ts::TOOL_DIRS`); three are written by their own
+ * emitters — `generate_cursor_mdc_rules`, `generate_windsurf_modern_rules`, and
+ * `project_to_augment`. The `.cursor/rules` row covers both the `.mdc` files and
+ * the legacy `.md` symlinks that share that directory.
+ *
+ * It lives here rather than in either consumer so the gate that reports a
+ * duplicate and the emitters that must stop creating one read the same list. A
+ * sixth host directory added to one and not the other is exactly how a gate goes
+ * green over a tree nobody checks.
+ */
+export const PROJECT_RULE_DIRS = {
+    '.claude/rules': 'claude-code',
+    '.cursor/rules': 'cursor',
+    '.clinerules': 'cline',
+    '.windsurf/rules': 'windsurf',
+    '.augment/rules': 'augment',
+};
+/** The tool id whose global layer covers a project rule directory, or null. */
+export function toolIdForProjectRuleDir(dir) {
+    return PROJECT_RULE_DIRS[dir] ?? null;
+}
+/** Every tool id that has a global rule directory this module can read. */
+export function hostsWithGlobalRuleLayer() {
+    return Object.keys(GLOBAL_RULE_DIRS).sort();
+}
+/**
+ * Absolute path to a host's global rule directory, or null when the host has no
+ * directory-shaped global layer.
+ *
+ * Null is a real answer and not an error: it means this module cannot supply
+ * evidence for that host, and every caller must read that as "do not withhold".
+ */
+export function globalRuleLayerPath(toolId, home = process.env['HOME'] ?? os.homedir()) {
+    const rel = GLOBAL_RULE_DIRS[toolId];
+    return rel === undefined ? null : path.join(home, rel);
+}
+/**
+ * The rule basenames a host's global layer actually holds, normalised to `.md`.
+ *
+ * Returns null when the directory does not exist or cannot be read — the
+ * absent-tolerant contract Phase 1.1 requires. Normalisation matters because
+ * Cursor's tree is `.mdc`: comparing raw filenames would report every rule as
+ * missing there and turn the partition off for the one host whose duplication is
+ * largest.
+ */
+export function globalRuleLayerNames(toolId, home = process.env['HOME'] ?? os.homedir()) {
+    const dir = globalRuleLayerPath(toolId, home);
+    if (dir === null) {
+        return null;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return null;
+    }
+    return entries
+        .filter((f) => f.endsWith('.md') || f.endsWith('.mdc'))
+        .map((f) => (f.endsWith('.mdc') ? `${f.slice(0, -4)}.md` : f))
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+/**
+ * Does this host's global layer carry every rule that would be withheld from its
+ * project directory?
+ *
+ * This is the property `personaPartition`'s docstring states as the precondition
+ * for any withhold — "withholding is only safe once the surviving layer is known
+ * to carry what is withheld" — asked per host instead of inferred from claude.
+ *
+ * Fails safe in all three negative directions: a host with no directory layer, a
+ * directory that is absent, and a directory missing even one name all return
+ * `carries: false`, so the caller keeps the full projection. An empty
+ * `ruleNames` is vacuously carried, which is correct — withholding nothing needs
+ * no evidence.
+ */
+export function hostLayerCarries(toolId, ruleNames, home = process.env['HOME'] ?? os.homedir()) {
+    const layerPath = globalRuleLayerPath(toolId, home);
+    if (layerPath === null) {
+        return { carries: false, layerPath: null, missing: [...ruleNames], reason: 'no-layer-for-host' };
+    }
+    const have = globalRuleLayerNames(toolId, home);
+    if (have === null) {
+        return { carries: false, layerPath, missing: [...ruleNames], reason: 'layer-absent' };
+    }
+    const present = new Set(have);
+    const missing = ruleNames.filter((n) => !present.has(n));
+    return {
+        carries: missing.length === 0,
+        layerPath,
+        missing,
+        reason: missing.length === 0 ? 'carries' : 'missing-names',
+    };
+}
+//# sourceMappingURL=globalRuleLayers.js.map

package/dist/install/globalRuleLayers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalRuleLayers.js","sourceRoot":"","sources":["../../src/install/globalRuleLayers.ts"],"names":[],"mappings":"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"}

package/dist/install/hostLayerFingerprint.js

@@ -0,0 +1,136 @@
+/**
+ * Deterministic content fingerprint of a host artefact layer.
+ *
+ * ## Why a fingerprint and not a version number
+ *
+ * The single-delivery partition is a *removal*: after it, `task generate-tools`
+ * writes 16 rules and zero skills into `<repo>/.claude/` and every other
+ * artefact is delivered ONLY by the host-global layer. That removes the build's
+ * own repair path — regeneration can no longer heal a stale global layer,
+ * because it stops writing the affected files at all.
+ *
+ * A package version proves *which installer claims to have written* the host
+ * directory. It does not prove that the directory holds the artefacts this
+ * checkout is about to omit. Measured on the maintainer machine 2026-08-20:
+ * `package.json` and the published release both read `14.6.0`, while **153
+ * skills existed only in the project layer** and 37 only in the global one. A
+ * version-equality predicate would have authorised the partition there and
+ * silently dropped 153 skills. So the predicate compares content.
+ *
+ * ## Cost — measured, and the earlier figure was wrong
+ *
+ * A prior revision of the blocker recorded 5.85 s per generation for a
+ * content comparison and used that number to argue the approach was too
+ * expensive. That figure was a **shell artefact**: it spawned one `cat` per
+ * file. Re-measured in Node on the same tree: **61 ms** over 664 source files,
+ * **103 ms** over 1019 host files. The comparison is cheap; the 5.85 s never
+ * described this mechanism.
+ *
+ * ## Contract
+ *
+ * Side-effect-free, no CLI entry, no `process.exit` — this module ships inside
+ * the consumer installer bundle, same constraint as `ruleInScope.ts`. Keep it
+ * that way.
+ */
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Fingerprint wire version. Bump when the digest input changes shape, so an
+ * old lockfile compares unequal instead of comparing wrong.
+ */
+export const FINGERPRINT_SCHEMA = 1;
+/** Files under `dir`, recursively, sorted by path — deterministic order. */
+function collectFiles(dir) {
+    const out = [];
+    const walk = (d) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return; // absent or unreadable → contributes nothing
+        }
+        const sorted = [...entries].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        for (const e of sorted) {
+            const p = path.join(d, e.name);
+            if (e.isDirectory()) {
+                walk(p);
+            }
+            else if (e.isFile()) {
+                out.push(p);
+            }
+            // Symlinks are deliberately skipped: the project layer symlinks into
+            // `dist/`, the global layer holds real files, and following links
+            // would make two layers of identical CONTENT fingerprint differently
+            // depending on which side was read.
+        }
+    };
+    walk(dir);
+    return out.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+/**
+ * Content fingerprint over the given layers.
+ *
+ * The digest covers, per file, its **layer-relative** path and its bytes — so a
+ * rename, a deletion, an addition, and an edit each change it, while the
+ * absolute location of the layer does not. Layers are folded in the order
+ * given; pass them in a stable order.
+ *
+ * An absent layer root is not an error: it contributes zero files. That makes
+ * the fingerprint of "nothing installed" well-defined and unequal to any real
+ * layer, which is what the fail-safe branch of the partition predicate wants.
+ */
+export function fingerprintLayers(layers) {
+    const h = createHash('sha256');
+    h.update(`v${FINGERPRINT_SCHEMA}\0`);
+    for (const layer of layers) {
+        h.update(`layer:${layer.label}\0`);
+        for (const file of collectFiles(layer.root)) {
+            h.update(path.relative(layer.root, file));
+            h.update('\0');
+            try {
+                h.update(fs.readFileSync(file));
+            }
+            catch {
+                // A file that vanished between listing and reading is a partial
+                // install by definition. Fold a marker rather than throwing, so
+                // the digest differs from a complete layer instead of aborting
+                // the caller.
+                h.update('\0unreadable\0');
+            }
+            h.update('\0');
+        }
+    }
+    return h.digest('hex');
+}
+/**
+ * The host-global artefact layers the partition depends on, in a FIXED order.
+ *
+ * **This is the one definition, and it has to be.** The installer fingerprints
+ * what it wrote; the build fingerprints what it finds and compares. Two inline
+ * lists would drift — and a drift here does not fail loudly, it makes the
+ * partition permanently unreachable while every fail-safe branch reports a
+ * plausible reason. Import this; never re-list the layers.
+ *
+ * Only `claude-code` is covered, and the narrowness is the measurement rather
+ * than an omission: the 110-rule / 203,873-token duplication ADR-236 partitions
+ * was measured on `~/.claude/`. Widening this list widens what must be verified
+ * before a single artefact is withheld, so it is a deliberate addition.
+ *
+ * `commands` is in the list because the project layer writes skills AND commands
+ * into ONE directory (`generate_claude_commands` targets `CLAUDE_SKILLS_DIR`)
+ * while the host layer keeps them apart in `~/.claude/skills` and
+ * `~/.claude/commands`. Emptying the project directory withholds commands too,
+ * so commands must be part of what gets verified first. Measured 2026-08-20:
+ * 414 project entries against 298 host skills plus 93 host commands.
+ */
+export function hostLayerInputs(userHome) {
+    const claude = path.join(userHome, '.claude');
+    return [
+        { label: 'rules', root: path.join(claude, 'rules') },
+        { label: 'skills', root: path.join(claude, 'skills') },
+        { label: 'commands', root: path.join(claude, 'commands') },
+    ];
+}
+//# sourceMappingURL=hostLayerFingerprint.js.map

package/dist/install/hostLayerFingerprint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostLayerFingerprint.js","sourceRoot":"","sources":["../../src/install/hostLayerFingerprint.ts"],"names":[],"mappings":"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"}