@event4u/agent-config 14.5.0 → 14.7.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":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAA6B;IAC9D,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC;IAClC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3B,OAAO,EAAE,CAAC;IACd,CAAC;IACD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACvB,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YAAE,SAAS;QACtE,MAAM,GAAG,GAAG,CAA4B,CAAC;QACzC,IAAI,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC;YACjE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;QACpC,CAAC;aAAM,IAAI,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC;YACtE,MAAM,MAAM,GAAG,GAAG,CAAC,aAAa,CAAW,CAAC;YAC5C,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC;QACrE,CAAC;IACL,CAAC;IACD,yDAAyD;IACzD,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,0BAA0B,CAAC,OAAe;IACtD,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;QAC/C,IAAI,CAAE,CAAC,CAAC,CAAC,CAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAClC,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IACD,OAAO,KAAK,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAe;IAClD,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAe;IACnD,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;QAC/C,CAAC,IAAK,CAAC,CAAC,CAAC,CAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,CAAC;IACD,OAAO,CAAC,CAAC;AACb,CAAC;AAED,iEAAiE;AACjE,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,CAAC;AAShD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAA6B;IAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC;IAClC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;QAAE,OAAO,KAAK,CAAC;IAC3C,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACvB,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YAAE,SAAS;QACtE,MAAM,GAAG,GAAG,CAA4B,CAAC;QACzC,IAAI,OAAO,GAAG,CAAC,SAAS,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,SAAS,CAAC;YAAE,OAAO,IAAI,CAAC;QACtE,IAAI,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;IACxE,CAAC;IACD,OAAO,KAAK,CAAC;AACjB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAA6B;IAC5D,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,QAAQ,CAAC,CAAC;IAC/E,IAAI,YAAY,EAAE,CAAC;QACf,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IACtC,CAAC;IACD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,OAAO,GAA+B,EAAE,CAAC;IAE/C,0EAA0E;IAC1E,mEAAmE;IACnE,EAAE;IACF,2EAA2E;IAC3E,0EAA0E;IAC1E,0EAA0E;IAC1E,2EAA2E;IAC3E,uEAAuE;IACvE,2EAA2E;IAC3E,0EAA0E;IAC1E,8DAA8D;IAC9D,EAAE;IACF,sEAAsE;IACtE,0EAA0E;IAC1E,4EAA4E;IAC5E,oEAAoE;IACpE,sDAAsD;IACtD,IAAI,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9B,KAAK,MAAM,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3C,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAC9B,CAAC;IAED,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3C,IAAI,0BAA0B,CAAC,GAAG,CAAC,EAAE,CAAC;YAClC,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,wBAAwB,EAAE,CAAC,CAAC;YACjE,SAAS;QACb,CAAC;QACD,MAAM,IAAI,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,KAAK,GAAG,IAAI,GAAG,2BAA2B,EAAE,CAAC;YAC7C,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;YACtD,SAAS;QACb,CAAC;QACD,KAAK,IAAI,IAAI,CAAC;QACd,KAAK,CAAC,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAC9B,CAAC"}

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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"}