@event4u/agent-config 9.11.0 → 9.12.0

package/dist/cli-delegate/{chunk-YMFO6FDN.js → chunk-QFKQLQ7X.js}

@@ -2,9 +2,15 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   main
 } from "./chunk-XX6TOPD7.js";
+import {
+  RULE_SOURCE_REL
+} from "./chunk-EJYIGZ3T.js";
 import {
   ScopeMismatchError,
+  build_claude_hook_matrix,
+  ensure_managed_hooks,
   expected_deploy_files,
+  is_ancestor,
   load_inventory,
   manifest_path,
   read_manifest,
@@ -14,7 +20,7 @@ import {
   save_inventory,
   upsert_tool,
   write_manifest
-} from "./chunk-IR7P7JWA.js";
+} from "./chunk-A3HJ6NTI.js";
 import {
   check_version,
   classify_mismatch,
@@ -26,13 +32,10 @@ import {
   write_lockfile
 } from "./chunk-GRRPEPRN.js";
 import {
-  TIER_TO_CLAUDE_MODEL,
-  build_claude_hook_matrix,
-  ensure_managed_hooks,
-  is_claude_builtin_name,
-  read_model_tier,
-  render_native_model_md
-} from "./chunk-7DSAMZFU.js";
+  LEGACY_ALL,
+  ruleFileArrives,
+  ruleScopeFromSettings
+} from "./chunk-TJIAM5FW.js";
 import {
   find_project_root_with_anchor,
   load_agent_settings
@@ -255,12 +258,128 @@ function subtract_pointers(doc, entries) {
 // src/scripts/install.ts
 import { spawn, spawnSync } from "node:child_process";
 import * as crypto3 from "node:crypto";
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 import * as os2 from "node:os";
 import * as path5 from "node:path";
 import process2 from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
+// src/scripts/_lib/claude_builtin_names.ts
+var _CURRENT = [
+  "add-dir",
+  "advisor",
+  "agents",
+  "autofix-pr",
+  "background",
+  "batch",
+  "branch",
+  "btw",
+  "cd",
+  "chrome",
+  "claude-api",
+  "clear",
+  "code-review",
+  "color",
+  "compact",
+  "config",
+  "context",
+  "copy",
+  "cost",
+  "dataviz",
+  "debug",
+  "deep-research",
+  "design-login",
+  "design-sync",
+  "desktop",
+  "diff",
+  "doctor",
+  "effort",
+  "exit",
+  "export",
+  "fast",
+  "feedback",
+  "fewer-permission-prompts",
+  "focus",
+  "fork",
+  "goal",
+  "heapdump",
+  "help",
+  "hooks",
+  "ide",
+  "init",
+  "insights",
+  "install-github-app",
+  "install-slack-app",
+  "keybindings",
+  "login",
+  "logout",
+  "loop",
+  "mcp",
+  "memory",
+  "mobile",
+  "model",
+  "passes",
+  "permissions",
+  "plan",
+  "plugin",
+  "powerup",
+  "pr-comments",
+  "privacy-settings",
+  "radio",
+  "recap",
+  "release-notes",
+  "reload-plugins",
+  "reload-skills",
+  "remote-control",
+  "remote-env",
+  "rename",
+  "resume",
+  "review",
+  "rewind",
+  "run",
+  "run-skill-generator",
+  "sandbox",
+  "schedule",
+  "scroll-speed",
+  "security-review",
+  "setup-bedrock",
+  "setup-vertex",
+  "simplify",
+  "skills",
+  "stats",
+  "status",
+  "statusline",
+  "stickers",
+  "teleport",
+  "thinking",
+  "trust",
+  "upgrade",
+  "usage",
+  "verify",
+  "vim",
+  "web",
+  "whats-new",
+  "workflow",
+  "workflows",
+  "worktree"
+];
+var _LEGACY = [
+  "bashes",
+  "bug",
+  "migrate-installer",
+  "output-style",
+  "terminal-setup",
+  "theme",
+  "todos"
+];
+var CLAUDE_CODE_BUILTIN_NAMES = /* @__PURE__ */ new Set([
+  ..._CURRENT,
+  ..._LEGACY
+]);
+function is_claude_builtin_name(slug) {
+  return CLAUDE_CODE_BUILTIN_NAMES.has(slug.toLowerCase());
+}
+
 // src/scripts/_lib/surface_tiers.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -6752,6 +6871,31 @@ function detect_module_roots(project_root) {
   return [...high, ...medium];
 }
 
+// src/scripts/_lib/model_tier.ts
+import fs5 from "node:fs";
+var TIER_TO_CLAUDE_MODEL = {
+  high: "opus",
+  medium: "sonnet",
+  lite: "haiku"
+};
+var MODEL_TIER_RE = /^model_tier:\s*"?([a-z]+)"?\s*$/m;
+function read_model_tier(skill_md) {
+  if (!fs5.existsSync(skill_md)) return null;
+  const text = fs5.readFileSync(skill_md).toString("utf-8");
+  if (!text.startsWith("---\n")) return null;
+  const end = text.indexOf("\n---\n", 4);
+  if (end === -1) return null;
+  const m = MODEL_TIER_RE.exec(text.slice(4, end));
+  return m ? m[1] : null;
+}
+function render_native_model_md(text, tier) {
+  const model = TIER_TO_CLAUDE_MODEL[tier];
+  if (model === void 0) {
+    throw new Error(`'${tier}'`);
+  }
+  return text.replace(MODEL_TIER_RE, `model: ${model}`);
+}
+
 // src/scripts/install.ts
 var _HERE = fileURLToPath(import.meta.url);
 var SystemExitError = class extends Error {
@@ -6777,28 +6921,28 @@ function expanduser2(p) {
 }
 function resolvePath(p) {
   try {
-    return fs5.realpathSync(path5.resolve(p));
+    return fs6.realpathSync(path5.resolve(p));
   } catch {
     return path5.resolve(p);
   }
 }
 function isFile(p) {
   try {
-    return fs5.statSync(p).isFile();
+    return fs6.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir(p) {
   try {
-    return fs5.statSync(p).isDirectory();
+    return fs6.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function pathExists(p) {
   try {
-    fs5.statSync(p);
+    fs6.statSync(p);
     return true;
   } catch {
     return false;
@@ -6806,24 +6950,24 @@ function pathExists(p) {
 }
 function isSymlink(p) {
   try {
-    return fs5.lstatSync(p).isSymbolicLink();
+    return fs6.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function readText(p) {
-  return fs5.readFileSync(p, "utf-8");
+  return fs6.readFileSync(p, "utf-8");
 }
 function writeText(p, content) {
-  fs5.writeFileSync(p, content, "utf-8");
+  fs6.writeFileSync(p, content, "utf-8");
 }
 function mkdirp(p) {
-  fs5.mkdirSync(p, { recursive: true });
+  fs6.mkdirSync(p, { recursive: true });
 }
 function sortedGlobStems(directory, suffix) {
   let entries;
   try {
-    entries = fs5.readdirSync(directory);
+    entries = fs6.readdirSync(directory);
   } catch {
     return [];
   }
@@ -6843,7 +6987,7 @@ function sortedGlobStems(directory, suffix) {
 function countZips(directory) {
   if (!isDir(directory)) return 0;
   let n = 0;
-  for (const name of fs5.readdirSync(directory)) {
+  for (const name of fs6.readdirSync(directory)) {
     if (name.endsWith(".zip")) n += 1;
   }
   return n;
@@ -6851,7 +6995,7 @@ function countZips(directory) {
 function sha256OfFile(p) {
   let data;
   try {
-    data = fs5.readFileSync(p);
+    data = fs6.readFileSync(p);
   } catch {
     return null;
   }
@@ -6865,21 +7009,21 @@ function atomicWrite0644(target, body, prefix) {
   );
   let fd = null;
   try {
-    fd = fs5.openSync(tmpName, "wx", 420);
-    fs5.writeFileSync(fd, body, "utf-8");
-    fs5.closeSync(fd);
+    fd = fs6.openSync(tmpName, "wx", 420);
+    fs6.writeFileSync(fd, body, "utf-8");
+    fs6.closeSync(fd);
     fd = null;
-    fs5.chmodSync(tmpName, 420);
-    fs5.renameSync(tmpName, target);
+    fs6.chmodSync(tmpName, 420);
+    fs6.renameSync(tmpName, target);
   } catch (err) {
     if (fd !== null) {
       try {
-        fs5.closeSync(fd);
+        fs6.closeSync(fd);
       } catch {
       }
     }
     try {
-      fs5.unlinkSync(tmpName);
+      fs6.unlinkSync(tmpName);
     } catch {
     }
     throw err;
@@ -7295,7 +7439,7 @@ function _migrate_legacy_if_present(project_root, template_body) {
   rendered = _append_unknown_legacy(rendered, values, unknown);
   const backup_target = path5.join(project_root, LEGACY_BACKUP_FILE);
   writeText(backup_target, legacy_text);
-  fs5.unlinkSync(legacy_target);
+  fs6.unlinkSync(legacy_target);
   info(`Migrated legacy ${LEGACY_SETTINGS_FILE} \u2192 ${SETTINGS_FILE}`);
   info(`Backup saved to ${LEGACY_BACKUP_FILE}`);
   if (unknown.length > 0) {
@@ -7412,7 +7556,7 @@ function ensure_agent_settings(project_root, package_root, profile, force, user_
   if (isFile(legacy_root) && !pathExists(target)) {
     mkdirp(path5.dirname(target));
     writeText(target, readText(legacy_root));
-    fs5.unlinkSync(legacy_root);
+    fs6.unlinkSync(legacy_root);
     success(`Migrated ${SETTINGS_FILE} \u2192 agents/settings/${SETTINGS_FILE} (ADR-038)`);
     return;
   }
@@ -7490,7 +7634,7 @@ function _deploy_augment_trampoline(package_root, name, force) {
     skip(`~/.augment/hooks/${name} already up to date`);
   } else {
     writeText(dst, src_text);
-    fs5.chmodSync(dst, 493);
+    fs6.chmodSync(dst, 493);
     success(`~/.augment/hooks/${name} installed`);
   }
   return dst;
@@ -7500,7 +7644,7 @@ function _remove_legacy_augment_trampolines() {
     const legacy = path5.join(AUGMENT_USER_HOOKS_DIR, name);
     try {
       if (isFile(legacy)) {
-        fs5.unlinkSync(legacy);
+        fs6.unlinkSync(legacy);
         skip(`removed legacy ~/.augment/hooks/${name}`);
       }
     } catch {
@@ -7591,7 +7735,7 @@ function ensure_cursor_user_hooks(package_root, force) {
     skip(`~/.cursor/hooks/${CURSOR_DISPATCHER_TRAMPOLINE} already up to date`);
   } else {
     writeText(dst, src_text);
-    fs5.chmodSync(dst, 493);
+    fs6.chmodSync(dst, 493);
     success(`~/.cursor/hooks/${CURSOR_DISPATCHER_TRAMPOLINE} installed`);
   }
   const hooks = {};
@@ -7658,7 +7802,7 @@ function ensure_cline_bridge(project_root, force) {
       continue;
     }
     writeText(target, body);
-    fs5.chmodSync(target, 493);
+    fs6.chmodSync(target, 493);
     written += 1;
   }
   if (written) {
@@ -7682,7 +7826,7 @@ function ensure_cline_user_hooks(package_root, force) {
     skip(`~/Documents/Cline/Hooks/${CLINE_DISPATCHER_TRAMPOLINE} already up to date`);
   } else {
     writeText(trampoline, src_text);
-    fs5.chmodSync(trampoline, 493);
+    fs6.chmodSync(trampoline, 493);
     success(`~/Documents/Cline/Hooks/${CLINE_DISPATCHER_TRAMPOLINE} installed`);
   }
   const trampoline_quoted = shlexQuote(trampoline);
@@ -7697,7 +7841,7 @@ exec ${trampoline_quoted} ${ac_event} ${native_event}
       continue;
     }
     writeText(wrapper, body);
-    fs5.chmodSync(wrapper, 493);
+    fs6.chmodSync(wrapper, 493);
   }
 }
 var WINDSURF_DISPATCHER_BINDINGS = [
@@ -7740,7 +7884,7 @@ function ensure_windsurf_user_hooks(package_root, force) {
     skip(`~/.codeium/windsurf/hooks/${WINDSURF_DISPATCHER_TRAMPOLINE} already up to date`);
   } else {
     writeText(dst, src_text);
-    fs5.chmodSync(dst, 493);
+    fs6.chmodSync(dst, 493);
     success(`~/.codeium/windsurf/hooks/${WINDSURF_DISPATCHER_TRAMPOLINE} installed`);
   }
   const hooks = {};
@@ -7803,7 +7947,7 @@ function ensure_gemini_user_hooks(package_root, force) {
     skip(`~/.gemini/hooks/${GEMINI_DISPATCHER_TRAMPOLINE} already up to date`);
   } else {
     writeText(dst, src_text);
-    fs5.chmodSync(dst, 493);
+    fs6.chmodSync(dst, 493);
     success(`~/.gemini/hooks/${GEMINI_DISPATCHER_TRAMPOLINE} installed`);
   }
   const settings_patch = {
@@ -8080,7 +8224,7 @@ var SMOKE_BRIDGE_PATHS = {
 };
 function dirHasEntries(p) {
   try {
-    return fs5.readdirSync(p).length > 0;
+    return fs6.readdirSync(p).length > 0;
   } catch {
     return false;
   }
@@ -8470,7 +8614,7 @@ function readLineSyncRaw(promptText) {
   for (; ; ) {
     let n;
     try {
-      n = fs5.readSync(0, buf, 0, 1, null);
+      n = fs6.readSync(0, buf, 0, 1, null);
     } catch (err) {
       const code = err.code;
       if (code === "EAGAIN") {
@@ -8629,7 +8773,7 @@ function _is_agent_config_source_repo(project_root) {
   }
   const packages_dir = path5.join(project_root, "packages");
   if (isDir(packages_dir)) {
-    for (const child of fs5.readdirSync(packages_dir)) {
+    for (const child of fs6.readdirSync(packages_dir)) {
       if (isDir(path5.join(packages_dir, child, ".agent-src.uncondensed"))) {
         return [true, `packages/${child}/.agent-src.uncondensed/`];
       }
@@ -8721,7 +8865,7 @@ function _remove_legacy_consumer_bridge_marker(project_root, env = null) {
   const target = path5.join(project_root, CONSUMER_BRIDGE_MARKER_RELPATH);
   if (!isFile(target)) return null;
   try {
-    fs5.rmSync(target);
+    fs6.rmSync(target);
   } catch {
     return null;
   }
@@ -8823,16 +8967,37 @@ function _inject_package_tag(target, source, package_root) {
     writeText(target, new_text);
   }
 }
-function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null) {
+function _escapes_package_root(resolved, package_root) {
+  if (package_root === null) return false;
+  let root;
+  try {
+    root = fs6.realpathSync(package_root);
+  } catch {
+    return false;
+  }
+  return !is_ancestor(root, resolved);
+}
+function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null, file_filter = null) {
   let written = 0;
   let skipped = 0;
   const written_paths = [];
   if (!pathExists(src)) return [0, 0, written_paths];
   if (!isDir(src)) {
+    if (file_filter !== null && !file_filter(src)) return [0, 0, written_paths];
+    let resolved_src = src;
+    try {
+      resolved_src = fs6.realpathSync(src);
+    } catch {
+      resolved_src = src;
+    }
+    if (_escapes_package_root(resolved_src, package_root)) {
+      warn(`refused: ${src} dereferences outside the package root \u2014 not copied`);
+      return [0, 0, written_paths];
+    }
     mkdirp(path5.dirname(dest));
     const decision = _resolve_file_conflict(dest, force);
     if (decision === "skip") return [0, 1, written_paths];
-    fs5.copyFileSync(src, dest);
+    fs6.copyFileSync(src, dest);
     _inject_package_tag(dest, src, package_root);
     written_paths.push(dest);
     return [1, 0, written_paths];
@@ -8840,11 +9005,11 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null)
   mkdirp(dest);
   const walk = (node) => {
     const acc = [];
-    const names = fs5.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const names = fs6.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const name of names) {
       const entry = path5.join(node, name);
       acc.push(entry);
-      const lst = fs5.lstatSync(entry);
+      const lst = fs6.lstatSync(entry);
       if (lst.isDirectory() && !lst.isSymbolicLink()) {
         acc.push(...walk(entry));
       }
@@ -8854,7 +9019,7 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null)
   for (const entry of walk(src)) {
     const rel = path5.relative(src, entry);
     const target = path5.join(dest, rel);
-    const lst = fs5.lstatSync(entry);
+    const lst = fs6.lstatSync(entry);
     if (lst.isDirectory() && !lst.isSymbolicLink()) {
       mkdirp(target);
       continue;
@@ -8862,31 +9027,39 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null)
     let resolvedIsDir = false;
     let resolved = entry;
     try {
-      resolved = fs5.realpathSync(entry);
-      resolvedIsDir = fs5.statSync(entry).isDirectory();
+      resolved = fs6.realpathSync(entry);
+      resolvedIsDir = fs6.statSync(entry).isDirectory();
     } catch {
       resolvedIsDir = false;
     }
+    if (_escapes_package_root(resolved, package_root)) {
+      warn(`refused: ${entry} dereferences outside the package root \u2014 not copied`);
+      continue;
+    }
     if (resolvedIsDir) {
       mkdirp(target);
       const [sub_w, sub_s, sub_p] = _copy_dir_dereferencing_symlinks(
         resolved,
         target,
         force,
-        package_root
+        package_root,
+        file_filter
       );
       written += sub_w;
       skipped += sub_s;
       written_paths.push(...sub_p);
       continue;
     }
+    if (file_filter !== null && !file_filter(entry)) {
+      continue;
+    }
     const decision = _resolve_file_conflict(target, force);
     if (decision === "skip") {
       skipped += 1;
       continue;
     }
     mkdirp(path5.dirname(target));
-    fs5.copyFileSync(resolved, target);
+    fs6.copyFileSync(resolved, target);
     _inject_package_tag(target, resolved, package_root);
     written += 1;
     written_paths.push(target);
@@ -8925,20 +9098,20 @@ function _apply_claude_flat_command_wrappers(anchor, package_root, current_files
   const commands_dir = path5.join(anchor, "commands");
   let flat_entries = [];
   try {
-    flat_entries = fs5.readdirSync(commands_dir).filter((f) => f.endsWith(".md"));
+    flat_entries = fs6.readdirSync(commands_dir).filter((f) => f.endsWith(".md"));
   } catch {
   }
   for (const fname of flat_entries.sort()) {
     const slug = fname.slice(0, -".md".length);
     if (!is_claude_builtin_name(slug)) continue;
-    fs5.rmSync(path5.join(commands_dir, fname), { force: true });
+    fs6.rmSync(path5.join(commands_dir, fname), { force: true });
     current_files.delete(`commands/${fname}`);
     reserved.push(slug);
   }
   const eligible = new Set(_CLAUDE_FLAT_WRAPPER_EXTRA);
   try {
     const manifest = JSON.parse(
-      fs5.readFileSync(path5.join(package_root, "dist", "discovery", "discovery-manifest.json"), "utf8")
+      fs6.readFileSync(path5.join(package_root, "dist", "discovery", "discovery-manifest.json"), "utf8")
     );
     for (const a of manifest.artefacts ?? []) {
       if (a.category !== "command" || typeof a.slug !== "string") continue;
@@ -8950,21 +9123,21 @@ function _apply_claude_flat_command_wrappers(anchor, package_root, current_files
   for (const slug of [...eligible].sort()) {
     const flat_rel = `commands/${slug}.md`;
     const flat_abs = path5.join(anchor, "commands", `${slug}.md`);
-    if (!fs5.existsSync(flat_abs)) continue;
+    if (!fs6.existsSync(flat_abs)) continue;
     const skill_dir = path5.join(anchor, "skills", slug);
-    if (fs5.existsSync(skill_dir)) {
+    if (fs6.existsSync(skill_dir)) {
       collisions.push(slug);
       continue;
     }
-    let body = fs5.readFileSync(flat_abs, "utf8");
+    let body = fs6.readFileSync(flat_abs, "utf8");
     if (body.startsWith("---\n") && !/^name:/m.test(body.split("\n---")[0] ?? "")) {
       body = body.replace("---\n", `---
 name: ${slug}
 `);
     }
-    fs5.mkdirSync(skill_dir, { recursive: true });
-    fs5.writeFileSync(path5.join(skill_dir, "SKILL.md"), body, "utf8");
-    fs5.rmSync(flat_abs, { force: true });
+    fs6.mkdirSync(skill_dir, { recursive: true });
+    fs6.writeFileSync(path5.join(skill_dir, "SKILL.md"), body, "utf8");
+    fs6.rmSync(flat_abs, { force: true });
     current_files.delete(flat_rel);
     current_files.add(`skills/${slug}/SKILL.md`);
     wrapped.push(slug);
@@ -8973,6 +9146,7 @@ name: ${slug}
 }
 function _deploy_global_content(tools, force, package_root, lockfile_path2) {
   const results = {};
+  const rule_scope = _resolve_global_rule_scope(package_root);
   for (const tool_id of [...tools].sort()) {
     if (tool_id === "claude-desktop") {
       results[tool_id] = _deploy_claude_desktop(force, package_root, lockfile_path2);
@@ -8997,13 +9171,24 @@ function _deploy_global_content(tools, force, package_root, lockfile_path2) {
     for (const [src_rel, dest_sub] of plan) {
       const src = path5.join(package_root, src_rel);
       const dest = dest_sub ? path5.join(anchor, dest_sub) : anchor;
-      const [w, s, paths] = _copy_dir_dereferencing_symlinks(src, dest, force, package_root);
+      const rule_filter = _rule_filter_for_source(src_rel, rule_scope);
+      const [w, s, paths] = _copy_dir_dereferencing_symlinks(
+        src,
+        dest,
+        force,
+        package_root,
+        rule_filter
+      );
       written_total += w;
       skipped_total += s;
       written_paths.push(...paths);
       current_files = setUnion(
         current_files,
-        expected_deploy_files(src, dest_sub ? dest_sub : "")
+        expected_deploy_files(
+          src,
+          dest_sub ? dest_sub : "",
+          rule_filter
+        )
       );
     }
     if (tool_id === "claude-code") {
@@ -9090,6 +9275,7 @@ function setUnion(a, b) {
 function _preview_global_reap(tools, package_root) {
   const inventory = load_inventory();
   const preview = {};
+  const rule_scope = _resolve_global_rule_scope(package_root);
   for (const tool_id of [...tools].sort()) {
     const plan = GLOBAL_DEPLOY_SOURCES[tool_id];
     if (plan === void 0) continue;
@@ -9101,7 +9287,11 @@ function _preview_global_reap(tools, package_root) {
       const src = path5.join(package_root, src_rel);
       current_files = setUnion(
         current_files,
-        expected_deploy_files(src, dest_sub ? dest_sub : "")
+        expected_deploy_files(
+          src,
+          dest_sub ? dest_sub : "",
+          _rule_filter_for_source(src_rel, rule_scope)
+        )
       );
     }
     let would_reap = [];
@@ -9135,7 +9325,7 @@ function _verify_deploy_targets(anchor, plan) {
       continue;
     }
     try {
-      const entries = fs5.readdirSync(target);
+      const entries = fs6.readdirSync(target);
       if (entries.length === 0) missing.push(label);
     } catch {
       missing.push(label);
@@ -9180,12 +9370,12 @@ function _prune_modules_by(deploy_results, is_pruned) {
       (is_target ? delete_files : keep).push(p);
     }
     for (const d of pruned_skill_dirs) {
-      fs5.rmSync(d, { recursive: true, force: true });
+      fs6.rmSync(d, { recursive: true, force: true });
     }
     for (const p of delete_files) {
       if (p.split(path5.sep).includes("commands") && pathExists(p)) {
         try {
-          fs5.unlinkSync(p);
+          fs6.unlinkSync(p);
         } catch {
         }
       }
@@ -9248,11 +9438,15 @@ function _compute_active_pack_ids(packs, runtime_active_packs) {
   return active;
 }
 function _resolve_global_settings_doc() {
+  const p = _resolve_global_settings_path();
+  return p === null ? null : _load_yaml_doc(p);
+}
+function _resolve_global_settings_path() {
   const root = event4u_root();
   const canonical = path5.join(root, "settings", SETTINGS_FILE);
-  if (pathExists(canonical)) return _load_yaml_doc(canonical);
+  if (pathExists(canonical)) return canonical;
   const legacy = path5.join(root, SETTINGS_FILE);
-  if (pathExists(legacy)) return _load_yaml_doc(legacy);
+  if (pathExists(legacy)) return legacy;
   return null;
 }
 function _resolve_scoped_projection(package_root) {
@@ -9264,6 +9458,44 @@ function _resolve_scoped_projection(package_root) {
   const active_packs = Array.isArray(active_packs_raw) ? active_packs_raw.filter((v) => typeof v === "string") : [];
   return { mode, active_packs };
 }
+function _resolve_global_rule_scope(package_root) {
+  const settings_path = _resolve_global_settings_path();
+  if (settings_path === null) {
+    try {
+      return ruleScopeFromSettings(_load_default_settings(package_root));
+    } catch {
+      return LEGACY_ALL;
+    }
+  }
+  let text;
+  try {
+    text = readText(settings_path);
+  } catch (e) {
+    warn(
+      `could not read ${settings_path} (${String(e)}) \u2014 rule scoping falls back to legacy-all, so ALL rules including maintainer-only ones will be installed. Fix the file to restore scoping.`
+    );
+    return LEGACY_ALL;
+  }
+  const parsed = yamlSafeLoad(text);
+  if (!_isPlainObject(parsed)) {
+    warn(
+      `${settings_path} is not a YAML mapping \u2014 rule scoping falls back to legacy-all, so ALL rules including maintainer-only ones will be installed. Fix the file to restore scoping.`
+    );
+    return LEGACY_ALL;
+  }
+  try {
+    return ruleScopeFromSettings(parsed);
+  } catch (e) {
+    warn(
+      `could not derive rule scope from ${settings_path} (${String(e)}) \u2014 falling back to legacy-all; ALL rules will be installed.`
+    );
+    return LEGACY_ALL;
+  }
+}
+function _rule_filter_for_source(src_rel, scope) {
+  if (src_rel !== RULE_SOURCE_REL) return null;
+  return (srcFile) => ruleFileArrives(srcFile, scope);
+}
 function _prune_scoped_modules(deploy_results, active_ids) {
   return _prune_modules_by(deploy_results, (p) => {
     const packs = frontmatter_packs(p);
@@ -9474,15 +9706,15 @@ function _write_settings_surface_snapshot(installed_version) {
   const next = _current_settings_surface(installed_version);
   let previous = null;
   try {
-    const parsed = JSON.parse(fs5.readFileSync(surface_path, "utf8"));
+    const parsed = JSON.parse(fs6.readFileSync(surface_path, "utf8"));
     if (parsed !== null && typeof parsed === "object" && parsed.entries !== void 0) previous = parsed;
   } catch {
   }
   if (previous !== null && previous.version !== next.version) {
     const delta = computeSurfaceDelta(previous, next);
     if (delta.changes.length > 0) {
-      fs5.mkdirSync(path5.dirname(delta_path), { recursive: true, mode: 448 });
-      fs5.writeFileSync(delta_path, `${JSON.stringify(delta, null, 2)}
+      fs6.mkdirSync(path5.dirname(delta_path), { recursive: true, mode: 448 });
+      fs6.writeFileSync(delta_path, `${JSON.stringify(delta, null, 2)}
 `, { mode: 384 });
       if (!state.QUIET) {
         const counts = {};
@@ -9494,8 +9726,8 @@ function _write_settings_surface_snapshot(installed_version) {
       }
     }
   }
-  fs5.mkdirSync(path5.dirname(surface_path), { recursive: true, mode: 448 });
-  fs5.writeFileSync(surface_path, `${JSON.stringify(next, null, 2)}
+  fs6.mkdirSync(path5.dirname(surface_path), { recursive: true, mode: 448 });
+  fs6.writeFileSync(surface_path, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 });
 }
 function arrayStrEqual(a, b) {
@@ -9931,7 +10163,7 @@ function _pid_is_agent_config(pid) {
 }
 function unlinkMissingOk(p) {
   try {
-    fs5.unlinkSync(p);
+    fs6.unlinkSync(p);
   } catch {
   }
 }
@@ -10016,7 +10248,7 @@ function _wizard_run_sync(cmd, env, cli) {
   let child;
   let log_fd = null;
   try {
-    log_fd = fs5.openSync(log_path, "w");
+    log_fd = fs6.openSync(log_path, "w");
     child = spawn(cmd[0], cmd.slice(1), {
       env,
       detached: true,
@@ -10034,7 +10266,7 @@ function _wizard_run_sync(cmd, env, cli) {
   } finally {
     if (log_fd !== null) {
       try {
-        fs5.closeSync(log_fd);
+        fs6.closeSync(log_fd);
       } catch {
       }
     }
@@ -10383,7 +10615,7 @@ function finalize_claude_model_tiers(project_root) {
   if (!isDir(claude_skills) || !isDir(augment_skills)) return 0;
   if (_read_consumer_auto_switch(project_root) !== "auto") return 0;
   let rendered = 0;
-  const entries = fs5.readdirSync(claude_skills).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const entries = fs6.readdirSync(claude_skills).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   for (const name of entries) {
     const entry = path5.join(claude_skills, name);
     const src_dir = path5.join(augment_skills, name);
@@ -10396,12 +10628,12 @@ function finalize_claude_model_tiers(project_root) {
     }
     if (tier === null || !(tier in TIER_TO_CLAUDE_MODEL) || !isDir(src_dir)) continue;
     if (isSymlink(entry) || isFile(entry)) {
-      fs5.unlinkSync(entry);
+      fs6.unlinkSync(entry);
     } else if (isDir(entry)) {
-      fs5.rmSync(entry, { recursive: true, force: true });
+      fs6.rmSync(entry, { recursive: true, force: true });
     }
     mkdirp(entry);
-    const srcFiles = fs5.readdirSync(src_dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const srcFiles = fs6.readdirSync(src_dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const fname of srcFiles) {
       if (fname === "SKILL.md") {
         writeText(
@@ -10409,7 +10641,7 @@ function finalize_claude_model_tiers(project_root) {
           render_native_model_md(readText(src_md), tier)
         );
       } else {
-        fs5.symlinkSync(
+        fs6.symlinkSync(
           path5.join("../../../.augment/skills", name, fname),
           path5.join(entry, fname)
         );
@@ -10564,7 +10796,7 @@ function _main_project_install(opts, project_root, parsed_tools, is_first_run) {
 function _resolvedArgv1() {
   if (process2.argv[1] === void 0) return void 0;
   try {
-    return fs5.realpathSync(path5.resolve(process2.argv[1]));
+    return fs6.realpathSync(path5.resolve(process2.argv[1]));
   } catch {
     return path5.resolve(process2.argv[1]);
   }