@event4u/agent-config 8.6.0 → 8.7.0

package/src/install/rule_scope.ts

@@ -0,0 +1,120 @@
+/**
+ * Install-time rule scoping — Pipeline B of consumer-scoped rule projection
+ * (road-to-request-scoped-rule-load Phase 1b).
+ *
+ * The projection filter (`rule_in_scope`, condense.ts) covered only the
+ * maintainer projection; the consumer install pipeline shipped rules
+ * unfiltered (dead `EXCLUDE_RULES` in install.sh; no exclude at all on the
+ * global payload). This module is the ONE scoping surface both install
+ * paths consume — it deliberately re-uses `rule_in_scope` so the install
+ * semantics can never drift from the projection semantics.
+ *
+ * ## The `source-of-truth.md` decision (Phase 1b Step 2 — recorded here)
+ *
+ * Before this module, `install.sh` excluded `source-of-truth.md` from
+ * PROJECT installs (hardcoded name) while the GLOBAL payload shipped it —
+ * the documented contradiction. Decision: the rule is excluded from BOTH
+ * consumer paths, always (even under legacy-all). Rationale: its Iron Law
+ * ("NEVER EDIT ANY GENERATED PROJECTION … ALWAYS WORK IN src/") describes
+ * THIS repository's build layout; in a consumer project there is no `src/`
+ * authoring tree and the installed files ARE the working surface — the rule
+ * is not merely useless there, it actively forbids legitimate consumer
+ * edits. Shipping it globally was the bug; project installs had it right.
+ * The compat list below is the pre-flip carrier of that decision; once the
+ * Phase-1 human gate flips consumer defaults to scoped, the rule drops out
+ * via its maintainer-only workspace tag and this list can retire.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { rule_in_scope } from '../scripts/condense.js';
+
+/**
+ * Rules excluded from EVERY consumer install path regardless of scope —
+ * same treatment on project and global (see module doc for the decision).
+ */
+export const COMPAT_ALWAYS_EXCLUDED: readonly string[] = ['source-of-truth.md'];
+
+/** Workspace/pack scope read from consumer settings. `null` axis = unset. */
+export interface RuleScope {
+    readonly workspaces: readonly string[] | null;
+    readonly packs: readonly string[] | null;
+}
+
+export const LEGACY_ALL: RuleScope = { workspaces: null, packs: null };
+
+/** Non-empty string-array extraction; anything else → null (legacy-all). */
+function _list(value: unknown): readonly string[] | null {
+    if (Array.isArray(value) && value.length > 0) {
+        return value.map((v) => String(v));
+    }
+    return null;
+}
+
+/**
+ * Extract `projection.rule_workspaces` / `projection.rule_packs` from an
+ * already-parsed settings object (same key contract as condense's
+ * `_read_projection_list` — absent / empty = legacy-all).
+ */
+export function ruleScopeFromSettings(settings: Record<string, unknown>): RuleScope {
+    const proj = settings['projection'];
+    if (typeof proj !== 'object' || proj === null || Array.isArray(proj)) {
+        return LEGACY_ALL;
+    }
+    const p = proj as Record<string, unknown>;
+    return {
+        workspaces: _list(p['rule_workspaces']),
+        packs: _list(p['rule_packs']),
+    };
+}
+
+/**
+ * Whether a rule FILE (path into the shipped `dist/agent-src/rules` tree)
+ * arrives in a consumer install under `scope`.
+ *
+ * Delegates the scoping decision to the projection-path predicate
+ * (`rule_in_scope` — kernel always ships, untagged axes fail safe) and adds
+ * the compat exclusion on top. Non-rule files (non-`.md`) always arrive.
+ */
+export function ruleFileArrives(sourcePath: string, scope: RuleScope): boolean {
+    if (!sourcePath.endsWith('.md')) {
+        return true;
+    }
+    const basename = path.basename(sourcePath);
+    if (COMPAT_ALWAYS_EXCLUDED.includes(basename)) {
+        return false;
+    }
+    return rule_in_scope(sourcePath, scope.workspaces, scope.packs);
+}
+
+/**
+ * Basenames from `rulesDir` that are EXCLUDED under `scope` — the shape the
+ * bash installer consumes (one basename per line via the CLI below).
+ */
+export function excludedRuleBasenames(rulesDir: string, scope: RuleScope): string[] {
+    let entries: string[];
+    try {
+        entries = fs.readdirSync(rulesDir).sort();
+    } catch {
+        return [];
+    }
+    const out: string[] = [];
+    for (const name of entries) {
+        if (!name.endsWith('.md')) {
+            continue;
+        }
+        const full = path.join(rulesDir, name);
+        try {
+            if (!fs.statSync(full).isFile()) {
+                continue;
+            }
+        } catch {
+            continue;
+        }
+        if (!ruleFileArrives(full, scope)) {
+            out.push(name);
+        }
+    }
+    return out;
+}

