@event4u/agent-config 8.5.0 → 8.7.0

package/src/scripts/_lib/subagent_steering.ts

@@ -117,6 +117,12 @@ export interface OrchEntry {
     token_delta: number;
     outcome: string;
     verify_mode: string;
+    /** Routing extension (road-to-cost-aware-model-routing) — null on pre-extension lines. */
+    task_class: string | null;
+    tier_chosen: string | null;
+    tier_source: string | null;
+    escalated_from: string | null;
+    verify_result_by_tier: Record<string, string> | null;
 }
 
 /**
@@ -129,9 +135,8 @@ export interface OrchEntry {
  *
  * user_override_rate cannot be measured from telemetry alone — returns 0.
  */
-export function readOrchestrationMetrics(
-    lines: string[],
-): GuardrailMetrics {
+/** Parse orchestration entries from audit-log-v1 JSONL lines (shared by all aggregators). */
+export function parseOrchEntries(lines: string[]): OrchEntry[] {
     const entries: OrchEntry[] = [];
     for (const line of lines) {
         const trimmed = line.trim();
@@ -141,17 +146,33 @@ export function readOrchestrationMetrics(
             if (parsed['input_kind'] !== 'orchestration') continue;
             const orch = parsed['orchestration'] as Record<string, unknown> | undefined;
             if (!orch) continue;
+            const vbt = orch['verify_result_by_tier'];
             entries.push({
                 task_size_estimate: Number(orch['task_size_estimate'] ?? 0),
                 spawn_count: Number(orch['spawn_count'] ?? 0),
                 token_delta: Number(orch['token_delta'] ?? 0),
                 outcome: String(orch['outcome'] ?? ''),
                 verify_mode: String(orch['verify_mode'] ?? ''),
+                task_class: orch['task_class'] == null ? null : String(orch['task_class']),
+                tier_chosen: orch['tier_chosen'] == null ? null : String(orch['tier_chosen']),
+                tier_source: orch['tier_source'] == null ? null : String(orch['tier_source']),
+                escalated_from: orch['escalated_from'] == null ? null : String(orch['escalated_from']),
+                verify_result_by_tier:
+                    vbt != null && typeof vbt === 'object' && !Array.isArray(vbt)
+                        ? Object.fromEntries(Object.entries(vbt as Record<string, unknown>).map(([k, v]) => [k, String(v)]))
+                        : null,
             });
         } catch {
             // skip malformed lines
         }
     }
+    return entries;
+}
+
+export function readOrchestrationMetrics(
+    lines: string[],
+): GuardrailMetrics {
+    const entries = parseOrchEntries(lines);
 
     if (entries.length === 0) {
         return { token_ratio: 1, spawn_failure_rate: 0, verify_skip_rate: 0, user_override_rate: 0 };
@@ -174,3 +195,192 @@ export function readOrchestrationMetrics(
         user_override_rate: 0, // cannot measure from telemetry alone
     };
 }
+
+/**
+ * Per-tier / per-class routing aggregates (road-to-cost-aware-model-routing
+ * Phase 0). Pure aggregation over the routing telemetry fields — feeds the
+ * `/cost:report` per-tier view and the Phase-2 tripwires. Pre-extension lines
+ * (null routing fields) are ignored per aggregate.
+ */
+export interface TierRoutingMetrics {
+    /** Dispatch count per tier_chosen. */
+    dispatches_by_tier: Record<string, number>;
+    /** Dispatch count per task_class. */
+    dispatches_by_class: Record<string, number>;
+    /** Escalation count per task_class (entries with escalated_from set). */
+    escalations_by_class: Record<string, number>;
+    /** escalations_by_class / dispatches_by_class, per class present in both. */
+    escalation_rate_by_class: Record<string, number>;
+    /** Per tier: pass / (pass + fail) over verify_result_by_tier attempts. */
+    verify_pass_rate_by_tier: Record<string, number>;
+}
+
+export function readTierRoutingMetrics(lines: string[]): TierRoutingMetrics {
+    const entries = parseOrchEntries(lines);
+
+    const dispatches_by_tier: Record<string, number> = {};
+    const dispatches_by_class: Record<string, number> = {};
+    const escalations_by_class: Record<string, number> = {};
+    const verifyCounts: Record<string, { pass: number; fail: number }> = {};
+
+    for (const e of entries) {
+        if (e.tier_chosen !== null) {
+            dispatches_by_tier[e.tier_chosen] = (dispatches_by_tier[e.tier_chosen] ?? 0) + 1;
+        }
+        if (e.task_class !== null) {
+            dispatches_by_class[e.task_class] = (dispatches_by_class[e.task_class] ?? 0) + 1;
+            if (e.escalated_from !== null) {
+                escalations_by_class[e.task_class] = (escalations_by_class[e.task_class] ?? 0) + 1;
+            }
+        }
+        if (e.verify_result_by_tier !== null) {
+            for (const [tier, result] of Object.entries(e.verify_result_by_tier)) {
+                const c = (verifyCounts[tier] ??= { pass: 0, fail: 0 });
+                if (result === 'pass') c.pass += 1;
+                else if (result === 'fail') c.fail += 1;
+                // 'skipped' counts toward neither pass nor fail.
+            }
+        }
+    }
+
+    const escalation_rate_by_class: Record<string, number> = {};
+    for (const [cls, n] of Object.entries(dispatches_by_class)) {
+        escalation_rate_by_class[cls] = (escalations_by_class[cls] ?? 0) / n;
+    }
+
+    const verify_pass_rate_by_tier: Record<string, number> = {};
+    for (const [tier, c] of Object.entries(verifyCounts)) {
+        const attempts = c.pass + c.fail;
+        if (attempts > 0) verify_pass_rate_by_tier[tier] = c.pass / attempts;
+    }
+
+    return {
+        dispatches_by_tier,
+        dispatches_by_class,
+        escalations_by_class,
+        escalation_rate_by_class,
+        verify_pass_rate_by_tier,
+    };
+}
+
+/**
+ * Cost-routing tripwires (road-to-cost-aware-model-routing Phase 2) —
+ * steering policy over the routing telemetry, surfaced never auto-flipped.
+ */
+export const ROUTING_TRIPWIRES = {
+    /**
+     * Per-class escalation rate above which the class's static default tier
+     * should be promoted: cascading a class that escalates this often costs
+     * more than starting on the higher tier.
+     */
+    escalation_promotion_rate: 0.4,
+    /** Verify-pass rate drop (absolute) below the trailing baseline that counts as drift. */
+    verify_pass_drift_tolerance: 0.1,
+    /** Minimum dispatches per class before the escalation tripwire may fire (noise floor). */
+    min_class_dispatches: 5,
+} as const;
+
+/**
+ * Tripwire (i): classes whose escalation rate exceeds the promotion
+ * threshold — their static default tier is wrong; promote it, stop cascading.
+ * Classes below the dispatch noise floor never fire.
+ */
+export function escalationPromotionCandidates(m: TierRoutingMetrics): string[] {
+    const candidates: string[] = [];
+    for (const [cls, rate] of Object.entries(m.escalation_rate_by_class)) {
+        const dispatches = m.dispatches_by_class[cls] ?? 0;
+        if (dispatches < ROUTING_TRIPWIRES.min_class_dispatches) continue;
+        if (rate > ROUTING_TRIPWIRES.escalation_promotion_rate) candidates.push(cls);
+    }
+    return candidates.sort();
+}
+
+/**
+ * Tripwire (ii): tiers whose current verify-pass rate dropped below the
+ * trailing baseline by more than the tolerance — verifier or model drift.
+ * Tiers absent from either side are skipped (no baseline → no drift claim).
+ */
+export function verifyPassDrift(
+    current: Record<string, number>,
+    trailingBaseline: Record<string, number>,
+): string[] {
+    const drifting: string[] = [];
+    for (const [tier, baseline] of Object.entries(trailingBaseline)) {
+        const now = current[tier];
+        if (now === undefined) continue;
+        if (now < baseline - ROUTING_TRIPWIRES.verify_pass_drift_tolerance) drifting.push(tier);
+    }
+    return drifting.sort();
+}
+
+/**
+ * Verify-fail escalation (road-to-cost-aware-model-routing Phase 4 / M3).
+ *
+ * A verification FAILURE on a downshifted return re-dispatches the slice one
+ * tier up, consuming the existing N=3 budget — never a new budget. Confined
+ * to tier_source static|inferred; inherit slices keep same-tier retry.
+ * The trigger is the judge verdict / deterministic verify result — never the
+ * subagent's self-reported confidence.
+ */
+export type EscalationTier = 'lite' | 'medium' | 'high';
+
+export interface VerifyFailInputs {
+    /** Tier of the attempt that just failed verification. */
+    failed_tier: EscalationTier;
+    /** Provenance of the slice's tier (telemetry `tier_source`). */
+    tier_source: 'static' | 'inferred' | 'inherit';
+    /** Consecutive failed attempts on this slice INCLUDING the one that just failed. */
+    consecutive_failures: number;
+}
+
+export interface VerifyFailDecision {
+    action: 'escalate' | 'retry-same-tier' | 'slice-failed';
+    /** Tier for the next attempt; null when the slice is failed. */
+    next_tier: EscalationTier | null;
+    reason: string;
+}
+
+const TIER_ABOVE: Record<EscalationTier, EscalationTier | null> = {
+    lite: 'medium',
+    medium: 'high',
+    high: null,
+};
+
+export function escalateOnVerifyFail(inp: VerifyFailInputs): VerifyFailDecision {
+    // Outside the downshift path → existing same-tier retry semantics, budget unchanged.
+    if (inp.tier_source === 'inherit') {
+        if (budgetHalt(inp.consecutive_failures)) {
+            return { action: 'slice-failed', next_tier: null, reason: 'N=3 budget exhausted on session tier' };
+        }
+        return {
+            action: 'retry-same-tier',
+            next_tier: inp.failed_tier,
+            reason: 'inherit slice — no downshift decision, same-tier retry semantics unchanged',
+        };
+    }
+
+    // Downshifted slice: two failed attempts mark the slice failed — the third
+    // "attempt" of the N=3 budget is the orchestrator's replan at session tier.
+    if (inp.consecutive_failures >= 2) {
+        return {
+            action: 'slice-failed',
+            next_tier: null,
+            reason: 'two failed attempts on a downshifted slice — mark failed, orchestrator replans at session tier',
+        };
+    }
+
+    const above = TIER_ABOVE[inp.failed_tier];
+    if (above === null) {
+        return {
+            action: 'slice-failed',
+            next_tier: null,
+            reason: 'verify-fail on the highest tier — no tier above, mark failed and replan',
+        };
+    }
+
+    return {
+        action: 'escalate',
+        next_tier: above,
+        reason: `verify-fail on ${inp.failed_tier} → re-dispatch one tier up (${above}); consumes the N=3 budget`,
+    };
+}

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"