@event4u/agent-config 14.9.0 → 14.11.0

package/dist/cli-delegate/{chunk-H4VIVD4C.js → chunk-236PNQZK.js}

@@ -2,13 +2,13 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   ZodFirstPartyTypeKind,
   settingsSchema
-} from "./chunk-YM4GZDJG.js";
+} from "./chunk-L43NCYPB.js";
 import {
   main
 } from "./chunk-6RJA2F5A.js";
 import {
   RULE_SOURCE_REL
-} from "./chunk-B2ERU2VA.js";
+} from "./chunk-WOKWX5PL.js";
 import {
   ScopeMismatchError,
   build_claude_hook_matrix,
@@ -38,14 +38,15 @@ import {
 import {
   LEGACY_ALL,
   compute_active_pack_ids,
-  is_lab_artefact,
   is_pruned_under_scoped,
   load_lab_pack_ids,
   load_packs_registry,
   parseFrontmatter,
+  prune_lab_modules,
+  prune_modules_by,
   ruleFileArrives,
   ruleScopeFromSettings
-} from "./chunk-G23AT6GD.js";
+} from "./chunk-DMSZHXZS.js";
 import {
   require_dist
 } from "./chunk-OY53J6II.js";
@@ -267,9 +268,9 @@ function subtract_pointers(doc, entries) {
 // src/scripts/install.ts
 import { spawn, spawnSync } from "node:child_process";
 import * as crypto3 from "node:crypto";
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os3 from "node:os";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import process2 from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -389,9 +390,66 @@ function is_claude_builtin_name(slug) {
   return CLAUDE_CODE_BUILTIN_NAMES.has(slug.toLowerCase());
 }
 
-// src/scripts/_lib/rule_layer_overlap.ts
+// src/scripts/_lib/mcp_bridge.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
+var MCP_SERVER_KEY = "agent-config";
+var MCP_BRIDGE_ENTRY = {
+  mcpServers: {
+    [MCP_SERVER_KEY]: {
+      command: "npx",
+      args: ["-y", "@event4u/agent-config", "mcp-server"]
+    }
+  }
+};
+function makeEnsureMcpBridge(mergeJsonFile) {
+  return (projectRoot, force) => mergeJsonFile(path.join(projectRoot, ".mcp.json"), MCP_BRIDGE_ENTRY, force, ".mcp.json");
+}
+function projectionModeOf(raw) {
+  return raw === "scoped" ? "scoped" : raw === "tiered" ? "tiered" : "legacy-all";
+}
+function resolveTierB(packageRoot) {
+  const p = path.join(packageRoot, "agents", "runtime", "state", "skill-tiers.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(p, "utf-8"));
+    if (!Array.isArray(parsed.tier_b)) return null;
+    return new Set(parsed.tier_b.filter((n) => typeof n === "string"));
+  } catch {
+    return null;
+  }
+}
+function tierBPrunePredicate(tierB) {
+  return (mdPath) => tierB.has(path.basename(path.dirname(mdPath)));
+}
+function tierBAdvisory(packageRoot) {
+  const tierB = resolveTierB(packageRoot);
+  if (tierB === null || tierB.size === 0) return null;
+  return `\u2139\uFE0F  ${tierB.size} skill(s) are predicted to reach the model WITHOUT their description on a default 200k window.
+   Two levers, neither applied for you:
+   \u2022 raise \`skillListingBudgetFraction\` in your Claude Code settings \u2014 restores descriptions at a token cost (100% delivery of this catalogue measures ~13,003 tok)
+   \u2022 or set \`projection.mode: tiered\` to withhold them from the catalogue and reach them via the MCP server instead (opt-in, still unproven \u2014 see docs/mcp-server.md)`;
+}
+function applyTieredPrune(deployResults, packageRoot, pruneBy) {
+  const tierB = resolveTierB(packageRoot);
+  if (tierB === null || tierB.size === 0) {
+    return {
+      deployResults,
+      level: "warn",
+      message: "projection.mode: tiered but no skill-tier split exists (agents/runtime/state/skill-tiers.json) \u2014 shipping the full surface. Compute one with `./scripts-run src/scripts/compute_skill_tiers` first."
+    };
+  }
+  const [pruned, adjusted] = pruneBy(deployResults, tierBPrunePredicate(tierB));
+  return {
+    deployResults: adjusted,
+    level: "info",
+    message: `\u{1F9F9} Tiered install: pruned ${pruned} Tier-B skill artefact(s) \u2014 still reachable via the MCP server's suggest_skill_for_task / read_skill. Set projection.mode: legacy-all to restore the full surface.`
+  };
+}
+
+// src/scripts/_lib/rule_layer_overlap.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 var INSTALLER_PROVENANCE_KEYS = ["package", "source_path"];
 function stripProvenance(text) {
   const lines = text.split("\n");
@@ -445,14 +503,14 @@ function compareLayers(global_layer, project_layer) {
 function readRuleLayer(dir) {
   let names;
   try {
-    names = fs.readdirSync(dir);
+    names = fs2.readdirSync(dir);
   } catch {
     return null;
   }
   const files = /* @__PURE__ */ new Map();
   for (const name of names.filter((n) => n.endsWith(".md")).sort()) {
     try {
-      files.set(name, fs.readFileSync(path.join(dir, name), "utf-8"));
+      files.set(name, fs2.readFileSync(path2.join(dir, name), "utf-8"));
     } catch {
       continue;
     }
@@ -460,7 +518,7 @@ function readRuleLayer(dir) {
   return { dir, files };
 }
 function claudeMdExcludesGlob(dir) {
-  return `${path.resolve(dir).replace(/\/+$/, "")}/**`;
+  return `${path2.resolve(dir).replace(/\/+$/, "")}/**`;
 }
 function mergeClaudeMdExcludes(existing, entry) {
   if (!Array.isArray(existing)) return [entry];
@@ -491,25 +549,25 @@ function decideLayerAction(report, choice, global_dir, project_dir) {
 // src/scripts/_lib/install_drift.ts
 var import_yaml = __toESM(require_dist(), 1);
 import * as crypto from "node:crypto";
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 function expanduser(p) {
   if (p === "~") {
     return os.homedir();
   }
   if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
-    return path2.join(os.homedir(), p.slice(2));
+    return path3.join(os.homedir(), p.slice(2));
   }
   return p;
 }
 function resolve_entry_path(project_root, raw) {
   const p = expanduser(raw);
-  return path2.isAbsolute(p) ? p : path2.join(project_root, p);
+  return path3.isAbsolute(p) ? p : path3.join(project_root, p);
 }
 function sha256_of_file(p) {
   try {
-    return crypto.createHash("sha256").update(fs2.readFileSync(p)).digest("hex");
+    return crypto.createHash("sha256").update(fs3.readFileSync(p)).digest("hex");
   } catch {
     return null;
   }
@@ -518,7 +576,7 @@ function collect_drift(project_root, env) {
   const target = manifest_path(project_root, env);
   let text;
   try {
-    text = fs2.readFileSync(target, "utf-8");
+    text = fs3.readFileSync(target, "utf-8");
   } catch {
     return null;
   }
@@ -563,7 +621,7 @@ function collect_drift(project_root, env) {
         continue;
       }
       const resolved = resolve_entry_path(project_root, raw_path);
-      if (!fs2.existsSync(resolved)) {
+      if (!fs3.existsSync(resolved)) {
         out.push({
           tool_id,
           path: resolved,
@@ -616,9 +674,9 @@ function format_drift_report(entries) {
 }
 
 // src/scripts/_lib/skill_catalogue.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-var OBSERVATION_LOG = path3.join(
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+var OBSERVATION_LOG = path4.join(
   "agents",
   "evidence",
   "metrics",
@@ -662,9 +720,9 @@ function descriptionOf(frontmatter) {
   return "";
 }
 function readProjectedCatalogue(root) {
-  const names = fs3.readdirSync(root).filter((n) => fs3.existsSync(path3.join(root, n, "SKILL.md"))).sort();
+  const names = fs4.readdirSync(root).filter((n) => fs4.existsSync(path4.join(root, n, "SKILL.md"))).sort();
   return names.map((name, index) => {
-    const content = fs3.readFileSync(path3.join(root, name, "SKILL.md"), "utf-8");
+    const content = fs4.readFileSync(path4.join(root, name, "SKILL.md"), "utf-8");
     const frontmatter = frontmatterOf(content);
     const description = descriptionOf(frontmatter);
     return {
@@ -681,12 +739,12 @@ function truncationModeOf(record) {
   return record.truncation_mode ?? "per-entry";
 }
 function markdownFilesUnder(root) {
-  if (!fs3.existsSync(root)) return [];
+  if (!fs4.existsSync(root)) return [];
   const out = [];
   const walk = (dir) => {
-    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-      const full = path3.join(dir, entry.name);
-      if (fs3.statSync(full).isDirectory()) walk(full);
+    for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+      const full = path4.join(dir, entry.name);
+      if (fs4.statSync(full).isDirectory()) walk(full);
       else if (entry.name.endsWith(".md")) out.push(full);
     }
   };
@@ -694,9 +752,9 @@ function markdownFilesUnder(root) {
   return out;
 }
 function measureCatalogueVolume(host, root) {
-  const skillsRoot = path3.join(root, "skills");
-  const skills = fs3.existsSync(skillsRoot) ? readProjectedCatalogue(skillsRoot) : [];
-  const commandEntries = markdownFilesUnder(path3.join(root, "commands")).length;
+  const skillsRoot = path4.join(root, "skills");
+  const skills = fs4.existsSync(skillsRoot) ? readProjectedCatalogue(skillsRoot) : [];
+  const commandEntries = markdownFilesUnder(path4.join(root, "commands")).length;
   return {
     host,
     root,
@@ -740,6 +798,7 @@ function catalogueLimitWarning(volume, limit) {
 }
 function migrationEligibility(host, resolvedMode, currentSkillCount, limits) {
   if (resolvedMode === "scoped") return { eligible: false, reason: "already-scoped" };
+  if (resolvedMode === "tiered") return { eligible: false, reason: "already-tiered" };
   const limit = limits.get(host);
   if (limit === void 0) return { eligible: false, reason: "no-observation-for-host" };
   if (limit.projectedSkills === null) return { eligible: false, reason: "observation-not-comparable" };
@@ -773,9 +832,9 @@ function migrationPromptLines(host, eligibility, settingsPath) {
   ];
 }
 function readObservationLog(logPath) {
-  if (!fs3.existsSync(logPath)) return [];
+  if (!fs4.existsSync(logPath)) return [];
   const out = [];
-  for (const line of fs3.readFileSync(logPath, "utf-8").split("\n")) {
+  for (const line of fs4.readFileSync(logPath, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (trimmed.length === 0) continue;
     try {
@@ -816,8 +875,8 @@ function isInteractiveSession(probe) {
 
 // src/scripts/_lib/claude_desktop_bundler.ts
 import * as crypto2 from "node:crypto";
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 
 // src/scripts/_lib/zip_min.ts
 import * as zlib from "node:zlib";
@@ -924,7 +983,7 @@ function _is_excluded(rel_parts) {
 }
 function _is_dir(p) {
   try {
-    return fs4.statSync(p).isDirectory();
+    return fs5.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -936,12 +995,12 @@ function _compare_rel_parts(a, b) {
 }
 function _walk_skill_files(skill_dir) {
   const out = [];
-  const resolved = fs4.realpathSync(skill_dir);
+  const resolved = fs5.realpathSync(skill_dir);
   const walk = (root, relRoot) => {
     const dirNames = [];
     const fileNames = [];
-    for (const dirent of fs4.readdirSync(root, { withFileTypes: true })) {
-      const full = path4.join(root, dirent.name);
+    for (const dirent of fs5.readdirSync(root, { withFileTypes: true })) {
+      const full = path5.join(root, dirent.name);
       const isDir2 = dirent.isDirectory() || dirent.isSymbolicLink() && _is_dir(full);
       if (isDir2) {
         dirNames.push(dirent.name);
@@ -954,13 +1013,13 @@ function _walk_skill_files(skill_dir) {
       if (_is_excluded(rel_parts)) {
         continue;
       }
-      out.push([path4.join(root, fname), rel_parts]);
+      out.push([path5.join(root, fname), rel_parts]);
     }
     for (const dname of dirNames) {
       if (_is_excluded([dname])) {
         continue;
       }
-      walk(path4.join(root, dname), [...relRoot, dname]);
+      walk(path5.join(root, dname), [...relRoot, dname]);
     }
   };
   walk(resolved, []);
@@ -973,53 +1032,53 @@ function _manifest_digest(files) {
     const rel = rel_parts.join("/");
     h.update(Buffer.from(rel, "utf-8"));
     h.update(Buffer.from([0]));
-    h.update(crypto2.createHash("sha256").update(fs4.readFileSync(abs_path)).digest());
+    h.update(crypto2.createHash("sha256").update(fs5.readFileSync(abs_path)).digest());
     h.update(Buffer.from([0]));
   }
   return h.digest("hex");
 }
 function _atomic_write_zip(zip_path, files) {
-  fs4.mkdirSync(path4.dirname(zip_path), { recursive: true });
-  const stem = path4.basename(zip_path, path4.extname(zip_path));
-  const tmp_path = path4.join(
-    path4.dirname(zip_path),
+  fs5.mkdirSync(path5.dirname(zip_path), { recursive: true });
+  const stem = path5.basename(zip_path, path5.extname(zip_path));
+  const tmp_path = path5.join(
+    path5.dirname(zip_path),
     `.${stem}.${crypto2.randomBytes(6).toString("hex")}.zip.tmp`
   );
   try {
     const entries = files.map(([abs_path, rel_parts]) => ({
       name: rel_parts.join("/"),
-      data: fs4.readFileSync(abs_path)
+      data: fs5.readFileSync(abs_path)
     }));
-    fs4.writeFileSync(tmp_path, zip_write_sync(entries));
-    fs4.renameSync(tmp_path, zip_path);
+    fs5.writeFileSync(tmp_path, zip_write_sync(entries));
+    fs5.renameSync(tmp_path, zip_path);
   } finally {
-    if (fs4.existsSync(tmp_path)) {
-      fs4.unlinkSync(tmp_path);
+    if (fs5.existsSync(tmp_path)) {
+      fs5.unlinkSync(tmp_path);
     }
   }
 }
 function _write_if_changed(dest_dir, slug, files, force, written) {
   const digest = _manifest_digest(files);
-  const zip_path = path4.join(dest_dir, `${slug}.zip`);
-  const digest_path = path4.join(dest_dir, `${slug}.sha256`);
-  const recorded = fs4.existsSync(digest_path) ? fs4.readFileSync(digest_path, "utf-8").trim() : "";
-  if (!force && recorded === digest && fs4.existsSync(zip_path)) {
+  const zip_path = path5.join(dest_dir, `${slug}.zip`);
+  const digest_path = path5.join(dest_dir, `${slug}.sha256`);
+  const recorded = fs5.existsSync(digest_path) ? fs5.readFileSync(digest_path, "utf-8").trim() : "";
+  if (!force && recorded === digest && fs5.existsSync(zip_path)) {
     return;
   }
   _atomic_write_zip(zip_path, files);
-  fs4.writeFileSync(digest_path, digest + "\n", "utf-8");
+  fs5.writeFileSync(digest_path, digest + "\n", "utf-8");
   written.push(zip_path);
 }
 function build_skill_bundles(package_root, dest_dir, force = false, curation = null) {
-  const skills_root = path4.join(package_root, "dist/agent-src", "skills");
+  const skills_root = path5.join(package_root, "dist/agent-src", "skills");
   if (!_is_dir(skills_root)) {
     return [];
   }
-  fs4.mkdirSync(dest_dir, { recursive: true });
+  fs5.mkdirSync(dest_dir, { recursive: true });
   const written = [];
-  for (const name of fs4.readdirSync(skills_root).sort()) {
-    const entry = path4.join(skills_root, name);
-    const isSymlink2 = fs4.lstatSync(entry).isSymbolicLink();
+  for (const name of fs5.readdirSync(skills_root).sort()) {
+    const entry = path5.join(skills_root, name);
+    const isSymlink2 = fs5.lstatSync(entry).isSymbolicLink();
     if (!(_is_dir(entry) || isSymlink2)) {
       continue;
     }
@@ -1027,8 +1086,8 @@ function build_skill_bundles(package_root, dest_dir, force = false, curation = n
     if (curation !== null && !curation.includes(skill_name)) {
       continue;
     }
-    const skill_md = path4.join(entry, "SKILL.md");
-    if (!fs4.existsSync(skill_md)) {
+    const skill_md = path5.join(entry, "SKILL.md");
+    if (!fs5.existsSync(skill_md)) {
       continue;
     }
     const files = _walk_skill_files(entry);
@@ -1040,15 +1099,15 @@ function build_skill_bundles(package_root, dest_dir, force = false, curation = n
   return written;
 }
 function _command_slug(source_file, commands_root) {
-  const rel = path4.relative(commands_root, source_file);
-  const noExt = rel.slice(0, rel.length - path4.extname(rel).length);
-  return noExt.split(path4.sep).join("-");
+  const rel = path5.relative(commands_root, source_file);
+  const noExt = rel.slice(0, rel.length - path5.extname(rel).length);
+  return noExt.split(path5.sep).join("-");
 }
 function _iter_command_files(commands_root) {
   const found = [];
   const walk = (dir) => {
-    for (const dirent of fs4.readdirSync(dir, { withFileTypes: true })) {
-      const full = path4.join(dir, dirent.name);
+    for (const dirent of fs5.readdirSync(dir, { withFileTypes: true })) {
+      const full = path5.join(dir, dirent.name);
       if (dirent.isDirectory() || dirent.isSymbolicLink() && _is_dir(full)) {
         walk(full);
       } else if (dirent.name.endsWith(".md")) {
@@ -1058,21 +1117,21 @@ function _iter_command_files(commands_root) {
   };
   walk(commands_root);
   found.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  return found.filter((source_file) => path4.basename(source_file) !== "AGENTS.md");
+  return found.filter((source_file) => path5.basename(source_file) !== "AGENTS.md");
 }
 function build_command_bundles(package_root, dest_dir, force = false, curation = null) {
-  const commands_root = path4.join(package_root, "dist/agent-src", "commands");
+  const commands_root = path5.join(package_root, "dist/agent-src", "commands");
   if (!_is_dir(commands_root)) {
     return [];
   }
-  const skills_root = path4.join(package_root, "dist/agent-src", "skills");
+  const skills_root = path5.join(package_root, "dist/agent-src", "skills");
   let skill_names = /* @__PURE__ */ new Set();
   if (_is_dir(skills_root)) {
     skill_names = new Set(
-      fs4.readdirSync(skills_root).filter((name) => _is_dir(path4.join(skills_root, name)))
+      fs5.readdirSync(skills_root).filter((name) => _is_dir(path5.join(skills_root, name)))
     );
   }
-  fs4.mkdirSync(dest_dir, { recursive: true });
+  fs5.mkdirSync(dest_dir, { recursive: true });
   const written = [];
   for (const source_file of _iter_command_files(commands_root)) {
     const slug = _command_slug(source_file, commands_root);
@@ -1082,33 +1141,33 @@ function build_command_bundles(package_root, dest_dir, force = false, curation =
     if (curation !== null && !curation.includes(slug)) {
       continue;
     }
-    const files = [[fs4.realpathSync(source_file), ["SKILL.md"]]];
+    const files = [[fs5.realpathSync(source_file), ["SKILL.md"]]];
     _write_if_changed(dest_dir, slug, files, force, written);
   }
   return written;
 }
 
 // src/install/partitionEligibility.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as os2 from "node:os";
 
 // src/install/hostLayerFingerprint.ts
 import { createHash as createHash4 } from "node:crypto";
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 var FINGERPRINT_SCHEMA = 1;
 function collectFiles(dir) {
   const out = [];
   const walk = (d) => {
     let entries;
     try {
-      entries = fs5.readdirSync(d, { withFileTypes: true });
+      entries = fs6.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
     const sorted = [...entries].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
     for (const e of sorted) {
-      const p = path5.join(d, e.name);
+      const p = path6.join(d, e.name);
       if (e.isDirectory()) {
         walk(p);
       } else if (e.isFile()) {
@@ -1125,10 +1184,10 @@ function fingerprintLayers(layers) {
   for (const layer of layers) {
     h.update(`layer:${layer.label}\0`);
     for (const file of collectFiles(layer.root)) {
-      h.update(path5.relative(layer.root, file));
+      h.update(path6.relative(layer.root, file));
       h.update("\0");
       try {
-        h.update(fs5.readFileSync(file));
+        h.update(fs6.readFileSync(file));
       } catch {
         h.update("\0unreadable\0");
       }
@@ -1138,11 +1197,11 @@ function fingerprintLayers(layers) {
   return h.digest("hex");
 }
 function hostLayerInputs(userHome) {
-  const claude = path5.join(userHome, ".claude");
+  const claude = path6.join(userHome, ".claude");
   return [
-    { label: "rules", root: path5.join(claude, "rules") },
-    { label: "skills", root: path5.join(claude, "skills") },
-    { label: "commands", root: path5.join(claude, "commands") }
+    { label: "rules", root: path6.join(claude, "rules") },
+    { label: "skills", root: path6.join(claude, "skills") },
+    { label: "commands", root: path6.join(claude, "commands") }
   ];
 }
 
@@ -1151,7 +1210,7 @@ var MAINTAINER_WORKSPACE = "agent-config-maintainer";
 function isExclusivelyPackageOnly(source_path) {
   let meta;
   try {
-    [meta] = parseFrontmatter(fs6.readFileSync(source_path, "utf-8"));
+    [meta] = parseFrontmatter(fs7.readFileSync(source_path, "utf-8"));
   } catch {
     return false;
   }
@@ -2536,8 +2595,8 @@ var zodToJsonSchema = (schema, options) => {
 };
 
 // src/scripts/_lib/module_detection.ts
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
 var _SKIP_DIRS = /* @__PURE__ */ new Set([".module-template", ".example"]);
 var _RULES = [
   ["app/Modules", "laravel-hmvc", "App\\Modules\\{ModuleName}"],
@@ -2551,14 +2610,14 @@ var _RULES = [
 ];
 function _isDir(p) {
   try {
-    return fs7.statSync(p).isDirectory();
+    return fs8.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _isFile(p) {
   try {
-    return fs7.statSync(p).isFile();
+    return fs8.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -2572,13 +2631,13 @@ function _isUpperChar(ch) {
 function _list_module_subdirs(root) {
   let entries;
   try {
-    entries = fs7.readdirSync(root).sort();
+    entries = fs8.readdirSync(root).sort();
   } catch {
     return [];
   }
   const out = [];
   for (const name of entries) {
-    if (!_isDir(path6.join(root, name))) {
+    if (!_isDir(path7.join(root, name))) {
       continue;
     }
     if (name.startsWith(".")) {
@@ -2600,11 +2659,11 @@ function _score_confidence(stack, root, subdirs) {
     return capitalized.length > 0 ? "high" : "medium";
   }
   if (stack === "node-monorepo") {
-    const withPkgJson = subdirs.filter((name) => _isFile(path6.join(root, name, "package.json")));
+    const withPkgJson = subdirs.filter((name) => _isFile(path7.join(root, name, "package.json")));
     return withPkgJson.length > 0 ? "high" : "medium";
   }
   if (stack === "python-src") {
-    const withInit = subdirs.filter((name) => _isFile(path6.join(root, name, "__init__.py")));
+    const withInit = subdirs.filter((name) => _isFile(path7.join(root, name, "__init__.py")));
     return withInit.length > 0 ? "high" : "medium";
   }
   if (stack === "go-internal") {
@@ -2616,7 +2675,7 @@ function detect_module_roots(project_root) {
   const high = [];
   const medium = [];
   for (const [rel_path, stack, namespace_template] of _RULES) {
-    const abs_path = path6.join(project_root, rel_path);
+    const abs_path = path7.join(project_root, rel_path);
     if (!_isDir(abs_path)) {
       continue;
     }
@@ -2638,7 +2697,7 @@ function detect_module_roots(project_root) {
 }
 
 // src/scripts/_lib/model_tier.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 var TIER_TO_CLAUDE_MODEL = {
   frontier: "fable",
   high: "opus",
@@ -2647,8 +2706,8 @@ var TIER_TO_CLAUDE_MODEL = {
 };
 var MODEL_TIER_RE = /^model_tier:\s*"?([a-z]+)"?\s*$/m;
 function read_model_tier(skill_md) {
-  if (!fs8.existsSync(skill_md)) return null;
-  const text = fs8.readFileSync(skill_md).toString("utf-8");
+  if (!fs9.existsSync(skill_md)) return null;
+  const text = fs9.readFileSync(skill_md).toString("utf-8");
   if (!text.startsWith("---\n")) return null;
   const end = text.indexOf("\n---\n", 4);
   if (end === -1) return null;
@@ -2682,34 +2741,34 @@ var ArgparseExit = class extends Error {
 function expanduser2(p) {
   if (p === "~") return os3.homedir();
   if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return path7.join(os3.homedir(), p.slice(2));
+    return path8.join(os3.homedir(), p.slice(2));
   }
   return p;
 }
 function resolvePath(p) {
   try {
-    return fs9.realpathSync(path7.resolve(p));
+    return fs10.realpathSync(path8.resolve(p));
   } catch {
-    return path7.resolve(p);
+    return path8.resolve(p);
   }
 }
 function isFile(p) {
   try {
-    return fs9.statSync(p).isFile();
+    return fs10.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir(p) {
   try {
-    return fs9.statSync(p).isDirectory();
+    return fs10.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function pathExists(p) {
   try {
-    fs9.statSync(p);
+    fs10.statSync(p);
     return true;
   } catch {
     return false;
@@ -2717,24 +2776,24 @@ function pathExists(p) {
 }
 function isSymlink(p) {
   try {
-    return fs9.lstatSync(p).isSymbolicLink();
+    return fs10.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function readText(p) {
-  return fs9.readFileSync(p, "utf-8");
+  return fs10.readFileSync(p, "utf-8");
 }
 function writeText(p, content) {
-  fs9.writeFileSync(p, content, "utf-8");
+  fs10.writeFileSync(p, content, "utf-8");
 }
 function mkdirp(p) {
-  fs9.mkdirSync(p, { recursive: true });
+  fs10.mkdirSync(p, { recursive: true });
 }
 function sortedGlobStems(directory, suffix) {
   let entries;
   try {
-    entries = fs9.readdirSync(directory);
+    entries = fs10.readdirSync(directory);
   } catch {
     return [];
   }
@@ -2754,7 +2813,7 @@ function sortedGlobStems(directory, suffix) {
 function countZips(directory) {
   if (!isDir(directory)) return 0;
   let n = 0;
-  for (const name of fs9.readdirSync(directory)) {
+  for (const name of fs10.readdirSync(directory)) {
     if (name.endsWith(".zip")) n += 1;
   }
   return n;
@@ -2762,35 +2821,35 @@ function countZips(directory) {
 function sha256OfFile(p) {
   let data;
   try {
-    data = fs9.readFileSync(p);
+    data = fs10.readFileSync(p);
   } catch {
     return null;
   }
   return crypto3.createHash("sha256").update(data).digest("hex");
 }
 function atomicWrite0644(target, body, prefix) {
-  const dir = path7.dirname(target);
-  const tmpName = path7.join(
+  const dir = path8.dirname(target);
+  const tmpName = path8.join(
     dir,
     `${prefix}${process2.pid}.${crypto3.randomBytes(6).toString("hex")}.yml.tmp`
   );
   let fd = null;
   try {
-    fd = fs9.openSync(tmpName, "wx", 420);
-    fs9.writeFileSync(fd, body, "utf-8");
-    fs9.closeSync(fd);
+    fd = fs10.openSync(tmpName, "wx", 420);
+    fs10.writeFileSync(fd, body, "utf-8");
+    fs10.closeSync(fd);
     fd = null;
-    fs9.chmodSync(tmpName, 420);
-    fs9.renameSync(tmpName, target);
+    fs10.chmodSync(tmpName, 420);
+    fs10.renameSync(tmpName, target);
   } catch (err) {
     if (fd !== null) {
       try {
-        fs9.closeSync(fd);
+        fs10.closeSync(fd);
       } catch {
       }
     }
     try {
-      fs9.unlinkSync(tmpName);
+      fs10.unlinkSync(tmpName);
     } catch {
     }
     throw err;
@@ -2914,12 +2973,12 @@ var LEGACY_SETTINGS_FILE = ".agent-settings";
 var LEGACY_BACKUP_FILE = ".agent-settings.backup.key-value";
 var SETTINGS_SUBDIR = ["agents", "settings"];
 function _canonical_settings_target(project_root) {
-  return path7.join(project_root, ...SETTINGS_SUBDIR, SETTINGS_FILE);
+  return path8.join(project_root, ...SETTINGS_SUBDIR, SETTINGS_FILE);
 }
 function _resolve_settings_read(project_root) {
   const canonical = _canonical_settings_target(project_root);
   if (pathExists(canonical)) return canonical;
-  const legacy = path7.join(project_root, SETTINGS_FILE);
+  const legacy = path8.join(project_root, SETTINGS_FILE);
   if (pathExists(legacy)) return legacy;
   return canonical;
 }
@@ -2983,9 +3042,9 @@ function fail(msg) {
   throw new SystemExitError(1);
 }
 function detect_package_root(project_root) {
-  const npm_path = path7.join(project_root, "node_modules", "@event4u", "agent-config");
+  const npm_path = path8.join(project_root, "node_modules", "@event4u", "agent-config");
   if (isDir(npm_path)) return resolvePath(npm_path);
-  if (pathExists(path7.join(project_root, "src", "config", "profiles", "minimal.ini"))) {
+  if (pathExists(path8.join(project_root, "src", "config", "profiles", "minimal.ini"))) {
     return project_root;
   }
   fail(
@@ -2993,12 +3052,12 @@ function detect_package_root(project_root) {
   );
 }
 function detect_package_type(package_root) {
-  if (package_root.split(path7.sep).includes("node_modules")) return "npm";
+  if (package_root.split(path8.sep).includes("node_modules")) return "npm";
   return "local";
 }
 function detect_package_type_for_project(project_root, package_root) {
   const npm_path = resolvePath(
-    path7.join(project_root, "node_modules", "@event4u", "agent-config")
+    path8.join(project_root, "node_modules", "@event4u", "agent-config")
   );
   const package_resolved = resolvePath(package_root);
   if (package_resolved === npm_path) return "npm";
@@ -3018,7 +3077,7 @@ function ensure_directory(p) {
   mkdirp(p);
 }
 function write_file(p, content) {
-  ensure_directory(path7.dirname(p));
+  ensure_directory(path8.dirname(p));
   writeText(p, content);
 }
 function read_json_file(p) {
@@ -3189,7 +3248,7 @@ function _append_unknown_legacy(rendered, legacy_values, unknown_keys) {
   return rendered + "\n" + suffix;
 }
 function _migrate_legacy_if_present(project_root, template_body) {
-  const legacy_target = path7.join(project_root, LEGACY_SETTINGS_FILE);
+  const legacy_target = path8.join(project_root, LEGACY_SETTINGS_FILE);
   if (!isFile(legacy_target)) return null;
   const legacy_text = readText(legacy_target);
   const [values, unknown] = _parse_legacy_settings(legacy_text);
@@ -3204,9 +3263,9 @@ function _migrate_legacy_if_present(project_root, template_body) {
     }
   }
   rendered = _append_unknown_legacy(rendered, values, unknown);
-  const backup_target = path7.join(project_root, LEGACY_BACKUP_FILE);
+  const backup_target = path8.join(project_root, LEGACY_BACKUP_FILE);
   writeText(backup_target, legacy_text);
-  fs9.unlinkSync(legacy_target);
+  fs10.unlinkSync(legacy_target);
   info(`Migrated legacy ${LEGACY_SETTINGS_FILE} \u2192 ${SETTINGS_FILE}`);
   info(`Backup saved to ${LEGACY_BACKUP_FILE}`);
   if (unknown.length > 0) {
@@ -3241,7 +3300,7 @@ function _render_template(template, profile_values) {
   return body;
 }
 function _load_valid_user_types(package_root) {
-  const directory = path7.join(package_root, USER_TYPES_DIR);
+  const directory = path8.join(package_root, USER_TYPES_DIR);
   if (!isDir(directory)) return [];
   return sortedGlobStems(directory, ".yml");
 }
@@ -3298,8 +3357,8 @@ function splitlinesKeepends(text) {
 }
 function ensure_agent_settings(project_root, package_root, profile, force, user_type = "", packs = null) {
   const target = _canonical_settings_target(project_root);
-  const profile_source = path7.join(package_root, "src", "config", "profiles", `${profile}.ini`);
-  const template_source = path7.join(package_root, "src", "config", "agent-settings.template.yml");
+  const profile_source = path8.join(package_root, "src", "config", "profiles", `${profile}.ini`);
+  const template_source = path8.join(package_root, "src", "config", "agent-settings.template.yml");
   if (!pathExists(profile_source)) fail(`Missing profile preset: ${profile_source}`);
   if (!pathExists(template_source)) fail(`Missing settings template: ${template_source}`);
   const template = readText(template_source);
@@ -3313,21 +3372,21 @@ function ensure_agent_settings(project_root, package_root, profile, force, user_
   if (profile_values["rule_loading_tier"] !== profile) {
     const got = "rule_loading_tier" in profile_values ? `'${profile_values["rule_loading_tier"]}'` : "None";
     fail(
-      `Profile preset ${path7.basename(profile_source)} has rule_loading_tier=${got} but --profile=${profile}`
+      `Profile preset ${path8.basename(profile_source)} has rule_loading_tier=${got} but --profile=${profile}`
     );
   }
   profile_values["user_type"] = _validate_user_type(package_root, user_type);
   let template_body = _render_template(template, profile_values);
   template_body = _inject_packs(template_body, packs ?? []);
-  const legacy_root = path7.join(project_root, SETTINGS_FILE);
+  const legacy_root = path8.join(project_root, SETTINGS_FILE);
   if (isFile(legacy_root) && !pathExists(target)) {
-    mkdirp(path7.dirname(target));
+    mkdirp(path8.dirname(target));
     writeText(target, readText(legacy_root));
-    fs9.unlinkSync(legacy_root);
+    fs10.unlinkSync(legacy_root);
     success(`Migrated ${SETTINGS_FILE} \u2192 agents/settings/${SETTINGS_FILE} (ADR-038)`);
     return;
   }
-  const legacy_target = path7.join(project_root, LEGACY_SETTINGS_FILE);
+  const legacy_target = path8.join(project_root, LEGACY_SETTINGS_FILE);
   if (isFile(legacy_target) && pathExists(target)) {
     warn(
       `Both ${SETTINGS_FILE} and legacy ${LEGACY_SETTINGS_FILE} exist. Skipping migration to avoid overwriting ${SETTINGS_FILE}. Delete one of them manually and re-run.`
@@ -3344,7 +3403,7 @@ function ensure_agent_settings(project_root, package_root, profile, force, user_
     skip(`${SETTINGS_FILE} already exists`);
     return;
   }
-  mkdirp(path7.dirname(target));
+  mkdirp(path8.dirname(target));
   write_file(target, template_body);
   const user_type_value = profile_values["user_type"] ?? "";
   const suffix = user_type_value ? `, user_type=${user_type_value}` : "";
@@ -3357,7 +3416,7 @@ function ensure_vscode_bridge(project_root, package_type, force) {
   const plugin_path = plugin_paths[package_type] ?? "./plugin/agent-config";
   const bridge = { "chat.pluginLocations": { [plugin_path]: true } };
   return merge_json_file(
-    path7.join(project_root, ".vscode", "settings.json"),
+    path8.join(project_root, ".vscode", "settings.json"),
     bridge,
     force,
     ".vscode/settings.json"
@@ -3366,14 +3425,14 @@ function ensure_vscode_bridge(project_root, package_type, force) {
 function ensure_augment_bridge(project_root, force) {
   const bridge = { enabledPlugins: { "agent-config@event4u": true } };
   return merge_json_file(
-    path7.join(project_root, ".augment", "settings.json"),
+    path8.join(project_root, ".augment", "settings.json"),
     bridge,
     force,
     ".augment/settings.json"
   );
 }
-var AUGMENT_USER_DIR = path7.join(os3.homedir(), ".augment");
-var AUGMENT_USER_HOOKS_DIR = path7.join(AUGMENT_USER_DIR, "hooks");
+var AUGMENT_USER_DIR = path8.join(os3.homedir(), ".augment");
+var AUGMENT_USER_HOOKS_DIR = path8.join(AUGMENT_USER_DIR, "hooks");
 var AUGMENT_DISPATCHER_TRAMPOLINE = "augment-dispatcher.sh";
 var AUGMENT_LEGACY_TRAMPOLINES = [
   "augment-chat-history.sh",
@@ -3389,29 +3448,29 @@ var AUGMENT_DISPATCHER_BINDINGS = [
   ["post_tool_use", "PostToolUse"]
 ];
 function _deploy_augment_trampoline(package_root, name, force) {
-  const src = path7.join(package_root, "scripts", "hooks", name);
+  const src = path8.join(package_root, "scripts", "hooks", name);
   if (!pathExists(src)) {
     skip(`augment trampoline missing in package: ${src}`);
     return null;
   }
   mkdirp(AUGMENT_USER_HOOKS_DIR);
-  const dst = path7.join(AUGMENT_USER_HOOKS_DIR, name);
+  const dst = path8.join(AUGMENT_USER_HOOKS_DIR, name);
   const src_text = readText(src);
   if (pathExists(dst) && readText(dst) === src_text && !force) {
     skip(`~/.augment/hooks/${name} already up to date`);
   } else {
     writeText(dst, src_text);
-    fs9.chmodSync(dst, 493);
+    fs10.chmodSync(dst, 493);
     success(`~/.augment/hooks/${name} installed`);
   }
   return dst;
 }
 function _remove_legacy_augment_trampolines() {
   for (const name of AUGMENT_LEGACY_TRAMPOLINES) {
-    const legacy = path7.join(AUGMENT_USER_HOOKS_DIR, name);
+    const legacy = path8.join(AUGMENT_USER_HOOKS_DIR, name);
     try {
       if (isFile(legacy)) {
-        fs9.unlinkSync(legacy);
+        fs10.unlinkSync(legacy);
         skip(`removed legacy ~/.augment/hooks/${name}`);
       }
     } catch (err) {
@@ -3431,7 +3490,7 @@ function ensure_augment_user_hooks(package_root, force) {
   }
   const settings_patch = { hooks: per_event };
   return merge_json_file(
-    path7.join(AUGMENT_USER_DIR, "settings.json"),
+    path8.join(AUGMENT_USER_DIR, "settings.json"),
     settings_patch,
     force,
     "~/.augment/settings.json"
@@ -3456,7 +3515,7 @@ function _heal_legacy_claude_plugin_ids(p) {
   return removed;
 }
 function ensure_claude_bridge(project_root, force) {
-  const target = path7.join(project_root, ".claude", "settings.json");
+  const target = path8.join(project_root, ".claude", "settings.json");
   const healed = _heal_legacy_claude_plugin_ids(target);
   for (const pid of healed) {
     success(`.claude/settings.json: removed stale plugin id \`${pid}\``);
@@ -3464,6 +3523,8 @@ function ensure_claude_bridge(project_root, force) {
   const bridge = { enabledPlugins: { [CLAUDE_PLUGIN_ID]: true } };
   return merge_json_file(target, bridge, force || healed.length > 0, ".claude/settings.json");
 }
+var ensure_mcp_bridge = makeEnsureMcpBridge(merge_json_file);
+var _tier_b_advisory = tierBAdvisory;
 var CURSOR_DISPATCHER_BINDINGS = [
   ["session_start", "sessionStart"],
   ["session_end", "sessionEnd"],
@@ -3481,29 +3542,29 @@ function ensure_cursor_bridge(project_root, force) {
   }
   const bridge = { version: 1, hooks };
   return merge_json_file(
-    path7.join(project_root, ".cursor", "hooks.json"),
+    path8.join(project_root, ".cursor", "hooks.json"),
     bridge,
     force,
     ".cursor/hooks.json"
   );
 }
-var CURSOR_USER_DIR = path7.join(os3.homedir(), ".cursor");
-var CURSOR_USER_HOOKS_DIR = path7.join(CURSOR_USER_DIR, "hooks");
+var CURSOR_USER_DIR = path8.join(os3.homedir(), ".cursor");
+var CURSOR_USER_HOOKS_DIR = path8.join(CURSOR_USER_DIR, "hooks");
 var CURSOR_DISPATCHER_TRAMPOLINE = "cursor-dispatcher.sh";
 function ensure_cursor_user_hooks(package_root, force) {
-  const src = path7.join(package_root, "scripts", "hooks", CURSOR_DISPATCHER_TRAMPOLINE);
+  const src = path8.join(package_root, "scripts", "hooks", CURSOR_DISPATCHER_TRAMPOLINE);
   if (!pathExists(src)) {
     skip(`cursor trampoline missing in package: ${src}`);
     return [];
   }
   mkdirp(CURSOR_USER_HOOKS_DIR);
-  const dst = path7.join(CURSOR_USER_HOOKS_DIR, CURSOR_DISPATCHER_TRAMPOLINE);
+  const dst = path8.join(CURSOR_USER_HOOKS_DIR, CURSOR_DISPATCHER_TRAMPOLINE);
   const src_text = readText(src);
   if (pathExists(dst) && readText(dst) === src_text && !force) {
     skip(`~/.cursor/hooks/${CURSOR_DISPATCHER_TRAMPOLINE} already up to date`);
   } else {
     writeText(dst, src_text);
-    fs9.chmodSync(dst, 493);
+    fs10.chmodSync(dst, 493);
     success(`~/.cursor/hooks/${CURSOR_DISPATCHER_TRAMPOLINE} installed`);
   }
   const hooks = {};
@@ -3512,7 +3573,7 @@ function ensure_cursor_user_hooks(package_root, force) {
   }
   const settings_patch = { version: 1, hooks };
   return merge_json_file(
-    path7.join(CURSOR_USER_DIR, "hooks.json"),
+    path8.join(CURSOR_USER_DIR, "hooks.json"),
     settings_patch,
     force,
     "~/.cursor/hooks.json"
@@ -3555,12 +3616,12 @@ exit 0
 `;
 }
 function ensure_cline_bridge(project_root, force) {
-  const hooks_dir = path7.join(project_root, ".clinerules", "hooks");
+  const hooks_dir = path8.join(project_root, ".clinerules", "hooks");
   mkdirp(hooks_dir);
   const workspace_quoted = shlexQuote(resolvePath(project_root));
   let written = 0;
   for (const [ac_event, native_event] of CLINE_DISPATCHER_BINDINGS) {
-    const target = path7.join(hooks_dir, native_event);
+    const target = path8.join(hooks_dir, native_event);
     const body = clineProjectHookBody(native_event, ac_event, workspace_quoted);
     if (pathExists(target) && readText(target) === body && !force) {
       continue;
@@ -3570,7 +3631,7 @@ function ensure_cline_bridge(project_root, force) {
       continue;
     }
     writeText(target, body);
-    fs9.chmodSync(target, 493);
+    fs10.chmodSync(target, 493);
     written += 1;
   }
   if (written) {
@@ -3579,27 +3640,27 @@ function ensure_cline_bridge(project_root, force) {
     skip(".clinerules/hooks/ already up to date");
   }
 }
-var CLINE_USER_DIR = path7.join(os3.homedir(), "Documents", "Cline", "Hooks");
+var CLINE_USER_DIR = path8.join(os3.homedir(), "Documents", "Cline", "Hooks");
 var CLINE_DISPATCHER_TRAMPOLINE = "cline-dispatcher.sh";
 function ensure_cline_user_hooks(package_root, force) {
-  const src = path7.join(package_root, "scripts", "hooks", CLINE_DISPATCHER_TRAMPOLINE);
+  const src = path8.join(package_root, "scripts", "hooks", CLINE_DISPATCHER_TRAMPOLINE);
   if (!pathExists(src)) {
     skip(`cline trampoline missing in package: ${src}`);
     return;
   }
   mkdirp(CLINE_USER_DIR);
-  const trampoline = path7.join(CLINE_USER_DIR, CLINE_DISPATCHER_TRAMPOLINE);
+  const trampoline = path8.join(CLINE_USER_DIR, CLINE_DISPATCHER_TRAMPOLINE);
   const src_text = readText(src);
   if (pathExists(trampoline) && readText(trampoline) === src_text && !force) {
     skip(`~/Documents/Cline/Hooks/${CLINE_DISPATCHER_TRAMPOLINE} already up to date`);
   } else {
     writeText(trampoline, src_text);
-    fs9.chmodSync(trampoline, 493);
+    fs10.chmodSync(trampoline, 493);
     success(`~/Documents/Cline/Hooks/${CLINE_DISPATCHER_TRAMPOLINE} installed`);
   }
   const trampoline_quoted = shlexQuote(trampoline);
   for (const [ac_event, native_event] of CLINE_DISPATCHER_BINDINGS) {
-    const wrapper = path7.join(CLINE_USER_DIR, native_event);
+    const wrapper = path8.join(CLINE_USER_DIR, native_event);
     const body = `#!/usr/bin/env bash
 # Generated by event4u/agent-config install.py \u2014 DO NOT EDIT.
 # User-scope Cline hook for ${native_event} \u2192 agent-config ${ac_event}.
@@ -3609,7 +3670,7 @@ exec ${trampoline_quoted} ${ac_event} ${native_event}
       continue;
     }
     writeText(wrapper, body);
-    fs9.chmodSync(wrapper, 493);
+    fs10.chmodSync(wrapper, 493);
   }
 }
 var WINDSURF_DISPATCHER_BINDINGS = [
@@ -3630,29 +3691,29 @@ function ensure_windsurf_bridge(project_root, force) {
   }
   const bridge = { hooks };
   return merge_json_file(
-    path7.join(project_root, ".windsurf", "hooks.json"),
+    path8.join(project_root, ".windsurf", "hooks.json"),
     bridge,
     force,
     ".windsurf/hooks.json"
   );
 }
-var WINDSURF_USER_DIR = path7.join(os3.homedir(), ".codeium", "windsurf");
-var WINDSURF_USER_HOOKS_DIR = path7.join(WINDSURF_USER_DIR, "hooks");
+var WINDSURF_USER_DIR = path8.join(os3.homedir(), ".codeium", "windsurf");
+var WINDSURF_USER_HOOKS_DIR = path8.join(WINDSURF_USER_DIR, "hooks");
 var WINDSURF_DISPATCHER_TRAMPOLINE = "windsurf-dispatcher.sh";
 function ensure_windsurf_user_hooks(package_root, force) {
-  const src = path7.join(package_root, "scripts", "hooks", WINDSURF_DISPATCHER_TRAMPOLINE);
+  const src = path8.join(package_root, "scripts", "hooks", WINDSURF_DISPATCHER_TRAMPOLINE);
   if (!pathExists(src)) {
     skip(`windsurf trampoline missing in package: ${src}`);
     return [];
   }
   mkdirp(WINDSURF_USER_HOOKS_DIR);
-  const dst = path7.join(WINDSURF_USER_HOOKS_DIR, WINDSURF_DISPATCHER_TRAMPOLINE);
+  const dst = path8.join(WINDSURF_USER_HOOKS_DIR, WINDSURF_DISPATCHER_TRAMPOLINE);
   const src_text = readText(src);
   if (pathExists(dst) && readText(dst) === src_text && !force) {
     skip(`~/.codeium/windsurf/hooks/${WINDSURF_DISPATCHER_TRAMPOLINE} already up to date`);
   } else {
     writeText(dst, src_text);
-    fs9.chmodSync(dst, 493);
+    fs10.chmodSync(dst, 493);
     success(`~/.codeium/windsurf/hooks/${WINDSURF_DISPATCHER_TRAMPOLINE} installed`);
   }
   const hooks = {};
@@ -3664,7 +3725,7 @@ function ensure_windsurf_user_hooks(package_root, force) {
   }
   const settings_patch = { hooks };
   return merge_json_file(
-    path7.join(WINDSURF_USER_DIR, "hooks.json"),
+    path8.join(WINDSURF_USER_DIR, "hooks.json"),
     settings_patch,
     force,
     "~/.codeium/windsurf/hooks.json"
@@ -3693,43 +3754,43 @@ function _gemini_hooks_dict(command_factory) {
 function ensure_gemini_bridge(project_root, force) {
   const bridge = { hooks: _gemini_hooks_dict(_gemini_dispatch_command) };
   return merge_json_file(
-    path7.join(project_root, ".gemini", "settings.json"),
+    path8.join(project_root, ".gemini", "settings.json"),
     bridge,
     force,
     ".gemini/settings.json"
   );
 }
-var GEMINI_USER_DIR = path7.join(os3.homedir(), ".gemini");
-var GEMINI_USER_HOOKS_DIR = path7.join(GEMINI_USER_DIR, "hooks");
+var GEMINI_USER_DIR = path8.join(os3.homedir(), ".gemini");
+var GEMINI_USER_HOOKS_DIR = path8.join(GEMINI_USER_DIR, "hooks");
 var GEMINI_DISPATCHER_TRAMPOLINE = "gemini-dispatcher.sh";
 function ensure_gemini_user_hooks(package_root, force) {
-  const src = path7.join(package_root, "scripts", "hooks", GEMINI_DISPATCHER_TRAMPOLINE);
+  const src = path8.join(package_root, "scripts", "hooks", GEMINI_DISPATCHER_TRAMPOLINE);
   if (!pathExists(src)) {
     skip(`gemini trampoline missing in package: ${src}`);
     return [];
   }
   mkdirp(GEMINI_USER_HOOKS_DIR);
-  const dst = path7.join(GEMINI_USER_HOOKS_DIR, GEMINI_DISPATCHER_TRAMPOLINE);
+  const dst = path8.join(GEMINI_USER_HOOKS_DIR, GEMINI_DISPATCHER_TRAMPOLINE);
   const src_text = readText(src);
   if (pathExists(dst) && readText(dst) === src_text && !force) {
     skip(`~/.gemini/hooks/${GEMINI_DISPATCHER_TRAMPOLINE} already up to date`);
   } else {
     writeText(dst, src_text);
-    fs9.chmodSync(dst, 493);
+    fs10.chmodSync(dst, 493);
     success(`~/.gemini/hooks/${GEMINI_DISPATCHER_TRAMPOLINE} installed`);
   }
   const settings_patch = {
     hooks: _gemini_hooks_dict((ac_event, native) => `${dst} ${ac_event} ${native}`)
   };
   return merge_json_file(
-    path7.join(GEMINI_USER_DIR, "settings.json"),
+    path8.join(GEMINI_USER_DIR, "settings.json"),
     settings_patch,
     force,
     "~/.gemini/settings.json"
   );
 }
 function ensure_copilot_bridge(project_root, force) {
-  const target = path7.join(project_root, ".github", "plugin", "marketplace.json");
+  const target = path8.join(project_root, ".github", "plugin", "marketplace.json");
   const bridge = {
     marketplace: {
       name: "event4u-agent-marketplace",
@@ -3772,7 +3833,7 @@ See \`docs/setup/per-ide/roocode.md\` for the full activation guide.
 Run \`./agent-config --help\` for available commands.
 `;
 function ensure_roocode_bridge(project_root, force) {
-  const target = path7.join(project_root, ".roo", "rules", "agent-config.md");
+  const target = path8.join(project_root, ".roo", "rules", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".roo/rules/agent-config.md already exists");
     return;
@@ -3794,7 +3855,7 @@ To wire Claude Desktop to this project's rules, run:
 Canonical rule and skill source: \`.augment/\` (see \`AGENTS.md\`).
 `;
 function ensure_claude_desktop_bridge(project_root, force) {
-  const target = path7.join(project_root, ".claude-desktop", "agent-config.md");
+  const target = path8.join(project_root, ".claude-desktop", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".claude-desktop/agent-config.md already exists");
     return;
@@ -3819,7 +3880,7 @@ Or pass \`--read .aider/agent-config.md\` on the command line.
 Canonical rule and skill source: \`.augment/\` (see \`AGENTS.md\`).
 `;
 function ensure_aider_bridge(project_root, force) {
-  const target = path7.join(project_root, ".aider", "agent-config.md");
+  const target = path8.join(project_root, ".aider", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".aider/agent-config.md already exists");
     return;
@@ -3838,7 +3899,7 @@ developers where the rules and skills live.
 Canonical rule and skill source: \`.augment/\` (see project \`AGENTS.md\`).
 `;
 function ensure_codex_bridge(project_root, force) {
-  const target = path7.join(project_root, ".codex", "agent-config.md");
+  const target = path8.join(project_root, ".codex", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".codex/agent-config.md already exists");
     return;
@@ -3856,7 +3917,7 @@ rules per session. The canonical rule and skill source lives under
 orientation).
 `;
 function ensure_continue_bridge(project_root, force) {
-  const target = path7.join(project_root, ".continue", "rules", "agent-config.md");
+  const target = path8.join(project_root, ".continue", "rules", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".continue/rules/agent-config.md already exists");
     return;
@@ -3887,7 +3948,7 @@ orientation).
 See \`docs/setup/per-ide/kilocode.md\` for the full activation guide.
 `;
 function ensure_kilocode_bridge(project_root, force) {
-  const target = path7.join(project_root, ".kilocode", "rules", "agent-config.md");
+  const target = path8.join(project_root, ".kilocode", "rules", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".kilocode/rules/agent-config.md already exists");
     return;
@@ -3914,7 +3975,7 @@ canonical source (or symlink it):
 Canonical rule and skill source: \`.augment/\` (see \`AGENTS.md\`).
 `;
 function ensure_zed_bridge(project_root, force) {
-  const target = path7.join(project_root, ".zed", "agent-config.md");
+  const target = path8.join(project_root, ".zed", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".zed/agent-config.md already exists");
     return;
@@ -3935,7 +3996,7 @@ rules into your JetBrains profile.
 Canonical rule and skill source: \`.augment/\` (see \`AGENTS.md\`).
 `;
 function ensure_jetbrains_bridge(project_root, force) {
-  const target = path7.join(project_root, ".jetbrains", "agent-config.md");
+  const target = path8.join(project_root, ".jetbrains", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".jetbrains/agent-config.md already exists");
     return;
@@ -3966,7 +4027,7 @@ session. The canonical rule and skill source lives under \`.augment/\`
 See \`docs/setup/per-ide/kiro.md\` for the full activation guide.
 `;
 function ensure_kiro_bridge(project_root, force) {
-  const target = path7.join(project_root, ".kiro", "steering", "agent-config.md");
+  const target = path8.join(project_root, ".kiro", "steering", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".kiro/steering/agent-config.md already exists");
     return;
@@ -3992,35 +4053,35 @@ var SMOKE_BRIDGE_PATHS = {
 };
 function dirHasEntries(p) {
   try {
-    return fs9.readdirSync(p).length > 0;
+    return fs10.readdirSync(p).length > 0;
   } catch {
     return false;
   }
 }
 function _resolve_tsx_invocation(scriptPath, scriptArgs) {
   const binName = process2.platform === "win32" ? "tsx.cmd" : "tsx";
-  let dir = path7.dirname(scriptPath);
+  let dir = path8.dirname(scriptPath);
   for (; ; ) {
-    const candidate = path7.join(dir, "node_modules", ".bin", binName);
+    const candidate = path8.join(dir, "node_modules", ".bin", binName);
     if (isFile(candidate)) {
       return { command: candidate, args: [scriptPath, ...scriptArgs] };
     }
-    const parent = path7.dirname(dir);
+    const parent = path8.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return { command: "npx", args: ["tsx", scriptPath, ...scriptArgs] };
 }
 function _smoke_test_hooks(project_root, package_root) {
-  const dispatcher = path7.join(package_root, "scripts", "hooks", "dispatch_hook.ts");
-  const manifest = path7.join(package_root, "scripts", "hook_manifest.yaml");
+  const dispatcher = path8.join(package_root, "scripts", "hooks", "dispatch_hook.ts");
+  const manifest = path8.join(package_root, "scripts", "hook_manifest.yaml");
   if (!isFile(dispatcher) || !isFile(manifest)) return 0;
   const failed = [];
   const skipped = [];
   const passed = [];
   for (const [platform, native] of SMOKE_PROBE_EVENTS) {
     const rel_bridge = SMOKE_BRIDGE_PATHS[platform] ?? "";
-    const bridge_path = rel_bridge ? path7.join(project_root, rel_bridge) : null;
+    const bridge_path = rel_bridge ? path8.join(project_root, rel_bridge) : null;
     const bridge_present = Boolean(
       bridge_path && (isFile(bridge_path) || isDir(bridge_path) && dirHasEntries(bridge_path))
     );
@@ -4220,9 +4281,9 @@ To remove this marker, delete this file.
 `;
 }
 var _CLAUDE_DESKTOP_BUNDLES_SUBPATH = "claude-desktop/bundles";
-var GLOBAL_ROOT = path7.join(os3.homedir(), ".event4u", "agent-config");
-var GLOBAL_USER_SETTINGS_PATH = path7.join(GLOBAL_ROOT, ".agent-user.yml");
-var GLOBAL_AGENT_SETTINGS_PATH = path7.join(GLOBAL_ROOT, ".agent-settings.yml");
+var GLOBAL_ROOT = path8.join(os3.homedir(), ".event4u", "agent-config");
+var GLOBAL_USER_SETTINGS_PATH = path8.join(GLOBAL_ROOT, ".agent-user.yml");
+var GLOBAL_AGENT_SETTINGS_PATH = path8.join(GLOBAL_ROOT, ".agent-settings.yml");
 function _bridge_marker(tool_id, scope) {
   if (scope === "global") return USER_SCOPE_PATHS[tool_id] ?? "";
   return PROJECT_BRIDGE_MARKERS[tool_id] ?? "";
@@ -4271,7 +4332,7 @@ function _load_yaml_doc(p) {
   return _isPlainObject(data) ? data : {};
 }
 function _load_default_settings(package_root) {
-  const template_source = path7.join(package_root, "src", "config", "agent-settings.template.yml");
+  const template_source = path8.join(package_root, "src", "config", "agent-settings.template.yml");
   if (!pathExists(template_source)) return {};
   let text;
   try {
@@ -4285,11 +4346,11 @@ function _load_default_settings(package_root) {
 }
 var RULE_LAYER_CHOICES = ["global", "project", "both-acknowledged"];
 function _suppress_rule_layer(project_root, suppress_dir) {
-  const target = path7.join(project_root, ".claude", "settings.local.json");
+  const target = path8.join(project_root, ".claude", "settings.local.json");
   const existing = pathExists(target) ? read_json_file(target) : {};
   let real_dir = suppress_dir;
   try {
-    real_dir = fs9.realpathSync(suppress_dir);
+    real_dir = fs10.realpathSync(suppress_dir);
   } catch {
     real_dir = suppress_dir;
   }
@@ -4300,8 +4361,8 @@ function _suppress_rule_layer(project_root, suppress_dir) {
   success(`.claude/settings.local.json: claudeMdExcludes += ${entry}`);
 }
 function _gate_rule_layer_overlap(project_root, layer, dry_run) {
-  const global_dir = path7.join(os3.homedir(), ".claude", "rules");
-  const project_dir = path7.join(project_root, ".claude", "rules");
+  const global_dir = path8.join(os3.homedir(), ".claude", "rules");
+  const project_dir = path8.join(project_root, ".claude", "rules");
   const g = readRuleLayer(global_dir);
   const p = readRuleLayer(project_dir);
   if (g === null || p === null) return true;
@@ -4411,9 +4472,9 @@ function detect_scope(cwd) {
   if (pathExists(_resolve_settings_read(cwd))) {
     return ["project", `existing ${SETTINGS_FILE}`];
   }
-  const has_manifest = SCOPE_DETECT_MANIFESTS.find((m) => pathExists(path7.join(cwd, m))) ?? null;
-  const has_ai_dir = SCOPE_DETECT_AI_DIRS.find((d) => isDir(path7.join(cwd, d))) ?? null;
-  const has_ai_file = SCOPE_DETECT_AI_FILES.find((f) => pathExists(path7.join(cwd, f))) ?? null;
+  const has_manifest = SCOPE_DETECT_MANIFESTS.find((m) => pathExists(path8.join(cwd, m))) ?? null;
+  const has_ai_dir = SCOPE_DETECT_AI_DIRS.find((d) => isDir(path8.join(cwd, d))) ?? null;
+  const has_ai_file = SCOPE_DETECT_AI_FILES.find((f) => pathExists(path8.join(cwd, f))) ?? null;
   if (has_manifest && (has_ai_dir || has_ai_file)) {
     const marker = has_ai_dir || has_ai_file;
     return ["prompt", `manifest (${has_manifest}) + AI-tool config (${marker})`];
@@ -4434,7 +4495,7 @@ function readLineSyncRaw(promptText) {
   for (; ; ) {
     let n;
     try {
-      n = fs9.readSync(0, buf, 0, 1, null);
+      n = fs10.readSync(0, buf, 0, 1, null);
     } catch (err) {
       const code = err.code;
       if (code === "EAGAIN") {
@@ -4509,8 +4570,8 @@ function _files_by_tool_from_bridges(tools, project_root, scope) {
     const marker = _bridge_marker(tool_id, scope);
     if (!marker) continue;
     let marker_path = marker;
-    if (!path7.isAbsolute(marker_path)) {
-      marker_path = path7.join(project_root, marker_path);
+    if (!path8.isAbsolute(marker_path)) {
+      marker_path = path8.join(project_root, marker_path);
     }
     out[tool_id] = [_file_entry(marker_path, "bridge", false)];
   }
@@ -4549,26 +4610,26 @@ function _update_installed_tools_manifest(project_root, tools, scope, force, fil
   }
   write_manifest(target, version, entries);
   if (!state.QUIET) {
-    const rel = isRelativeTo(target, project_root) ? path7.relative(project_root, target) : target;
+    const rel = isRelativeTo(target, project_root) ? path8.relative(project_root, target) : target;
     info(`Manifest updated: ${rel}`);
   }
   return 0;
 }
 function isRelativeTo(child, parent) {
-  const rel = path7.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path7.isAbsolute(rel);
+  const rel = path8.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path8.isAbsolute(rel);
 }
 function _resolve_package_root_for_global() {
   const here = resolvePath(_HERE);
-  const candidate = path7.dirname(path7.dirname(path7.dirname(here)));
-  if (!pathExists(path7.join(candidate, "src", "config", "profiles", "minimal.ini"))) {
+  const candidate = path8.dirname(path8.dirname(path8.dirname(here)));
+  if (!pathExists(path8.join(candidate, "src", "config", "profiles", "minimal.ini"))) {
     fail(
       `Could not locate agent-config package root from ${here}. Expected src/config/profiles/minimal.ini at the parent directory.`
     );
   }
   return candidate;
 }
-var CONSUMER_BRIDGE_MARKER_RELPATH = path7.join("agents", ".event4u-bridge.yml");
+var CONSUMER_BRIDGE_MARKER_RELPATH = path8.join("agents", ".event4u-bridge.yml");
 var MIGRATE_LEGACY_YAML_FILES = [".agent-settings.yml", ".agent-user.yml"];
 var MIGRATE_LEGACY_TOOL_DIRS = [".augment", ".claude", ".cursor"];
 var AGENT_CONFIG_PACKAGE_NAME = "@event4u/agent-config";
@@ -4576,7 +4637,7 @@ function _is_agent_config_source_repo(project_root) {
   if (process2.env["AGENT_CONFIG_CONSUMER_MODE"] === "1") {
     return [false, "consumer-mode-override"];
   }
-  const pkg_json = path7.join(project_root, "package.json");
+  const pkg_json = path8.join(project_root, "package.json");
   if (isFile(pkg_json)) {
     let data = {};
     try {
@@ -4588,18 +4649,18 @@ function _is_agent_config_source_repo(project_root) {
       return [true, "package.json:name"];
     }
   }
-  if (isDir(path7.join(project_root, ".agent-src.uncondensed"))) {
+  if (isDir(path8.join(project_root, ".agent-src.uncondensed"))) {
     return [true, ".agent-src.uncondensed/"];
   }
-  const packages_dir = path7.join(project_root, "packages");
+  const packages_dir = path8.join(project_root, "packages");
   if (isDir(packages_dir)) {
-    for (const child of fs9.readdirSync(packages_dir)) {
-      if (isDir(path7.join(packages_dir, child, ".agent-src.uncondensed"))) {
+    for (const child of fs10.readdirSync(packages_dir)) {
+      if (isDir(path8.join(packages_dir, child, ".agent-src.uncondensed"))) {
         return [true, `packages/${child}/.agent-src.uncondensed/`];
       }
     }
   }
-  const installer_self = path7.join(project_root, "scripts", "install.py");
+  const installer_self = path8.join(project_root, "scripts", "install.py");
   try {
     if (isFile(installer_self) && resolvePath(installer_self) === resolvePath(_HERE)) {
       return [true, "src/scripts/install.py (self)"];
@@ -4619,17 +4680,17 @@ function _detect_legacy_for_migration(project_root) {
     }
     return [];
   }
-  if (isFile(path7.join(project_root, INSTALL_MODE_MARKER_REL))) return [];
+  if (isFile(path8.join(project_root, INSTALL_MODE_MARKER_REL))) return [];
   const found = [];
   for (const name of MIGRATE_LEGACY_YAML_FILES) {
-    if (isFile(path7.join(project_root, name))) {
+    if (isFile(path8.join(project_root, name))) {
       found.push(name);
-    } else if (isFile(path7.join(project_root, "settings", name))) {
+    } else if (isFile(path8.join(project_root, "settings", name))) {
       found.push(`settings/${name}`);
     }
   }
   for (const name of MIGRATE_LEGACY_TOOL_DIRS) {
-    const p = path7.join(project_root, name);
+    const p = path8.join(project_root, name);
     if (isDir(p) && !isSymlink(p)) {
       found.push(`${name}/`);
     }
@@ -4641,7 +4702,7 @@ function _prompt_migrate_to_global(project_root, artefacts) {
     process2.stdout.write("\n");
     warn("Legacy project-local artefacts detected \u2014 pre-ADR-020 layout:");
     for (const rel of artefacts) {
-      info(`  ${path7.join(project_root, rel)}`);
+      info(`  ${path8.join(project_root, rel)}`);
     }
     info("The unified `agent-config migrate` sweeps these in one pass.");
     info("The wizard recreates fresh config afterwards.");
@@ -4672,20 +4733,20 @@ function _run_migrate_to_global(project_root) {
 function _format_global_root_for_marker(global_root) {
   const home = resolvePath(os3.homedir());
   const resolved = resolvePath(global_root);
-  const rel = path7.relative(home, resolved);
-  if (rel === "" || rel.startsWith("..") || path7.isAbsolute(rel)) {
+  const rel = path8.relative(home, resolved);
+  if (rel === "" || rel.startsWith("..") || path8.isAbsolute(rel)) {
     return global_root;
   }
-  return `~/${rel.split(path7.sep).join("/")}`;
+  return `~/${rel.split(path8.sep).join("/")}`;
 }
 function _remove_legacy_consumer_bridge_marker(project_root, env = null) {
   const env_map = env ?? process2.env;
   if (env_map["AGENT_CONFIG_DEV_MODE"] === "1") return null;
-  if (isDir(path7.join(project_root, ".agent-src.uncondensed"))) return null;
-  const target = path7.join(project_root, CONSUMER_BRIDGE_MARKER_RELPATH);
+  if (isDir(path8.join(project_root, ".agent-src.uncondensed"))) return null;
+  const target = path8.join(project_root, CONSUMER_BRIDGE_MARKER_RELPATH);
   if (!isFile(target)) return null;
   try {
-    fs9.rmSync(target);
+    fs10.rmSync(target);
   } catch {
     return null;
   }
@@ -4699,7 +4760,7 @@ var PROJECT_ANCHOR_TOOLS = {
 function _write_per_tool_project_anchors(project_root, tools, env = null, now = null) {
   const env_map = env ?? process2.env;
   if (env_map["AGENT_CONFIG_DEV_MODE"] === "1") return [];
-  if (isDir(path7.join(project_root, ".agent-src.uncondensed"))) return [];
+  if (isDir(path8.join(project_root, ".agent-src.uncondensed"))) return [];
   const global_root_str = _format_global_root_for_marker(
     event4u_root(env_map)
   );
@@ -4708,8 +4769,8 @@ function _write_per_tool_project_anchors(project_root, tools, env = null, now =
   for (const tool_id of Object.keys(PROJECT_ANCHOR_TOOLS).sort()) {
     const rel_path = PROJECT_ANCHOR_TOOLS[tool_id];
     if (!tools.has(tool_id)) continue;
-    const target = path7.join(project_root, rel_path);
-    mkdirp(path7.dirname(target));
+    const target = path8.join(project_root, rel_path);
+    mkdirp(path8.dirname(target));
     const body = `# event4u/agent-config \u2014 per-tool project anchor (auto-written).
 # Spec: docs/contracts/consumer-bridge.md \xA7 Per-tool anchor strategy.
 # Tool: ${tool_id}. Resolves the global install directly \u2014 no
@@ -4727,7 +4788,7 @@ installed_at: ${stamp}
 }
 var PACKAGE_TAG_ID = "event4u/agent-config";
 function _inject_package_tag(target, source, package_root) {
-  if (path7.extname(target) !== ".md") return;
+  if (path8.extname(target) !== ".md") return;
   let text;
   try {
     text = readText(target);
@@ -4755,8 +4816,8 @@ function _inject_package_tag(target, source, package_root) {
       resolved_src = source;
     }
     if (package_root !== null) {
-      const rel = path7.relative(resolvePath(package_root), resolved_src);
-      if (rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel)) {
+      const rel = path8.relative(resolvePath(package_root), resolved_src);
+      if (rel !== "" && !rel.startsWith("..") && !path8.isAbsolute(rel)) {
         source_value = rel;
       } else {
         source_value = resolved_src;
@@ -4791,7 +4852,7 @@ function _escapes_package_root(resolved, package_root) {
   if (package_root === null) return false;
   let root;
   try {
-    root = fs9.realpathSync(package_root);
+    root = fs10.realpathSync(package_root);
   } catch {
     return false;
   }
@@ -4806,7 +4867,7 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
     if (file_filter !== null && !file_filter(src)) return [0, 0, written_paths];
     let resolved_src = src;
     try {
-      resolved_src = fs9.realpathSync(src);
+      resolved_src = fs10.realpathSync(src);
     } catch {
       resolved_src = src;
     }
@@ -4814,10 +4875,10 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
       warn(`refused: ${src} dereferences outside the package root \u2014 not copied`);
       return [0, 0, written_paths];
     }
-    mkdirp(path7.dirname(dest));
+    mkdirp(path8.dirname(dest));
     const decision = _resolve_file_conflict(dest, force);
     if (decision === "skip") return [0, 1, written_paths];
-    fs9.copyFileSync(src, dest);
+    fs10.copyFileSync(src, dest);
     _inject_package_tag(dest, src, package_root);
     written_paths.push(dest);
     return [1, 0, written_paths];
@@ -4825,11 +4886,11 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
   mkdirp(dest);
   const walk = (node) => {
     const acc = [];
-    const names = fs9.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const names = fs10.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const name of names) {
-      const entry = path7.join(node, name);
+      const entry = path8.join(node, name);
       acc.push(entry);
-      const lst = fs9.lstatSync(entry);
+      const lst = fs10.lstatSync(entry);
       if (lst.isDirectory() && !lst.isSymbolicLink()) {
         acc.push(...walk(entry));
       }
@@ -4837,9 +4898,9 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
     return acc;
   };
   for (const entry of walk(src)) {
-    const rel = path7.relative(src, entry);
-    const target = path7.join(dest, rel);
-    const lst = fs9.lstatSync(entry);
+    const rel = path8.relative(src, entry);
+    const target = path8.join(dest, rel);
+    const lst = fs10.lstatSync(entry);
     if (lst.isDirectory() && !lst.isSymbolicLink()) {
       mkdirp(target);
       continue;
@@ -4847,8 +4908,8 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
     let resolvedIsDir = false;
     let resolved = entry;
     try {
-      resolved = fs9.realpathSync(entry);
-      resolvedIsDir = fs9.statSync(entry).isDirectory();
+      resolved = fs10.realpathSync(entry);
+      resolvedIsDir = fs10.statSync(entry).isDirectory();
     } catch {
       resolvedIsDir = false;
     }
@@ -4878,8 +4939,8 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
       skipped += 1;
       continue;
     }
-    mkdirp(path7.dirname(target));
-    fs9.copyFileSync(resolved, target);
+    mkdirp(path8.dirname(target));
+    fs10.copyFileSync(resolved, target);
     _inject_package_tag(target, resolved, package_root);
     written += 1;
     written_paths.push(target);
@@ -4891,7 +4952,7 @@ function _claude_desktop_bundles_dir() {
 }
 function _write_claude_desktop_marker(_force, lockfile_path2, bundles_dir, bundle_count) {
   const anchor = expanduser2(USER_SCOPE_PATHS["claude-desktop"]);
-  const target = path7.join(anchor, "agent-config.md");
+  const target = path8.join(anchor, "agent-config.md");
   mkdirp(anchor);
   const body = claudeDesktopMarkerBody(lockfile_path2, anchor, bundles_dir, bundle_count);
   writeText(target, body);
@@ -4915,23 +4976,23 @@ function _apply_claude_flat_command_wrappers(anchor, package_root, current_files
   const wrapped = [];
   const collisions = [];
   const reserved = [];
-  const commands_dir = path7.join(anchor, "commands");
+  const commands_dir = path8.join(anchor, "commands");
   let flat_entries = [];
   try {
-    flat_entries = fs9.readdirSync(commands_dir).filter((f) => f.endsWith(".md"));
+    flat_entries = fs10.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;
-    fs9.rmSync(path7.join(commands_dir, fname), { force: true });
+    fs10.rmSync(path8.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(
-      fs9.readFileSync(path7.join(package_root, "dist", "discovery", "discovery-manifest.json"), "utf8")
+      fs10.readFileSync(path8.join(package_root, "dist", "discovery", "discovery-manifest.json"), "utf8")
     );
     for (const a of manifest.artefacts ?? []) {
       if (a.category !== "command" || typeof a.slug !== "string") continue;
@@ -4942,22 +5003,22 @@ 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 = path7.join(anchor, "commands", `${slug}.md`);
-    if (!fs9.existsSync(flat_abs)) continue;
-    const skill_dir = path7.join(anchor, "skills", slug);
-    if (fs9.existsSync(skill_dir)) {
+    const flat_abs = path8.join(anchor, "commands", `${slug}.md`);
+    if (!fs10.existsSync(flat_abs)) continue;
+    const skill_dir = path8.join(anchor, "skills", slug);
+    if (fs10.existsSync(skill_dir)) {
       collisions.push(slug);
       continue;
     }
-    let body = fs9.readFileSync(flat_abs, "utf8");
+    let body = fs10.readFileSync(flat_abs, "utf8");
     if (body.startsWith("---\n") && !/^name:/m.test(body.split("\n---")[0] ?? "")) {
       body = body.replace("---\n", `---
 name: ${slug}
 `);
     }
-    fs9.mkdirSync(skill_dir, { recursive: true });
-    fs9.writeFileSync(path7.join(skill_dir, "SKILL.md"), body, "utf8");
-    fs9.rmSync(flat_abs, { force: true });
+    fs10.mkdirSync(skill_dir, { recursive: true });
+    fs10.writeFileSync(path8.join(skill_dir, "SKILL.md"), body, "utf8");
+    fs10.rmSync(flat_abs, { force: true });
     current_files.delete(flat_rel);
     current_files.add(`skills/${slug}/SKILL.md`);
     wrapped.push(slug);
@@ -4989,8 +5050,8 @@ function _deploy_global_content(tools, force, package_root, lockfile_path2) {
     const written_paths = [];
     let current_files = /* @__PURE__ */ new Set();
     for (const [src_rel, dest_sub] of plan) {
-      const src = path7.join(package_root, src_rel);
-      const dest = dest_sub ? path7.join(anchor, dest_sub) : anchor;
+      const src = path8.join(package_root, src_rel);
+      const dest = dest_sub ? path8.join(anchor, dest_sub) : anchor;
       const rule_filter = _rule_filter_for_source(src_rel, rule_scope);
       const [w, s, paths] = _copy_dir_dereferencing_symlinks(
         src,
@@ -5064,10 +5125,10 @@ function _deploy_global_content(tools, force, package_root, lockfile_path2) {
     results[tool_id] = [written_total, skipped_total, "deployed", written_paths];
     if (tool_id === "claude-code") {
       try {
-        const manifest = path7.join(package_root, "src", "scripts", "hook_manifest.yaml");
+        const manifest = path8.join(package_root, "src", "scripts", "hook_manifest.yaml");
         const matrix = build_claude_hook_matrix(manifest);
         const res = ensure_managed_hooks(
-          path7.join(anchor, "settings.json"),
+          path8.join(anchor, "settings.json"),
           matrix
         );
         if (!state.QUIET) {
@@ -5104,7 +5165,7 @@ function _preview_global_reap(tools, package_root) {
     const anchor = expanduser2(anchor_raw);
     let current_files = /* @__PURE__ */ new Set();
     for (const [src_rel, dest_sub] of plan) {
-      const src = path7.join(package_root, src_rel);
+      const src = path8.join(package_root, src_rel);
       current_files = setUnion(
         current_files,
         expected_deploy_files(
@@ -5138,14 +5199,14 @@ function _preview_global_reap(tools, package_root) {
 function _verify_deploy_targets(anchor, plan) {
   const missing = [];
   for (const [, dest_sub] of plan) {
-    const target = dest_sub ? path7.join(anchor, dest_sub) : anchor;
+    const target = dest_sub ? path8.join(anchor, dest_sub) : anchor;
     const label = dest_sub || ".";
     if (!isDir(target)) {
       missing.push(label);
       continue;
     }
     try {
-      const entries = fs9.readdirSync(target);
+      const entries = fs10.readdirSync(target);
       if (entries.length === 0) missing.push(label);
     } catch {
       missing.push(label);
@@ -5153,61 +5214,8 @@ function _verify_deploy_targets(anchor, plan) {
   }
   return missing;
 }
-function _prune_modules_by(deploy_results, is_pruned) {
-  let pruned = 0;
-  const adjusted = {};
-  for (const tool_id of Object.keys(deploy_results)) {
-    const [written, skipped, status, paths] = deploy_results[tool_id];
-    const pruned_skill_dirs = /* @__PURE__ */ new Set();
-    for (const p of paths) {
-      const parts = p.split(path7.sep);
-      if (parts.includes("skills")) {
-        const i = parts.indexOf("skills");
-        if (i + 1 < parts.length) {
-          const skill_root = parts.slice(0, i + 2).join(path7.sep);
-          if (!pruned_skill_dirs.has(skill_root)) {
-            const skillmd = path7.join(skill_root, "SKILL.md");
-            if (pathExists(skillmd) && is_pruned(skillmd)) {
-              pruned_skill_dirs.add(skill_root);
-            }
-          }
-        }
-      }
-    }
-    const keep = [];
-    const delete_files = [];
-    for (const p of paths) {
-      const parts = p.split(path7.sep);
-      let is_target = false;
-      if (parts.includes("skills")) {
-        const i = parts.indexOf("skills");
-        if (i + 1 < parts.length && pruned_skill_dirs.has(parts.slice(0, i + 2).join(path7.sep))) {
-          is_target = true;
-        }
-      } else if (parts.includes("commands") && path7.extname(p) === ".md" && is_pruned(p)) {
-        is_target = true;
-      }
-      (is_target ? delete_files : keep).push(p);
-    }
-    for (const d of pruned_skill_dirs) {
-      fs9.rmSync(d, { recursive: true, force: true });
-    }
-    for (const p of delete_files) {
-      if (p.split(path7.sep).includes("commands") && pathExists(p)) {
-        try {
-          fs9.unlinkSync(p);
-        } catch {
-        }
-      }
-    }
-    pruned += delete_files.length;
-    adjusted[tool_id] = [Math.max(0, written - delete_files.length), skipped, status, keep];
-  }
-  return [pruned, adjusted];
-}
-function _prune_lab_modules(deploy_results, lab_ids) {
-  return _prune_modules_by(deploy_results, (p) => is_lab_artefact(p, lab_ids));
-}
+var _prune_modules_by = prune_modules_by;
+var _prune_lab_modules = prune_lab_modules;
 var _load_packs_registry = load_packs_registry;
 var _compute_active_pack_ids = compute_active_pack_ids;
 function _resolve_global_settings_doc() {
@@ -5216,16 +5224,16 @@ function _resolve_global_settings_doc() {
 }
 function _resolve_global_settings_path() {
   const root = event4u_root();
-  const canonical = path7.join(root, "settings", SETTINGS_FILE);
+  const canonical = path8.join(root, "settings", SETTINGS_FILE);
   if (pathExists(canonical)) return canonical;
-  const legacy = path7.join(root, SETTINGS_FILE);
+  const legacy = path8.join(root, SETTINGS_FILE);
   if (pathExists(legacy)) return legacy;
   return null;
 }
 function _resolve_scoped_projection(package_root) {
   const doc = _resolve_global_settings_doc() ?? _load_default_settings(package_root);
   const projection = _isPlainObject(doc["projection"]) ? doc["projection"] : {};
-  const mode = projection["mode"] === "scoped" ? "scoped" : "legacy-all";
+  const mode = projectionModeOf(projection["mode"]);
   const runtime = _isPlainObject(doc["runtime"]) ? doc["runtime"] : {};
   const active_packs_raw = runtime["active_packs"];
   const active_packs = Array.isArray(active_packs_raw) ? active_packs_raw.filter((v) => typeof v === "string") : [];
@@ -5329,7 +5337,7 @@ function install_global(tools, force, project_root = null, core_only = false) {
     info(`  schema_version=1, agent_config_version=${installed_version}`);
     info(`  tools=${merged_tools.join(",")}`);
   }
-  if (project_root !== null && pathExists(_resolve_settings_read(project_root)) && !isDir(path7.join(project_root, ".agent-src.uncondensed"))) {
+  if (project_root !== null && pathExists(_resolve_settings_read(project_root)) && !isDir(path8.join(project_root, ".agent-src.uncondensed"))) {
     const drift = collect_drift(project_root);
     if (!state.QUIET) {
       process2.stdout.write("\n");
@@ -5352,6 +5360,13 @@ function install_global(tools, force, project_root = null, core_only = false) {
   }
   try {
     const { mode, active_packs } = _resolve_scoped_projection(package_root);
+    if (mode === "tiered") {
+      const outcome = applyTieredPrune(deploy_results, package_root, _prune_modules_by);
+      deploy_results = outcome.deployResults;
+      if (!state.QUIET && outcome.message !== null) {
+        (outcome.level === "warn" ? warn : info)(outcome.message);
+      }
+    }
     if (mode === "scoped") {
       const packs_registry = _load_packs_registry(package_root);
       const active_ids = _compute_active_pack_ids(packs_registry, active_packs);
@@ -5436,19 +5451,19 @@ function install_global(tools, force, project_root = null, core_only = false) {
       }
     }
   }
-  if (project_root !== null && pathExists(_resolve_settings_read(project_root)) && !isDir(path7.join(project_root, ".agent-src.uncondensed"))) {
+  if (project_root !== null && pathExists(_resolve_settings_read(project_root)) && !isDir(path8.join(project_root, ".agent-src.uncondensed"))) {
     const files_by_tool = _files_by_tool_from_deploy(deploy_results);
     const rc = _update_installed_tools_manifest(project_root, tools, "global", force, files_by_tool);
     if (rc !== 0) return rc;
     const removed_marker = _remove_legacy_consumer_bridge_marker(project_root);
     if (removed_marker !== null && !state.QUIET) {
-      const rel = isRelativeTo(removed_marker, project_root) ? path7.relative(project_root, removed_marker) : removed_marker;
+      const rel = isRelativeTo(removed_marker, project_root) ? path8.relative(project_root, removed_marker) : removed_marker;
       info(`Removed legacy bridge marker: ${rel}`);
     }
     const anchor_paths = _write_per_tool_project_anchors(project_root, tools);
     if (anchor_paths.length > 0 && !state.QUIET) {
       for (const p of anchor_paths) {
-        const rel = isRelativeTo(p, project_root) ? path7.relative(project_root, p) : p;
+        const rel = isRelativeTo(p, project_root) ? path8.relative(project_root, p) : p;
         info(`Project anchor written: ${rel}`);
       }
     }
@@ -5484,8 +5499,8 @@ function install_global(tools, force, project_root = null, core_only = false) {
 }
 function _catalogue_truncation_warnings(deploy_results, project_root) {
   const log_candidates = [
-    path7.join(event4u_root(), "state", "skill-catalogue.jsonl"),
-    ...project_root ? [path7.join(project_root, OBSERVATION_LOG)] : []
+    path8.join(event4u_root(), "state", "skill-catalogue.jsonl"),
+    ...project_root ? [path8.join(project_root, OBSERVATION_LOG)] : []
   ];
   const records = log_candidates.flatMap((p) => readObservationLog(p));
   if (records.length === 0) return [];
@@ -5508,13 +5523,13 @@ function _catalogue_truncation_warnings(deploy_results, project_root) {
 function _scoped_migration_notice(deploy_results, project_root, package_root, probe) {
   if (!isInteractiveSession(probe)) return [];
   const log_candidates = [
-    path7.join(event4u_root(), "state", "skill-catalogue.jsonl"),
-    ...project_root ? [path7.join(project_root, OBSERVATION_LOG)] : []
+    path8.join(event4u_root(), "state", "skill-catalogue.jsonl"),
+    ...project_root ? [path8.join(project_root, OBSERVATION_LOG)] : []
   ];
   const limits = knownHostLimits(log_candidates.flatMap((p) => readObservationLog(p)));
   if (limits.size === 0) return [];
   const resolved = _resolve_scoped_projection(package_root);
-  const settings_path = _resolve_global_settings_path() ?? path7.join(event4u_root(), "settings", SETTINGS_FILE);
+  const settings_path = _resolve_global_settings_path() ?? path8.join(event4u_root(), "settings", SETTINGS_FILE);
   for (const tool_id of Object.keys(deploy_results).sort()) {
     const [, , status] = deploy_results[tool_id];
     if (status !== "deployed") continue;
@@ -5533,8 +5548,8 @@ function _scoped_migration_notice(deploy_results, project_root, package_root, pr
   }
   return [];
 }
-var SETTINGS_SURFACE_REL = path7.join("state", "settings-surface.json");
-var SETTINGS_DELTA_REL = path7.join("state", "settings-delta.json");
+var SETTINGS_SURFACE_REL = path8.join("state", "settings-surface.json");
+var SETTINGS_DELTA_REL = path8.join("state", "settings-delta.json");
 function _current_settings_surface(version) {
   const jsonSchema = zodToJsonSchema(settingsSchema, {
     name: "AgentSettings",
@@ -5545,20 +5560,20 @@ function _current_settings_surface(version) {
 }
 function _write_settings_surface_snapshot(installed_version) {
   const root = event4u_root();
-  const surface_path = path7.join(root, SETTINGS_SURFACE_REL);
-  const delta_path = path7.join(root, SETTINGS_DELTA_REL);
+  const surface_path = path8.join(root, SETTINGS_SURFACE_REL);
+  const delta_path = path8.join(root, SETTINGS_DELTA_REL);
   const next = _current_settings_surface(installed_version);
   let previous = null;
   try {
-    const parsed = JSON.parse(fs9.readFileSync(surface_path, "utf8"));
+    const parsed = JSON.parse(fs10.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) {
-      fs9.mkdirSync(path7.dirname(delta_path), { recursive: true, mode: 448 });
-      fs9.writeFileSync(delta_path, `${JSON.stringify(delta, null, 2)}
+      fs10.mkdirSync(path8.dirname(delta_path), { recursive: true, mode: 448 });
+      fs10.writeFileSync(delta_path, `${JSON.stringify(delta, null, 2)}
 `, { mode: 384 });
       if (!state.QUIET) {
         const counts = {};
@@ -5570,8 +5585,8 @@ function _write_settings_surface_snapshot(installed_version) {
       }
     }
   }
-  fs9.mkdirSync(path7.dirname(surface_path), { recursive: true, mode: 448 });
-  fs9.writeFileSync(surface_path, `${JSON.stringify(next, null, 2)}
+  fs10.mkdirSync(path8.dirname(surface_path), { recursive: true, mode: 448 });
+  fs10.writeFileSync(surface_path, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 });
 }
 function arrayStrEqual(a, b) {
@@ -5791,13 +5806,13 @@ function _minimal_templates_root() {
   const chain = [start];
   let cur = start;
   for (; ; ) {
-    const parent = path7.dirname(cur);
+    const parent = path8.dirname(cur);
     if (parent === cur) break;
     chain.push(parent);
     cur = parent;
   }
   for (const ancestor of chain) {
-    const candidate = path7.join(ancestor, "src", "templates", "minimal");
+    const candidate = path8.join(ancestor, "src", "templates", "minimal");
     if (isDir(candidate)) return candidate;
   }
   fail("Could not locate src/templates/minimal/ \u2014 package install is corrupt.");
@@ -5805,9 +5820,9 @@ function _minimal_templates_root() {
 var INSTALL_MODE_MARKER_REL = "agents/.agent-state/install-mode.txt";
 function _write_install_mode_marker(project_root, mode) {
   if (mode !== "minimal" && mode !== "full") return;
-  const marker = path7.join(project_root, INSTALL_MODE_MARKER_REL);
+  const marker = path8.join(project_root, INSTALL_MODE_MARKER_REL);
   try {
-    mkdirp(path7.dirname(marker));
+    mkdirp(path8.dirname(marker));
     writeText(marker, `${mode}
 `);
   } catch {
@@ -5816,7 +5831,7 @@ function _write_install_mode_marker(project_root, mode) {
 function install_minimal(target_root_in, force, user_type = "") {
   let target_root = resolvePath(target_root_in);
   mkdirp(target_root);
-  const parent = path7.dirname(target_root);
+  const parent = path8.dirname(target_root);
   if (parent !== target_root) {
     const existing = find_project_root_with_anchor(parent);
     if (existing !== null && existing[0] !== target_root) {
@@ -5827,21 +5842,21 @@ function install_minimal(target_root_in, force, user_type = "") {
     }
   }
   const templates = _minimal_templates_root();
-  const settings_src = path7.join(templates, SETTINGS_FILE);
-  const overrides_gitkeep_src = path7.join(templates, "overrides-gitkeep");
-  const overrides_readme_src = path7.join(templates, "agents-overrides-readme.md");
+  const settings_src = path8.join(templates, SETTINGS_FILE);
+  const overrides_gitkeep_src = path8.join(templates, "overrides-gitkeep");
+  const overrides_readme_src = path8.join(templates, "agents-overrides-readme.md");
   if (!isFile(settings_src)) fail(`Bundled minimal settings template missing under ${templates}`);
   if (!isFile(overrides_gitkeep_src) || !isFile(overrides_readme_src)) {
     fail(`Bundled overrides scaffold templates missing under ${templates}`);
   }
   info(`Minimal init \u2192 ${target_root}`);
-  const overrides_root = path7.join(target_root, "agents", "overrides");
+  const overrides_root = path8.join(target_root, "agents", "overrides");
   mkdirp(overrides_root);
   const gitkeep_body = readText(overrides_gitkeep_src);
   for (const sub of ["rules", "skills", "commands"]) {
-    const sub_dir = path7.join(overrides_root, sub);
+    const sub_dir = path8.join(overrides_root, sub);
     mkdirp(sub_dir);
-    const gitkeep_dst = path7.join(sub_dir, ".gitkeep");
+    const gitkeep_dst = path8.join(sub_dir, ".gitkeep");
     if (pathExists(gitkeep_dst) && !force) {
       skip(`agents/overrides/${sub}/.gitkeep already exists (use --force to overwrite)`);
     } else {
@@ -5849,7 +5864,7 @@ function install_minimal(target_root_in, force, user_type = "") {
       success(`Wrote agents/overrides/${sub}/.gitkeep`);
     }
   }
-  const readme_dst = path7.join(overrides_root, "README.md");
+  const readme_dst = path8.join(overrides_root, "README.md");
   if (pathExists(readme_dst) && !force) {
     skip("agents/overrides/README.md already exists (use --force to overwrite)");
   } else {
@@ -5867,14 +5882,14 @@ function install_minimal(target_root_in, force, user_type = "") {
 personal:
   user_type: ${user_type}
 `;
-      mkdirp(path7.dirname(settings_dst));
+      mkdirp(path8.dirname(settings_dst));
       writeText(settings_dst, body);
       success(`Wrote ${SETTINGS_FILE} (user_type=${user_type})`);
     }
   }
   const removed_marker = _remove_legacy_consumer_bridge_marker(target_root);
   if (removed_marker !== null) {
-    const rel = isRelativeTo(removed_marker, target_root) ? path7.relative(target_root, removed_marker) : removed_marker;
+    const rel = isRelativeTo(removed_marker, target_root) ? path8.relative(target_root, removed_marker) : removed_marker;
     success(`Removed legacy bridge marker: ${rel}`);
   }
   _write_install_mode_marker(target_root, "minimal");
@@ -5948,7 +5963,7 @@ function run_interactive_init(project_root, force) {
     );
     return 0;
   }
-  const target = path7.join(project_root, _LOCAL_CONFIG_FILE);
+  const target = path8.join(project_root, _LOCAL_CONFIG_FILE);
   if (pathExists(target) && !force) {
     warn(
       `${_LOCAL_CONFIG_FILE} already exists; re-run with --force to overwrite. Skipping interactive init.`
@@ -5975,7 +5990,7 @@ function run_interactive_init(project_root, force) {
     warn(`Could not write ${target}: ${String(exc)}`);
     return 1;
   }
-  success(`Wrote ${path7.relative(project_root, target)} (${user_type} / ${stack} / ${verbosity})`);
+  success(`Wrote ${path8.relative(project_root, target)} (${user_type} / ${stack} / ${verbosity})`);
   return 0;
 }
 var _WIZARD_READY_RE = /^WIZARD_READY (http:\/\/(?:127\.0\.0\.1|localhost):\d+\/\S*)\r?$/;
@@ -5993,12 +6008,12 @@ function _wizard_should_launch(opts) {
   return [true, ""];
 }
 function _wizard_cli_dist(_project_root) {
-  const package_root = path7.dirname(path7.dirname(path7.dirname(resolvePath(_HERE))));
-  const cli = path7.join(package_root, "dist", "cli", "agent-config.js");
+  const package_root = path8.dirname(path8.dirname(path8.dirname(resolvePath(_HERE))));
+  const cli = path8.join(package_root, "dist", "cli", "agent-config.js");
   return pathExists(cli) ? cli : null;
 }
 function _server_info_path() {
-  return path7.join(os3.homedir(), ".event4u", "agent-config", "local-server.json");
+  return path8.join(os3.homedir(), ".event4u", "agent-config", "local-server.json");
 }
 function _pid_is_agent_config(pid) {
   let res;
@@ -6015,7 +6030,7 @@ function _pid_is_agent_config(pid) {
 }
 function unlinkMissingOk(p) {
   try {
-    fs9.unlinkSync(p);
+    fs10.unlinkSync(p);
   } catch {
   }
 }
@@ -6093,14 +6108,14 @@ function _wizard_spawn(project_root, pass_project_root = true) {
 }
 function _wizard_run_sync(cmd, env, cli) {
   const total = _WIZARD_TIMEOUTS.reduce((a, b) => a + b, 0);
-  const log_path = path7.join(
+  const log_path = path8.join(
     os3.tmpdir(),
     `agent-config-wizard-${process2.pid}-${Date.now()}.log`
   );
   let child;
   let log_fd = null;
   try {
-    log_fd = fs9.openSync(log_path, "w");
+    log_fd = fs10.openSync(log_path, "w");
     child = spawn(cmd[0], cmd.slice(1), {
       env,
       detached: true,
@@ -6118,7 +6133,7 @@ function _wizard_run_sync(cmd, env, cli) {
   } finally {
     if (log_fd !== null) {
       try {
-        fs9.closeSync(log_fd);
+        fs10.closeSync(log_fd);
       } catch {
       }
     }
@@ -6368,8 +6383,8 @@ function main2(argv) {
     const target_root = resolvePath(
       opts.custom_path || opts.project || process2.env["PROJECT_ROOT"] || process2.cwd()
     );
-    const minimal_package_root = path7.dirname(
-      path7.dirname(path7.dirname(_minimal_templates_root()))
+    const minimal_package_root = path8.dirname(
+      path8.dirname(path8.dirname(_minimal_templates_root()))
     );
     const validated_user_type = _validate_user_type(minimal_package_root, opts.user_type);
     return install_minimal(target_root, opts.force, validated_user_type);
@@ -6401,7 +6416,7 @@ function main2(argv) {
     return rc2;
   }
   const project_root = custom_path || resolvePath(opts.project || process2.env["PROJECT_ROOT"] || process2.cwd());
-  const is_first_run = !pathExists(path7.join(project_root, SETTINGS_FILE));
+  const is_first_run = !pathExists(path8.join(project_root, SETTINGS_FILE));
   const rc = _main_project_install(opts, project_root, parsed_tools, is_first_run);
   if (rc === 0 && opts.interactive) {
     run_interactive_init(project_root, opts.force);
@@ -6465,16 +6480,16 @@ function _team_setup_hint_line(project_root) {
   return "  \u2022 Claude Code team mode (optional cross-model review via the official codex plugin): run `agent-config doctor --check team` for setup status.";
 }
 function finalize_claude_model_tiers(project_root) {
-  const claude_skills = path7.join(project_root, ".claude", "skills");
-  const augment_skills = path7.join(project_root, ".augment", "skills");
+  const claude_skills = path8.join(project_root, ".claude", "skills");
+  const augment_skills = path8.join(project_root, ".augment", "skills");
   if (!isDir(claude_skills) || !isDir(augment_skills)) return 0;
   if (_read_consumer_auto_switch(project_root) !== "auto") return 0;
   let rendered = 0;
-  const entries = fs9.readdirSync(claude_skills).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const entries = fs10.readdirSync(claude_skills).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   for (const name of entries) {
-    const entry = path7.join(claude_skills, name);
-    const src_dir = path7.join(augment_skills, name);
-    const src_md = path7.join(src_dir, "SKILL.md");
+    const entry = path8.join(claude_skills, name);
+    const src_dir = path8.join(augment_skills, name);
+    const src_md = path8.join(src_dir, "SKILL.md");
     let tier;
     try {
       tier = read_model_tier(src_md);
@@ -6483,22 +6498,22 @@ 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)) {
-      fs9.unlinkSync(entry);
+      fs10.unlinkSync(entry);
     } else if (isDir(entry)) {
-      fs9.rmSync(entry, { recursive: true, force: true });
+      fs10.rmSync(entry, { recursive: true, force: true });
     }
     mkdirp(entry);
-    const srcFiles = fs9.readdirSync(src_dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const srcFiles = fs10.readdirSync(src_dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const fname of srcFiles) {
       if (fname === "SKILL.md") {
         writeText(
-          path7.join(entry, "SKILL.md"),
+          path8.join(entry, "SKILL.md"),
           render_native_model_md(readText(src_md), tier)
         );
       } else {
-        fs9.symlinkSync(
-          path7.join("../../../.augment/skills", name, fname),
-          path7.join(entry, fname)
+        fs10.symlinkSync(
+          path8.join("../../../.augment/skills", name, fname),
+          path8.join(entry, fname)
         );
       }
     }
@@ -6516,7 +6531,7 @@ function _main_project_install(opts, project_root, parsed_tools, is_first_run) {
   let package_type;
   if (opts.package) {
     package_root = resolvePath(opts.package);
-    if (!pathExists(path7.join(package_root, "src", "config", "profiles", "minimal.ini"))) {
+    if (!pathExists(path8.join(package_root, "src", "config", "profiles", "minimal.ini"))) {
       fail(`Invalid --package path (missing src/config/profiles/minimal.ini): ${package_root}`);
     }
     package_type = detect_package_type_for_project(project_root, package_root);
@@ -6544,7 +6559,10 @@ function _main_project_install(opts, project_root, parsed_tools, is_first_run) {
       ...ensure_augment_bridge(project_root, opts.force)
     ];
     if (_is_tool_enabled(tools, "claude-code")) {
-      merged_keys_by_tool["claude-code"] = ensure_claude_bridge(project_root, opts.force);
+      merged_keys_by_tool["claude-code"] = [
+        ...ensure_claude_bridge(project_root, opts.force),
+        ...ensure_mcp_bridge(project_root, opts.force)
+      ];
     }
     if (_is_tool_enabled(tools, "cursor")) {
       merged_keys_by_tool["cursor"] = ensure_cursor_bridge(project_root, opts.force);
@@ -6567,6 +6585,10 @@ function _main_project_install(opts, project_root, parsed_tools, is_first_run) {
     if (_is_tool_enabled(tools, "jetbrains")) ensure_jetbrains_bridge(project_root, opts.force);
     if (_is_tool_enabled(tools, "kiro")) ensure_kiro_bridge(project_root, opts.force);
   }
+  const tier_advisory = _tier_b_advisory(package_root);
+  if (tier_advisory !== null && !state.QUIET) {
+    info(tier_advisory);
+  }
   if (opts.augment_user_hooks) {
     (merged_keys_by_tool["augment"] ??= []).push(...ensure_augment_user_hooks(package_root, opts.force));
   }
@@ -6653,9 +6675,9 @@ 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 fs9.realpathSync(path7.resolve(process2.argv[1]));
+    return fs10.realpathSync(path8.resolve(process2.argv[1]));
   } catch {
-    return path7.resolve(process2.argv[1]);
+    return path8.resolve(process2.argv[1]);
   }
 }
 var _argv1 = _resolvedArgv1();