package/src/install/rule_scope_cli.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env tsx
+/**
+ * CLI twin surface of {@link module:install/rule_scope} for the bash
+ * installer (road-to-request-scoped-rule-load Phase 1b).
+ *
+ * Prints one EXCLUDED rule basename per line for the given rules source
+ * dir + consumer settings file. `install.sh` consumes this to replace its
+ * dead hardcoded `EXCLUDE_RULES` list; on any failure the caller falls back
+ * to the static compat exclusion (fail-safe: over-ship, never under-ship).
+ *
+ * Usage:
+ *   rule_scope_cli.ts --rules-dir <dist/agent-src/rules> [--settings <file>]
+ *
+ * Exit codes: 0 ok (list on stdout, possibly empty) · 2 usage error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { load_agent_settings } from '../scripts/_lib/agent_settings.js';
+
+import { excludedRuleBasenames, ruleScopeFromSettings, LEGACY_ALL } from './rule_scope.js';
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    let rulesDir = '';
+    let settingsFile = '';
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--rules-dir') {
+            rulesDir = argv[i + 1] ?? '';
+            i += 1;
+        } else if (arg === '--settings') {
+            settingsFile = argv[i + 1] ?? '';
+            i += 1;
+        } else {
+            process.stderr.write(`rule_scope_cli: unknown argument: ${arg}\n`);
+            return 2;
+        }
+    }
+    if (rulesDir === '') {
+        process.stderr.write('usage: rule_scope_cli.ts --rules-dir <dir> [--settings <file>]\n');
+        return 2;
+    }
+
+    let scope = LEGACY_ALL;
+    if (settingsFile !== '' && fs.existsSync(settingsFile)) {
+        try {
+            const settings = load_agent_settings({ project_path: settingsFile });
+            scope = ruleScopeFromSettings(settings as Record<string, unknown>);
+        } catch {
+            // Unreadable settings → legacy-all (fail-safe: over-ship).
+            scope = LEGACY_ALL;
+        }
+    }
+
+    for (const name of excludedRuleBasenames(path.resolve(rulesDir), scope)) {
+        process.stdout.write(`${name}\n`);
+    }
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) return false;
+    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (import.meta.url === argvUrl) return true;
+    try {
+        return (
+            fs.realpathSync(fileURLToPath(import.meta.url)) ===
+            fs.realpathSync(path.resolve(process.argv[1]))
+        );
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exit(main());
+}

package/src/install/wizard-plan.ts

@@ -23,6 +23,7 @@ import { isAbsolute, join, resolve } from 'node:path';
 
 import type { ConflictPolicy, InstallPlan, InstallTarget } from './types.js';
 import { buildInstallPlan, type PlanSource } from './plan.js';
+import { ruleFileArrives, LEGACY_ALL, type RuleScope } from './rule_scope.js';
 
 /**
  * Per-tool user-scope anchor directory, mirrored 1:1 from
@@ -152,6 +153,14 @@ export interface WizardExpandInputs {
     readonly packageRoot: string;
     /** Override for the user's home directory (tests only). */
     readonly home?: string;
+    /**
+     * Workspace/pack scope applied to `rules` sources
+     * (road-to-request-scoped-rule-load Phase 1b). Absent = LEGACY_ALL,
+     * which still applies the compat exclusion (`source-of-truth.md`) so
+     * the global path finally matches the project path — the recorded
+     * decision in `rule_scope.ts`.
+     */
+    readonly ruleScope?: RuleScope;
 }
 
 /**
@@ -172,6 +181,8 @@ export interface WizardExpandInputs {
  */
 export function expandWizardSources(inputs: WizardExpandInputs): PlanSource[] {
     const { toolIds, packageRoot, home } = inputs;
+    const scope = inputs.ruleScope ?? LEGACY_ALL;
+    const ruleFilter = (srcFile: string): boolean => ruleFileArrives(srcFile, scope);
     const out: PlanSource[] = [];
     for (const toolId of toolIds) {
         const deploy = GLOBAL_DEPLOY_SOURCES[toolId];
@@ -181,7 +192,17 @@ export function expandWizardSources(inputs: WizardExpandInputs): PlanSource[] {
         for (const [srcRel, destSub] of deploy) {
             const srcDir = join(packageRoot, srcRel);
             const destDir = destSub.length === 0 ? destRoot : join(destRoot, destSub);
-            out.push({ toolId, srcDir, destDir, kind: 'deployed' });
+            // Rule sources get the install-time scoping filter — the same
+            // predicate the projection path uses (Phase 1b: Pipeline B may
+            // never drift from Pipeline A).
+            const isRuleSource = srcRel === 'dist/agent-src/rules';
+            out.push({
+                toolId,
+                srcDir,
+                destDir,
+                kind: 'deployed',
+                ...(isRuleSource ? { fileFilter: ruleFilter } : {}),
+            });
         }
     }
     return out;

package/src/scripts/check_trigger_eval_presence.ts

@@ -0,0 +1,171 @@
+#!/usr/bin/env tsx
+/**
+ * Trigger-eval PRESENCE ratchet (road-to-composition-ratchet Phase 1).
+ *
+ * `check_trigger_evals.ts` validates freshness + structure of triggers.json
+ * files that EXIST; it cannot flag a new skill that ships without one, even
+ * though the drafting protocol mandates the stub. This gate closes that gap
+ * with a shrink-only grandfather allowlist
+ * (`src/scripts/trigger_eval_grandfather.json`, frozen 2026-07-08 at 221
+ * entries):
+ *
+ *   1. Every skill under `src/skills/` must either carry
+ *      `evals/triggers.json` or appear in the allowlist.
+ *   2. An allowlist entry whose skill directory no longer exists is stale
+ *      and must be removed.
+ *   3. An allowlist entry whose skill HAS a triggers.json must be removed —
+ *      the list may only shrink (ratchet), never regrow.
+ *
+ * Structure + freshness of existing files stay owned by
+ * `check_trigger_evals.ts`; this gate checks presence only.
+ *
+ * Exit codes: 0 ok · 1 violation(s) · 2 usage / unreadable allowlist.
+ * `--quiet` suppresses the ✅ summary (errors always print to stderr).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const SKILLS_DIR = path.join(REPO_ROOT, 'src', 'skills');
+const ALLOWLIST_PATH = path.join(REPO_ROOT, 'src', 'scripts', 'trigger_eval_grandfather.json');
+
+interface Allowlist {
+    skills: string[];
+}
+
+function load_allowlist(p: string): Allowlist | null {
+    try {
+        const raw = JSON.parse(fs.readFileSync(p, 'utf-8')) as unknown;
+        if (
+            typeof raw !== 'object' ||
+            raw === null ||
+            !Array.isArray((raw as { skills?: unknown }).skills) ||
+            !(raw as { skills: unknown[] }).skills.every((s) => typeof s === 'string')
+        ) {
+            return null;
+        }
+        return { skills: (raw as { skills: string[] }).skills };
+    } catch {
+        return null;
+    }
+}
+
+function list_skill_dirs(root: string): string[] {
+    return fs
+        .readdirSync(root, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name)
+        .sort();
+}
+
+function has_triggers(skill: string): boolean {
+    return fs.existsSync(path.join(SKILLS_DIR, skill, 'evals', 'triggers.json'));
+}
+
+interface Findings {
+    errors: string[];
+    covered: number;
+    total: number;
+}
+
+function check(skills: string[], allowlisted: string[]): Findings {
+    const allow = new Set(allowlisted);
+    const skillSet = new Set(skills);
+    const errors: string[] = [];
+    let covered = 0;
+
+    for (const skill of skills) {
+        if (has_triggers(skill)) {
+            covered += 1;
+            if (allow.has(skill)) {
+                errors.push(
+                    `${skill}: has evals/triggers.json but is still in the grandfather allowlist — remove the entry (shrink-only ratchet)`,
+                );
+            }
+        } else if (!allow.has(skill)) {
+            errors.push(
+                `${skill}: missing evals/triggers.json and not grandfathered — new/changed skills must ship a trigger-eval set (see artifact-drafting-protocol Phase C)`,
+            );
+        }
+    }
+
+    for (const entry of allowlisted) {
+        if (!skillSet.has(entry)) {
+            errors.push(
+                `allowlist entry "${entry}" has no matching skill directory — remove the stale entry`,
+            );
+        }
+    }
+
+    return { errors, covered, total: skills.length };
+}
+
+function parse_args(argv: string[]): { quiet: boolean } | null {
+    let quiet = false;
+    for (const a of argv) {
+        if (a === '--quiet' || a === '-q') {
+            quiet = true;
+        } else {
+            return null;
+        }
+    }
+    return { quiet };
+}
+
+function main(): number {
+    const args = parse_args(process.argv.slice(2));
+    if (args === null) {
+        process.stderr.write('usage: check_trigger_eval_presence [--quiet]\n');
+        return 2;
+    }
+
+    const allowlist = load_allowlist(ALLOWLIST_PATH);
+    if (allowlist === null) {
+        process.stderr.write(
+            `❌ check-trigger-eval-presence: unreadable or malformed allowlist at ${path.relative(REPO_ROOT, ALLOWLIST_PATH)}\n`,
+        );
+        return 2;
+    }
+
+    const { errors, covered, total } = check(list_skill_dirs(SKILLS_DIR), allowlist.skills);
+
+    if (errors.length) {
+        process.stderr.write('❌ check-trigger-eval-presence: presence-ratchet violation(s):\n');
+        for (const e of errors) {
+            process.stderr.write(`   - ${e}\n`);
+        }
+        return 1;
+    }
+
+    if (!args.quiet) {
+        process.stdout.write(
+            `✅ check-trigger-eval-presence: ${covered}/${total} skills carry evals/triggers.json (${allowlist.skills.length} grandfathered, shrink-only)\n`,
+        );
+    }
+    return 0;
+}
+
+const _HERE = fileURLToPath(import.meta.url);
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (import.meta.url === argvUrl) {
+        return true;
+    }
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv = fs.realpathSync(path.resolve(process.argv[1]));
+        return here === argv;
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    process.exit(main());
+}
+
+export { ALLOWLIST_PATH, check, load_allowlist, parse_args, main };

package/src/scripts/install.sh

@@ -23,8 +23,14 @@ set -euo pipefail
 COPY_DIRS="rules"  # Subdirectories where files must be real copies (space-separated)
 
 # Rules that are internal to the agent-config package and should NOT be shipped to consumers.
-# These are only relevant when developing the agent-config package itself.
-EXCLUDE_RULES="source-of-truth.md augment-portability.md docs-sync.md"
+# Static COMPAT floor only (see src/install/rule_scope.ts for the recorded
+# source-of-truth.md decision — same treatment on project AND global paths).
+# The full workspace/pack scoping list is resolved at runtime by
+# resolve_excluded_rules() via src/install/rule_scope_cli.ts, which re-uses
+# the projection predicate (rule_in_scope) so install semantics can never
+# drift from projection semantics. This variable is the fail-safe fallback
+# when no node/tsx runtime is available (over-ship, never under-ship).
+EXCLUDE_RULES="source-of-truth.md"
 
 # Files inside target/.augment/ that are NOT managed by sync (created by the bridge installer).
 # Never remove them in clean_stale even though they are absent in the source manifest.
@@ -284,6 +290,47 @@ create_symlink() {
 
 # --- Core functions ---
 
+# Resolve the full excluded-rule list for this install via the shared
+# scoping CLI (workspace/pack scope from <TARGET>/.agent-settings.yml,
+# router/frontmatter truth, kernel-safe). Overwrites EXCLUDE_RULES on
+# success; keeps the static compat fallback on any failure
+# (road-to-request-scoped-rule-load Phase 1b).
+resolve_excluded_rules() {
+    local rules_src="$SOURCE_PAYLOAD/rules"
+    local settings_file="$TARGET_DIR/.agent-settings.yml"
+    local cli="$SOURCE_DIR/src/install/rule_scope_cli.ts"
+    [[ -f "$cli" && -d "$rules_src" ]] || { log_verbose "rule-scope CLI unavailable — static exclude fallback"; return 0; }
+
+    local tsx_bin=""
+    if [[ -x "$SOURCE_DIR/node_modules/.bin/tsx" ]]; then
+        tsx_bin="$SOURCE_DIR/node_modules/.bin/tsx"
+    elif command -v npx >/dev/null 2>&1; then
+        tsx_bin="npx --yes tsx"
+    else
+        log_verbose "no tsx/npx runtime — static exclude fallback"
+        return 0
+    fi
+
+    local resolved
+    local -a cli_args=(--rules-dir "$rules_src")
+    [[ -f "$settings_file" ]] && cli_args+=(--settings "$settings_file")
+    # TMPDIR pinned for the child: tsx writes its transform cache under
+    # $TMPDIR — on macOS TMPDIR is exported, and callers (tests, wrappers)
+    # may point it INTO the install target, leaking tsx-cache files into a
+    # consumer tree / breaking dry-run's zero-file guarantee.
+    # shellcheck disable=SC2086
+    if resolved=$(TMPDIR=/tmp $tsx_bin "$cli" "${cli_args[@]}" 2>/dev/null); then
+        # Newline list → space list (is_excluded_rule iterates words).
+        EXCLUDE_RULES="$(echo "$resolved" | tr '\n' ' ')"
+        local n
+        n="$(echo "$resolved" | grep -c . || true)"
+        log_verbose "rule scope resolved: $n excluded rule(s)"
+    else
+        log_verbose "rule-scope CLI failed — static exclude fallback"
+    fi
+    return 0
+}
+
 # Check if a relative path matches an excluded rule
 is_excluded_rule() {
     local rel_path="$1"
@@ -470,6 +517,60 @@ clean_stale() {
 }
 
 
+# Emit host-NATIVE rule surfaces for consumer Cursor (.mdc with globs) and
+# Windsurf (.windsurf/rules + .windsurfrules) via the exported condense
+# emitters — so consumer installs carry the same trigger signal as the
+# maintainer projection (road-to-request-scoped-rule-load Phase 1b Step 3;
+# the recorded install-time-vs-dist decision lives in
+# src/install/emit_host_rules_cli.ts). Sets CURSOR_NATIVE_EMITTED /
+# WINDSURF_NATIVE_EMITTED so the legacy surfaces (raw-md symlink farm,
+# bash frontmatter-stripping concatenator) run only as no-node fallbacks.
+CURSOR_NATIVE_EMITTED=false
+WINDSURF_NATIVE_EMITTED=false
+emit_host_rules() {
+    local project_root="$1"
+    local rules_dir="$project_root/.augment/rules"
+    local cli="$SOURCE_DIR/src/install/emit_host_rules_cli.ts"
+    [[ -d "$rules_dir" && -f "$cli" ]] || return 0
+
+    local -a tools=()
+    is_tool_enabled "cursor" && tools+=("cursor")
+    is_tool_enabled "windsurf" && tools+=("windsurf")
+    [[ ${#tools[@]} -gt 0 ]] || return 0
+
+    if $DRY_RUN; then
+        log_verbose "emit host-native rules (${tools[*]})"
+        return 0
+    fi
+
+    local tsx_bin=""
+    if [[ -x "$SOURCE_DIR/node_modules/.bin/tsx" ]]; then
+        tsx_bin="$SOURCE_DIR/node_modules/.bin/tsx"
+    elif command -v npx >/dev/null 2>&1; then
+        tsx_bin="npx --yes tsx"
+    else
+        log_verbose "no tsx/npx runtime — legacy host-rule surfaces"
+        return 0
+    fi
+
+    local tools_csv
+    tools_csv="$(IFS=,; echo "${tools[*]}")"
+    # TMPDIR pinned: tsx cache must never land in the install target.
+    # shellcheck disable=SC2086
+    if TMPDIR=/tmp $tsx_bin "$cli" --rules-dir "$rules_dir" \
+        --project-root "$project_root" --tools "$tools_csv" >/dev/null 2>&1; then
+        for tool in "${tools[@]}"; do
+            case "$tool" in
+                cursor)   CURSOR_NATIVE_EMITTED=true;   log_info "Emitted native .cursor/rules/*.mdc" ;;
+                windsurf) WINDSURF_NATIVE_EMITTED=true; log_info "Emitted native .windsurf/rules + .windsurfrules" ;;
+            esac
+        done
+    else
+        log_verbose "host-rule emission failed — legacy fallback surfaces"
+    fi
+    return 0
+}
+
 # Create tool-specific rule symlinks (filtered by --tools selection).
 # Map: tool ID → (target dir, relative prefix from target → .augment/rules).
 create_tool_symlinks() {
@@ -482,7 +583,11 @@ create_tool_symlinks() {
     local -a tool_dirs=()
     local -a rel_prefixes=()
     is_tool_enabled "claude-code" && { tool_ids+=("claude-code"); tool_dirs+=(".claude/rules");  rel_prefixes+=("../../.augment/rules"); }
-    is_tool_enabled "cursor"      && { tool_ids+=("cursor");      tool_dirs+=(".cursor/rules");  rel_prefixes+=("../../.augment/rules"); }
+    # Cursor gets NATIVE .mdc files when emit_host_rules succeeded — the
+    # raw-md symlink farm is the no-node fallback only (Phase 1b Step 3).
+    if ! $CURSOR_NATIVE_EMITTED; then
+        is_tool_enabled "cursor"  && { tool_ids+=("cursor");      tool_dirs+=(".cursor/rules");  rel_prefixes+=("../../.augment/rules"); }
+    fi
     is_tool_enabled "cline"       && { tool_ids+=("cline");       tool_dirs+=(".clinerules");    rel_prefixes+=("../.augment/rules"); }
 
     if [[ ${#tool_dirs[@]} -eq 0 ]]; then
@@ -596,6 +701,9 @@ generate_windsurfrules() {
     local project_root="$1"
     local rules_dir="$project_root/.augment/rules"
 
+    # Native emission (frontmatter-aware, trigger-preserving) already wrote
+    # .windsurfrules — this bash concatenator is the no-node fallback only.
+    $WINDSURF_NATIVE_EMITTED && { log_verbose "skip bash .windsurfrules (native emitted)"; return 0; }
     [[ -d "$rules_dir" ]] || return 0
     is_tool_enabled "windsurf" || { log_verbose "skip .windsurfrules (windsurf not selected)"; return 0; }
 
@@ -1107,6 +1215,10 @@ main() {
     #     install the file does not exist yet → defaults preserved.
     resolve_settings
 
+    # 0c. Resolve the excluded-rule set for this install (workspace/pack
+    #     scope via the shared rule_scope CLI; static compat fallback).
+    resolve_excluded_rules
+
     # 1. Hybrid sync payload → target/.augment/
     sync_hybrid "$SOURCE_PAYLOAD" "$TARGET_DIR/.augment"
     if $USE_RULES_SYMLINKS; then
@@ -1130,7 +1242,9 @@ main() {
         log_verbose "skip .github/copilot-instructions.md (copilot not selected)"
     fi
 
-    # 3. Create tool-specific symlinks
+    # 3. Emit host-native rule surfaces (cursor .mdc / windsurf), then
+    #    create tool-specific symlinks for the remaining tools.
+    emit_host_rules "$TARGET_DIR"
     create_tool_symlinks "$TARGET_DIR"
     create_skill_symlinks "$TARGET_DIR"