@event4u/agent-config 9.13.0 → 9.15.0

package/dist/install/install.mjs

@@ -117,17 +117,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path15) {
-      const ctrl = callVisitor(key, node, visitor, path15);
+    function visit_(key, node, visitor, path16) {
+      const ctrl = callVisitor(key, node, visitor, path16);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path15, ctrl);
-        return visit_(key, ctrl, visitor, path15);
+        replaceNode(key, path16, ctrl);
+        return visit_(key, ctrl, visitor, path16);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path15 = Object.freeze(path15.concat(node));
+          path16 = Object.freeze(path16.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path15);
+            const ci = visit_(i, node.items[i], visitor, path16);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -138,13 +138,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path15 = Object.freeze(path15.concat(node));
-          const ck = visit_("key", node.key, visitor, path15);
+          path16 = Object.freeze(path16.concat(node));
+          const ck = visit_("key", node.key, visitor, path16);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path15);
+          const cv = visit_("value", node.value, visitor, path16);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -165,17 +165,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path15) {
-      const ctrl = await callVisitor(key, node, visitor, path15);
+    async function visitAsync_(key, node, visitor, path16) {
+      const ctrl = await callVisitor(key, node, visitor, path16);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path15, ctrl);
-        return visitAsync_(key, ctrl, visitor, path15);
+        replaceNode(key, path16, ctrl);
+        return visitAsync_(key, ctrl, visitor, path16);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path15 = Object.freeze(path15.concat(node));
+          path16 = Object.freeze(path16.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path15);
+            const ci = await visitAsync_(i, node.items[i], visitor, path16);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -186,13 +186,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path15 = Object.freeze(path15.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path15);
+          path16 = Object.freeze(path16.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path16);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path15);
+          const cv = await visitAsync_("value", node.value, visitor, path16);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -219,23 +219,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path15) {
+    function callVisitor(key, node, visitor, path16) {
       if (typeof visitor === "function")
-        return visitor(key, node, path15);
+        return visitor(key, node, path16);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path15);
+        return visitor.Map?.(key, node, path16);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path15);
+        return visitor.Seq?.(key, node, path16);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path15);
+        return visitor.Pair?.(key, node, path16);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path15);
+        return visitor.Scalar?.(key, node, path16);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path15);
+        return visitor.Alias?.(key, node, path16);
       return void 0;
     }
-    function replaceNode(key, path15, node) {
-      const parent = path15[path15.length - 1];
+    function replaceNode(key, path16, node) {
+      const parent = path16[path16.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -845,10 +845,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path15, value) {
+    function collectionFromPath(schema, path16, value) {
       let v = value;
-      for (let i = path15.length - 1; i >= 0; --i) {
-        const k = path15[i];
+      for (let i = path16.length - 1; i >= 0; --i) {
+        const k = path16[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -867,7 +867,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path15) => path15 == null || typeof path15 === "object" && !!path15[Symbol.iterator]().next().done;
+    var isEmptyPath = (path16) => path16 == null || typeof path16 === "object" && !!path16[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -897,11 +897,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path15, value) {
-        if (isEmptyPath(path15))
+      addIn(path16, value) {
+        if (isEmptyPath(path16))
           this.add(value);
         else {
-          const [key, ...rest] = path15;
+          const [key, ...rest] = path16;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -915,8 +915,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path15) {
-        const [key, ...rest] = path15;
+      deleteIn(path16) {
+        const [key, ...rest] = path16;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -930,8 +930,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path15, keepScalar) {
-        const [key, ...rest] = path15;
+      getIn(path16, keepScalar) {
+        const [key, ...rest] = path16;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -949,8 +949,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path15) {
-        const [key, ...rest] = path15;
+      hasIn(path16) {
+        const [key, ...rest] = path16;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -960,8 +960,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path15, value) {
-        const [key, ...rest] = path15;
+      setIn(path16, value) {
+        const [key, ...rest] = path16;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3476,9 +3476,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path15, value) {
+      addIn(path16, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path15, value);
+          this.contents.addIn(path16, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3553,14 +3553,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path15) {
-        if (Collection.isEmptyPath(path15)) {
+      deleteIn(path16) {
+        if (Collection.isEmptyPath(path16)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path15) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path16) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3575,10 +3575,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path15, keepScalar) {
-        if (Collection.isEmptyPath(path15))
+      getIn(path16, keepScalar) {
+        if (Collection.isEmptyPath(path16))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path15, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path16, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3589,10 +3589,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path15) {
-        if (Collection.isEmptyPath(path15))
+      hasIn(path16) {
+        if (Collection.isEmptyPath(path16))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path15) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path16) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3609,13 +3609,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path15, value) {
-        if (Collection.isEmptyPath(path15)) {
+      setIn(path16, value) {
+        if (Collection.isEmptyPath(path16)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path15), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path16), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path15, value);
+          this.contents.setIn(path16, value);
         }
       }
       /**
@@ -5575,9 +5575,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path15) => {
+    visit.itemAtPath = (cst, path16) => {
       let item = cst;
-      for (const [field, index] of path15) {
+      for (const [field, index] of path16) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5586,23 +5586,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path15) => {
-      const parent = visit.itemAtPath(cst, path15.slice(0, -1));
-      const field = path15[path15.length - 1][0];
+    visit.parentCollection = (cst, path16) => {
+      const parent = visit.itemAtPath(cst, path16.slice(0, -1));
+      const field = path16[path16.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path15, item, visitor) {
-      let ctrl = visitor(item, path15);
+    function _visit(path16, item, visitor) {
+      let ctrl = visitor(item, path16);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path15.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path16.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5613,10 +5613,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path15);
+            ctrl = ctrl(item, path16);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path15) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path16) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6918,14 +6918,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs17 = this.flowScalar(this.type);
+              const fs18 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs17, sep: [] });
+                map.items.push({ start, key: fs18, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs17);
+                this.stack.push(fs18);
               } else {
-                Object.assign(it, { key: fs17, sep: [] });
+                Object.assign(it, { key: fs18, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7053,13 +7053,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs17 = this.flowScalar(this.type);
+              const fs18 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs17, sep: [] });
+                fc.items.push({ start: [], key: fs18, sep: [] });
               else if (it.sep)
-                this.stack.push(fs17);
+                this.stack.push(fs18);
               else
-                Object.assign(it, { key: fs17, sep: [] });
+                Object.assign(it, { key: fs18, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7370,9 +7370,9 @@ var require_dist = __commonJS({
 // src/scripts/install.ts
 import { spawn, spawnSync as spawnSync2 } from "node:child_process";
 import * as crypto3 from "node:crypto";
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os7 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import process3 from "node:process";
 import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL2 } from "node:url";
 
@@ -7872,8 +7872,8 @@ function lockfile_write_path(env) {
   }
   return write_target("installed.lock", { env: env ?? null });
 }
-function read_lockfile(path15) {
-  const target = path15 ?? lockfile_path();
+function read_lockfile(path16) {
+  const target = path16 ?? lockfile_path();
   let text;
   try {
     text = fs2.readFileSync(target, { encoding: "utf-8" });
@@ -8108,6 +8108,11 @@ function current_package_version(repo_root) {
   return _find_package_version_upward(here) ?? "0.0.0";
 }
 
+// src/scripts/_lib/scoped_projection.ts
+import * as fs4 from "node:fs";
+import { createRequire } from "node:module";
+import * as path4 from "node:path";
+
 // src/scripts/_lib/surface_tiers.ts
 import * as fs3 from "node:fs";
 import * as path3 from "node:path";
@@ -8198,11 +8203,108 @@ function _strip_quotes(s) {
   return out;
 }
 
+// src/scripts/_lib/scoped_projection.ts
+var _require = createRequire(import.meta.url);
+var SCOPED_ACTIVE_WORKSPACES = /* @__PURE__ */ new Set([
+  "engineering",
+  "agent-config-maintainer"
+]);
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function yamlSafeLoad(text) {
+  let YAML3;
+  try {
+    YAML3 = _require("yaml");
+  } catch {
+    return null;
+  }
+  try {
+    return YAML3.parse(text, { version: "1.1" }) ?? null;
+  } catch {
+    return null;
+  }
+}
+var PACKS_YML_REL = path4.join("src", "config", "discovery", "packs.yml");
+function load_packs_registry(package_root) {
+  const vocab_path = path4.join(package_root, PACKS_YML_REL);
+  const data = yamlSafeLoad(fs4.readFileSync(vocab_path, "utf-8"));
+  if (!Array.isArray(data)) {
+    throw new Error(`packs.yml did not parse to a list: ${vocab_path}`);
+  }
+  const out = [];
+  for (const entry of data) {
+    if (!isPlainObject(entry)) continue;
+    const id = entry["id"];
+    if (typeof id !== "string" || id === "") continue;
+    const workspaces_raw = entry["workspaces"];
+    const workspaces = Array.isArray(workspaces_raw) ? workspaces_raw.filter((w) => typeof w === "string") : [];
+    const requires_raw = entry["requires"] ?? entry["requires_hint"];
+    const requires = Array.isArray(requires_raw) ? requires_raw.filter((r) => typeof r === "string") : [];
+    out.push({ id, workspaces, requires });
+  }
+  return out;
+}
+function compute_active_pack_ids(packs, runtime_active_packs) {
+  const by_id = /* @__PURE__ */ new Map();
+  for (const p of packs) by_id.set(p.id, p);
+  const active = /* @__PURE__ */ new Set();
+  for (const p of packs) {
+    if (p.workspaces.some((w) => SCOPED_ACTIVE_WORKSPACES.has(w))) {
+      active.add(p.id);
+    }
+  }
+  for (const id of runtime_active_packs) {
+    active.add(id);
+  }
+  let frontier = [...active];
+  while (frontier.length > 0) {
+    const next = [];
+    for (const id of frontier) {
+      const rec = by_id.get(id);
+      if (rec === void 0) continue;
+      for (const dep of rec.requires) {
+        if (!active.has(dep)) {
+          active.add(dep);
+          next.push(dep);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return active;
+}
+function is_pruned_under_scoped(md_path, active_ids) {
+  const packs = frontmatter_packs(md_path);
+  if (packs.size === 0) return false;
+  for (const id of packs) {
+    if (active_ids.has(id)) return false;
+  }
+  return true;
+}
+var RULE_PACKS_AUTO = "auto";
+function resolve_rule_pack_scope(raw, package_root, runtime_active_packs = []) {
+  const is_auto = raw === RULE_PACKS_AUTO || Array.isArray(raw) && raw.length === 1 && raw[0] === RULE_PACKS_AUTO;
+  if (is_auto) {
+    try {
+      return [
+        ...compute_active_pack_ids(load_packs_registry(package_root), runtime_active_packs)
+      ].sort();
+    } catch {
+      return null;
+    }
+  }
+  if (Array.isArray(raw) && raw.length > 0) {
+    return raw.map((v) => String(v));
+  }
+  return null;
+}
+
 // src/scripts/_lib/global_deploy_inventory.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 import * as os3 from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 var SCHEMA_VERSION2 = 1;
 var INVENTORY_BASENAME = "deployed-files.json";
 var INVENTORY_ENV = "AGENT_CONFIG_DEPLOY_INVENTORY";
@@ -8211,22 +8313,22 @@ function expanduser3(p) {
     return os3.homedir();
   }
   if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
-    return path4.join(os3.homedir(), p.slice(2));
+    return path5.join(os3.homedir(), p.slice(2));
   }
   return p;
 }
 function resolve_path(p) {
   try {
-    return fs4.realpathSync(p);
+    return fs5.realpathSync(p);
   } catch {
-    const abs = path4.resolve(p);
-    const parts = abs.split(path4.sep);
+    const abs = path5.resolve(p);
+    const parts = abs.split(path5.sep);
     for (let i = parts.length; i > 0; i -= 1) {
-      const prefix = parts.slice(0, i).join(path4.sep) || path4.sep;
+      const prefix = parts.slice(0, i).join(path5.sep) || path5.sep;
       try {
-        const real = fs4.realpathSync(prefix);
+        const real = fs5.realpathSync(prefix);
         const rest = parts.slice(i);
-        return rest.length > 0 ? path4.join(real, ...rest) : real;
+        return rest.length > 0 ? path5.join(real, ...rest) : real;
       } catch {
         continue;
       }
@@ -8236,7 +8338,7 @@ function resolve_path(p) {
 }
 function path_exists(p) {
   try {
-    fs4.statSync(p);
+    fs5.statSync(p);
     return true;
   } catch {
     return false;
@@ -8254,7 +8356,7 @@ function load_inventory(p) {
   const target = p ?? inventory_path();
   let data;
   try {
-    data = JSON.parse(fs4.readFileSync(target, { encoding: "utf-8" }));
+    data = JSON.parse(fs5.readFileSync(target, { encoding: "utf-8" }));
   } catch {
     return { schema_version: SCHEMA_VERSION2, tools: {} };
   }
@@ -8265,15 +8367,15 @@ function load_inventory(p) {
 }
 function save_inventory(data, p) {
   const target = p ?? inventory_path();
-  fs4.mkdirSync(path4.dirname(target), { recursive: true });
+  fs5.mkdirSync(path5.dirname(target), { recursive: true });
   const payload = json_dumps_sorted(data, 2) + "\n";
-  const parent = path4.dirname(target);
+  const parent = path5.dirname(target);
   let fd = null;
   let tmp_name = "";
   for (let attempt = 0; attempt < 32; attempt += 1) {
-    tmp_name = path4.join(parent, `${path4.basename(target)}.${randomBytes2(6).toString("hex")}`);
+    tmp_name = path5.join(parent, `${path5.basename(target)}.${randomBytes2(6).toString("hex")}`);
     try {
-      fd = fs4.openSync(tmp_name, "wx", 384);
+      fd = fs5.openSync(tmp_name, "wx", 384);
       break;
     } catch (err) {
       if (err.code === "EEXIST") {
@@ -8286,16 +8388,16 @@ function save_inventory(data, p) {
     throw new Error("save_inventory: could not create a unique temp file");
   }
   try {
-    fs4.writeFileSync(fd, payload, { encoding: "utf-8" });
-    fs4.closeSync(fd);
-    fs4.renameSync(tmp_name, target);
+    fs5.writeFileSync(fd, payload, { encoding: "utf-8" });
+    fs5.closeSync(fd);
+    fs5.renameSync(tmp_name, target);
   } catch (err) {
     try {
-      fs4.closeSync(fd);
+      fs5.closeSync(fd);
     } catch {
     }
     try {
-      fs4.unlinkSync(tmp_name);
+      fs5.unlinkSync(tmp_name);
     } catch {
     }
     throw err;
@@ -8354,7 +8456,7 @@ function expected_deploy_files(src, dest_rel, file_filter = null) {
   const out = /* @__PURE__ */ new Set();
   let src_stat;
   try {
-    src_stat = fs4.statSync(src);
+    src_stat = fs5.statSync(src);
   } catch {
     return out;
   }
@@ -8366,23 +8468,23 @@ function expected_deploy_files(src, dest_rel, file_filter = null) {
     return out;
   }
   const _walk = (node, prefix) => {
-    const entries = fs4.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const entries = fs5.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const name of entries) {
-      const entry = path4.join(node, name);
+      const entry = path5.join(node, name);
       const rel = join_rel(prefix, name);
-      const lst = fs4.lstatSync(entry);
+      const lst = fs5.lstatSync(entry);
       if (lst.isDirectory() && !lst.isSymbolicLink()) {
         _walk(entry, rel);
         continue;
       }
       let resolved_is_dir = false;
       try {
-        resolved_is_dir = fs4.statSync(entry).isDirectory();
+        resolved_is_dir = fs5.statSync(entry).isDirectory();
       } catch {
         resolved_is_dir = false;
       }
       if (resolved_is_dir) {
-        _walk(fs4.realpathSync(entry), rel);
+        _walk(fs5.realpathSync(entry), rel);
         continue;
       }
       if (file_filter !== null && !file_filter(entry)) {
@@ -8395,13 +8497,13 @@ function expected_deploy_files(src, dest_rel, file_filter = null) {
   return out;
 }
 function join_rel(prefix, name) {
-  return prefix ? path4.join(prefix, name) : name;
+  return prefix ? path5.join(prefix, name) : name;
 }
 function as_posix(p) {
   if (p === "") {
     return ".";
   }
-  return p.split(path4.sep).join("/");
+  return p.split(path5.sep).join("/");
 }
 function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false) {
   const tools = inventory["tools"] ?? {};
@@ -8426,15 +8528,15 @@ function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false)
     if (typeof rel !== "string" || !rel || rel.startsWith("/") || rel.startsWith("..")) {
       continue;
     }
-    const target = path4.join(anchor_resolved, rel);
+    const target = path5.join(anchor_resolved, rel);
     try {
-      relative_to(resolve_path(path4.dirname(target)), anchor_resolved);
+      relative_to(resolve_path(path5.dirname(target)), anchor_resolved);
     } catch {
       continue;
     }
     let lst = null;
     try {
-      lst = fs4.lstatSync(target);
+      lst = fs5.lstatSync(target);
     } catch {
       lst = null;
     }
@@ -8448,12 +8550,12 @@ function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false)
       continue;
     }
     try {
-      fs4.unlinkSync(target);
+      fs5.unlinkSync(target);
     } catch {
       continue;
     }
     deleted.push(target);
-    prune_candidates.add(path4.dirname(target));
+    prune_candidates.add(path5.dirname(target));
   }
   prune_empty_dirs(prune_candidates, anchor_resolved);
   return deleted;
@@ -8464,10 +8566,10 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
   const prune_candidates = /* @__PURE__ */ new Set();
   const needle = `package: ${package_tag}`;
   for (const dest_sub of dest_subs) {
-    const root = dest_sub ? path4.join(anchor_resolved, dest_sub) : anchor_resolved;
+    const root = dest_sub ? path5.join(anchor_resolved, dest_sub) : anchor_resolved;
     let root_stat;
     try {
-      root_stat = fs4.statSync(root);
+      root_stat = fs5.statSync(root);
     } catch {
       continue;
     }
@@ -8477,7 +8579,7 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
     for (const md of rglob_md(root)) {
       let md_lst;
       try {
-        md_lst = fs4.lstatSync(md);
+        md_lst = fs5.lstatSync(md);
       } catch {
         continue;
       }
@@ -8489,13 +8591,13 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
         continue;
       }
       try {
-        relative_to(resolve_path(path4.dirname(md)), anchor_resolved);
+        relative_to(resolve_path(path5.dirname(md)), anchor_resolved);
       } catch {
         continue;
       }
       let head;
       try {
-        head = fs4.readFileSync(md, { encoding: "utf-8" });
+        head = fs5.readFileSync(md, { encoding: "utf-8" });
       } catch {
         continue;
       }
@@ -8513,12 +8615,12 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
         continue;
       }
       try {
-        fs4.unlinkSync(md);
+        fs5.unlinkSync(md);
       } catch {
         continue;
       }
       deleted.push(md);
-      prune_candidates.add(path4.dirname(md));
+      prune_candidates.add(path5.dirname(md));
     }
   }
   prune_empty_dirs(prune_candidates, anchor_resolved);
@@ -8538,51 +8640,51 @@ function record_deploy(tool_id, anchor, current_files, inventory) {
 }
 function prune_empty_dirs(prune_candidates, anchor_resolved) {
   const ordered = [...prune_candidates].sort(
-    (a, b) => b.split(path4.sep).length - a.split(path4.sep).length
+    (a, b) => b.split(path5.sep).length - a.split(path5.sep).length
   );
   for (const start of ordered) {
     let node = start;
     while (node !== anchor_resolved && is_ancestor(anchor_resolved, node)) {
       try {
-        fs4.rmdirSync(node);
+        fs5.rmdirSync(node);
       } catch {
         break;
       }
-      node = path4.dirname(node);
+      node = path5.dirname(node);
     }
   }
 }
 function is_ancestor(anchor, node) {
-  const rel = path4.relative(anchor, node);
-  return rel !== "" && !rel.startsWith("..") && !path4.isAbsolute(rel);
+  const rel = path5.relative(anchor, node);
+  return rel !== "" && !rel.startsWith("..") && !path5.isAbsolute(rel);
 }
 function relative_to(child, parent) {
   if (child === parent) {
     return "";
   }
-  const rel = path4.relative(parent, child);
-  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
+  const rel = path5.relative(parent, child);
+  if (rel.startsWith("..") || path5.isAbsolute(rel)) {
     throw new Error(`'${child}' is not in the subpath of '${parent}'`);
   }
   return rel;
 }
 function relative_to_posix(child, parent) {
-  return path4.relative(parent, child).split(path4.sep).join("/");
+  return path5.relative(parent, child).split(path5.sep).join("/");
 }
 function rglob_md(root) {
   const out = [];
   const walk = (dir) => {
     let names;
     try {
-      names = fs4.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      names = fs5.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     } catch {
       return;
     }
     for (const name of names) {
-      const full = path4.join(dir, name);
+      const full = path5.join(dir, name);
       let lst;
       try {
-        lst = fs4.lstatSync(full);
+        lst = fs5.lstatSync(full);
       } catch {
         continue;
       }
@@ -8623,13 +8725,13 @@ function splitlines2(text) {
 }
 
 // src/scripts/_lib/installed_tools.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as os4 from "node:os";
 import * as fsPath from "node:path";
 
 // src/scripts/_lib/fs_atomic.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 import { randomBytes as randomBytes3 } from "node:crypto";
 function _normalize_encoding(encoding) {
   const compact = encoding.toLowerCase().replace(/[-_\s]/g, "");
@@ -8645,9 +8747,9 @@ function _normalize_encoding(encoding) {
 }
 function write_atomic(p, data, options = {}) {
   const encoding = options.encoding ?? "utf-8";
-  const target = path5.normalize(p);
-  const parent = path5.dirname(target);
-  fs5.mkdirSync(parent, { recursive: true });
+  const target = path6.normalize(p);
+  const parent = path6.dirname(target);
+  fs6.mkdirSync(parent, { recursive: true });
   let payload;
   if (typeof data === "string") {
     payload = Buffer.from(data, _normalize_encoding(encoding));
@@ -8661,12 +8763,12 @@ function write_atomic(p, data, options = {}) {
   let fd = null;
   let tmp_path = "";
   for (let attempt = 0; attempt < 32; attempt += 1) {
-    tmp_path = path5.join(
+    tmp_path = path6.join(
       parent,
-      `.${path5.basename(target)}.tmp.${randomBytes3(6).toString("hex")}`
+      `.${path6.basename(target)}.tmp.${randomBytes3(6).toString("hex")}`
     );
     try {
-      fd = fs5.openSync(tmp_path, "wx", 384);
+      fd = fs6.openSync(tmp_path, "wx", 384);
       break;
     } catch (err) {
       if (err.code === "EEXIST") continue;
@@ -8680,24 +8782,24 @@ function write_atomic(p, data, options = {}) {
   try {
     let offset = 0;
     while (offset < payload.length) {
-      offset += fs5.writeSync(fd, payload, offset, payload.length - offset);
+      offset += fs6.writeSync(fd, payload, offset, payload.length - offset);
     }
     try {
-      fs5.fsyncSync(fd);
+      fs6.fsyncSync(fd);
     } catch {
     }
-    fs5.closeSync(fd);
+    fs6.closeSync(fd);
     closed = true;
-    fs5.renameSync(tmp_path, target);
+    fs6.renameSync(tmp_path, target);
   } catch (err) {
     if (!closed) {
       try {
-        fs5.closeSync(fd);
+        fs6.closeSync(fd);
       } catch {
       }
     }
     try {
-      fs5.unlinkSync(tmp_path);
+      fs6.unlinkSync(tmp_path);
     } catch {
     }
     throw err;
@@ -8708,17 +8810,17 @@ function write_atomic(p, data, options = {}) {
 function _fsync_dir(directory) {
   let dir_fd;
   try {
-    dir_fd = fs5.openSync(directory, fs5.constants.O_RDONLY);
+    dir_fd = fs6.openSync(directory, fs6.constants.O_RDONLY);
   } catch {
     return;
   }
   try {
     try {
-      fs5.fsyncSync(dir_fd);
+      fs6.fsyncSync(dir_fd);
     } catch {
     }
   } finally {
-    fs5.closeSync(dir_fd);
+    fs6.closeSync(dir_fd);
   }
 }
 
@@ -8747,18 +8849,18 @@ function manifest_path(project_root, env) {
 var _TOP_KEY_RE = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
 var _LIST_DASH_RE = /^\s*-\s*(.+?)\s*$/;
 var _INDENT_KEY_RE = /^\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
-function read_manifest(path15) {
+function read_manifest(path16) {
   let text;
   try {
-    text = require_read_text(path15);
+    text = require_read_text(path16);
   } catch {
     return null;
   }
   const data = _parse_manual(text);
   return _normalise_v2_shape(data);
 }
-function require_read_text(path15) {
-  return fs6.readFileSync(path15, { encoding: "utf-8" });
+function require_read_text(path16) {
+  return fs7.readFileSync(path16, { encoding: "utf-8" });
 }
 function _normalise_v2_shape(data) {
   if (data["tools"] === void 0 || data["tools"] === null) {
@@ -8939,9 +9041,9 @@ function stable_sort(items, key) {
     return a.index - b.index;
   }).map((entry) => entry.item);
 }
-function write_manifest(path15, version, tools, options = {}) {
+function write_manifest(path16, version, tools, options = {}) {
   const rendered = _render2(version, tools, { deploy_roots: options.deploy_roots ?? null });
-  return write_atomic(path15, rendered);
+  return write_atomic(path16, rendered);
 }
 var ScopeMismatchError = class extends Error {
   name_;
@@ -9032,25 +9134,25 @@ function _today() {
 // src/scripts/_lib/install_drift.ts
 var import_yaml = __toESM(require_dist(), 1);
 import * as crypto from "node:crypto";
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os5 from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 function expanduser5(p) {
   if (p === "~") {
     return os5.homedir();
   }
   if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
-    return path6.join(os5.homedir(), p.slice(2));
+    return path7.join(os5.homedir(), p.slice(2));
   }
   return p;
 }
 function resolve_entry_path(project_root, raw) {
   const p = expanduser5(raw);
-  return path6.isAbsolute(p) ? p : path6.join(project_root, p);
+  return path7.isAbsolute(p) ? p : path7.join(project_root, p);
 }
 function sha256_of_file(p) {
   try {
-    return crypto.createHash("sha256").update(fs7.readFileSync(p)).digest("hex");
+    return crypto.createHash("sha256").update(fs8.readFileSync(p)).digest("hex");
   } catch {
     return null;
   }
@@ -9059,7 +9161,7 @@ function collect_drift(project_root, env) {
   const target = manifest_path(project_root, env);
   let text;
   try {
-    text = fs7.readFileSync(target, "utf-8");
+    text = fs8.readFileSync(target, "utf-8");
   } catch {
     return null;
   }
@@ -9104,7 +9206,7 @@ function collect_drift(project_root, env) {
         continue;
       }
       const resolved = resolve_entry_path(project_root, raw_path);
-      if (!fs7.existsSync(resolved)) {
+      if (!fs8.existsSync(resolved)) {
         out.push({
           tool_id,
           path: resolved,
@@ -9158,8 +9260,8 @@ function format_drift_report(entries) {
 
 // src/scripts/_lib/claude_desktop_bundler.ts
 import * as crypto2 from "node:crypto";
-import * as fs8 from "node:fs";
-import * as path7 from "node:path";
+import * as fs9 from "node:fs";
+import * as path8 from "node:path";
 
 // src/scripts/_lib/zip_min.ts
 import * as zlib from "node:zlib";
@@ -9266,7 +9368,7 @@ function _is_excluded(rel_parts) {
 }
 function _is_dir(p) {
   try {
-    return fs8.statSync(p).isDirectory();
+    return fs9.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -9278,12 +9380,12 @@ function _compare_rel_parts(a, b) {
 }
 function _walk_skill_files(skill_dir) {
   const out = [];
-  const resolved = fs8.realpathSync(skill_dir);
+  const resolved = fs9.realpathSync(skill_dir);
   const walk = (root, relRoot) => {
     const dirNames = [];
     const fileNames = [];
-    for (const dirent of fs8.readdirSync(root, { withFileTypes: true })) {
-      const full = path7.join(root, dirent.name);
+    for (const dirent of fs9.readdirSync(root, { withFileTypes: true })) {
+      const full = path8.join(root, dirent.name);
       const isDir2 = dirent.isDirectory() || dirent.isSymbolicLink() && _is_dir(full);
       if (isDir2) {
         dirNames.push(dirent.name);
@@ -9296,13 +9398,13 @@ function _walk_skill_files(skill_dir) {
       if (_is_excluded(rel_parts)) {
         continue;
       }
-      out.push([path7.join(root, fname), rel_parts]);
+      out.push([path8.join(root, fname), rel_parts]);
     }
     for (const dname of dirNames) {
       if (_is_excluded([dname])) {
         continue;
       }
-      walk(path7.join(root, dname), [...relRoot, dname]);
+      walk(path8.join(root, dname), [...relRoot, dname]);
     }
   };
   walk(resolved, []);
@@ -9315,53 +9417,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(fs8.readFileSync(abs_path)).digest());
+    h.update(crypto2.createHash("sha256").update(fs9.readFileSync(abs_path)).digest());
     h.update(Buffer.from([0]));
   }
   return h.digest("hex");
 }
 function _atomic_write_zip(zip_path, files) {
-  fs8.mkdirSync(path7.dirname(zip_path), { recursive: true });
-  const stem = path7.basename(zip_path, path7.extname(zip_path));
-  const tmp_path = path7.join(
-    path7.dirname(zip_path),
+  fs9.mkdirSync(path8.dirname(zip_path), { recursive: true });
+  const stem = path8.basename(zip_path, path8.extname(zip_path));
+  const tmp_path = path8.join(
+    path8.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: fs8.readFileSync(abs_path)
+      data: fs9.readFileSync(abs_path)
     }));
-    fs8.writeFileSync(tmp_path, zip_write_sync(entries));
-    fs8.renameSync(tmp_path, zip_path);
+    fs9.writeFileSync(tmp_path, zip_write_sync(entries));
+    fs9.renameSync(tmp_path, zip_path);
   } finally {
-    if (fs8.existsSync(tmp_path)) {
-      fs8.unlinkSync(tmp_path);
+    if (fs9.existsSync(tmp_path)) {
+      fs9.unlinkSync(tmp_path);
     }
   }
 }
 function _write_if_changed(dest_dir, slug, files, force, written) {
   const digest = _manifest_digest(files);
-  const zip_path = path7.join(dest_dir, `${slug}.zip`);
-  const digest_path = path7.join(dest_dir, `${slug}.sha256`);
-  const recorded = fs8.existsSync(digest_path) ? fs8.readFileSync(digest_path, "utf-8").trim() : "";
-  if (!force && recorded === digest && fs8.existsSync(zip_path)) {
+  const zip_path = path8.join(dest_dir, `${slug}.zip`);
+  const digest_path = path8.join(dest_dir, `${slug}.sha256`);
+  const recorded = fs9.existsSync(digest_path) ? fs9.readFileSync(digest_path, "utf-8").trim() : "";
+  if (!force && recorded === digest && fs9.existsSync(zip_path)) {
     return;
   }
   _atomic_write_zip(zip_path, files);
-  fs8.writeFileSync(digest_path, digest + "\n", "utf-8");
+  fs9.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 = path7.join(package_root, "dist/agent-src", "skills");
+  const skills_root = path8.join(package_root, "dist/agent-src", "skills");
   if (!_is_dir(skills_root)) {
     return [];
   }
-  fs8.mkdirSync(dest_dir, { recursive: true });
+  fs9.mkdirSync(dest_dir, { recursive: true });
   const written = [];
-  for (const name of fs8.readdirSync(skills_root).sort()) {
-    const entry = path7.join(skills_root, name);
-    const isSymlink2 = fs8.lstatSync(entry).isSymbolicLink();
+  for (const name of fs9.readdirSync(skills_root).sort()) {
+    const entry = path8.join(skills_root, name);
+    const isSymlink2 = fs9.lstatSync(entry).isSymbolicLink();
     if (!(_is_dir(entry) || isSymlink2)) {
       continue;
     }
@@ -9369,8 +9471,8 @@ function build_skill_bundles(package_root, dest_dir, force = false, curation = n
     if (curation !== null && !curation.includes(skill_name)) {
       continue;
     }
-    const skill_md = path7.join(entry, "SKILL.md");
-    if (!fs8.existsSync(skill_md)) {
+    const skill_md = path8.join(entry, "SKILL.md");
+    if (!fs9.existsSync(skill_md)) {
       continue;
     }
     const files = _walk_skill_files(entry);
@@ -9382,15 +9484,15 @@ function build_skill_bundles(package_root, dest_dir, force = false, curation = n
   return written;
 }
 function _command_slug(source_file, commands_root) {
-  const rel = path7.relative(commands_root, source_file);
-  const noExt = rel.slice(0, rel.length - path7.extname(rel).length);
-  return noExt.split(path7.sep).join("-");
+  const rel = path8.relative(commands_root, source_file);
+  const noExt = rel.slice(0, rel.length - path8.extname(rel).length);
+  return noExt.split(path8.sep).join("-");
 }
 function _iter_command_files(commands_root) {
   const found = [];
   const walk = (dir) => {
-    for (const dirent of fs8.readdirSync(dir, { withFileTypes: true })) {
-      const full = path7.join(dir, dirent.name);
+    for (const dirent of fs9.readdirSync(dir, { withFileTypes: true })) {
+      const full = path8.join(dir, dirent.name);
       if (dirent.isDirectory() || dirent.isSymbolicLink() && _is_dir(full)) {
         walk(full);
       } else if (dirent.name.endsWith(".md")) {
@@ -9400,21 +9502,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) => path7.basename(source_file) !== "AGENTS.md");
+  return found.filter((source_file) => path8.basename(source_file) !== "AGENTS.md");
 }
 function build_command_bundles(package_root, dest_dir, force = false, curation = null) {
-  const commands_root = path7.join(package_root, "dist/agent-src", "commands");
+  const commands_root = path8.join(package_root, "dist/agent-src", "commands");
   if (!_is_dir(commands_root)) {
     return [];
   }
-  const skills_root = path7.join(package_root, "dist/agent-src", "skills");
+  const skills_root = path8.join(package_root, "dist/agent-src", "skills");
   let skill_names = /* @__PURE__ */ new Set();
   if (_is_dir(skills_root)) {
     skill_names = new Set(
-      fs8.readdirSync(skills_root).filter((name) => _is_dir(path7.join(skills_root, name)))
+      fs9.readdirSync(skills_root).filter((name) => _is_dir(path8.join(skills_root, name)))
     );
   }
-  fs8.mkdirSync(dest_dir, { recursive: true });
+  fs9.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);
@@ -9424,7 +9526,7 @@ function build_command_bundles(package_root, dest_dir, force = false, curation =
     if (curation !== null && !curation.includes(slug)) {
       continue;
     }
-    const files = [[fs8.realpathSync(source_file), ["SKILL.md"]]];
+    const files = [[fs9.realpathSync(source_file), ["SKILL.md"]]];
     _write_if_changed(dest_dir, slug, files, force, written);
   }
   return written;
@@ -9432,8 +9534,8 @@ function build_command_bundles(package_root, dest_dir, force = false, curation =
 
 // src/scripts/_lib/claude_settings_hooks.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs9 from "node:fs";
-import * as path8 from "node:path";
+import * as fs10 from "node:fs";
+import * as path9 from "node:path";
 
 // src/install/atomic.ts
 import {
@@ -9441,17 +9543,17 @@ import {
   fsyncSync,
   mkdirSync as mkdirSync5,
   openSync as openSync3,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   renameSync as renameSync5,
   unlinkSync as unlinkSync4,
   writeSync
 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 function atomicWriteFile(target, data, options = {}) {
   const mode = options.mode ?? 420;
   const parent = dirname4(target);
   mkdirSync5(parent, { recursive: true });
-  const tmp = join8(parent, `.tmp.${process.pid}.${randSuffix()}`);
+  const tmp = join9(parent, `.tmp.${process.pid}.${randSuffix()}`);
   let fd = null;
   try {
     fd = openSync3(tmp, "w", mode);
@@ -9501,7 +9603,7 @@ var SettingsLockError = class extends Error {
   }
 };
 function build_claude_hook_matrix(manifest_path2) {
-  const raw = fs9.readFileSync(manifest_path2, "utf8");
+  const raw = fs10.readFileSync(manifest_path2, "utf8");
   const manifest = _yaml_parse(raw) ?? {};
   const hook_spec = manifest["schema_version"] ?? 1;
   const platforms = manifest["platforms"] ?? {};
@@ -9517,7 +9619,8 @@ function build_claude_hook_matrix(manifest_path2) {
     if (!concerns || Array.isArray(concerns) && concerns.length === 0) continue;
     const native = ac_to_native[ac_event];
     if (native === void 0) continue;
-    matrix[native] = `BIN="$CLAUDE_PROJECT_DIR/agent-config"; [ -x "$BIN" ] || BIN=agent-config; command -v "$BIN" >/dev/null 2>&1 || exit 0; "$BIN" dispatch:hook --platform claude --event ${ac_event} --native-event ${native} --project-dir "$CLAUDE_PROJECT_DIR" --min-version ${String(hook_spec)}`;
+    const dispatchArgs = `--platform claude --event ${ac_event} --native-event ${native} --project-dir "$CLAUDE_PROJECT_DIR" --min-version ${String(hook_spec)}`;
+    matrix[native] = `B=""; [ -f "$CLAUDE_PROJECT_DIR/node_modules/@event4u/agent-config/dist/hooks/dispatch.js" ] && B="$CLAUDE_PROJECT_DIR/node_modules/@event4u/agent-config/dist/hooks/dispatch.js"; [ -z "$B" ] && [ -f "$CLAUDE_PROJECT_DIR/dist/hooks/dispatch.js" ] && [ -f "$CLAUDE_PROJECT_DIR/src/scripts/hook_manifest.yaml" ] && B="$CLAUDE_PROJECT_DIR/dist/hooks/dispatch.js"; if [ -n "$B" ] && command -v node >/dev/null 2>&1; then exec node "$B" ${dispatchArgs}; fi; BIN="$CLAUDE_PROJECT_DIR/agent-config"; [ -x "$BIN" ] || BIN=agent-config; command -v "$BIN" >/dev/null 2>&1 || exit 0; "$BIN" dispatch:hook ${dispatchArgs}`;
   }
   return matrix;
 }
@@ -9530,8 +9633,8 @@ function _is_managed_group(group) {
   );
 }
 function _read_settings(settings_path) {
-  if (!fs9.existsSync(settings_path)) return {};
-  const raw = fs9.readFileSync(settings_path, "utf8");
+  if (!fs10.existsSync(settings_path)) return {};
+  const raw = fs10.readFileSync(settings_path, "utf8");
   if (raw.trim() === "") return {};
   let parsed;
   try {
@@ -9546,18 +9649,18 @@ function _read_settings(settings_path) {
 }
 function _with_lock(settings_path, fn) {
   const lockPath = settings_path + ".agent-config.lock";
-  fs9.mkdirSync(path8.dirname(lockPath), { recursive: true });
+  fs10.mkdirSync(path9.dirname(lockPath), { recursive: true });
   let fd;
   try {
-    fd = fs9.openSync(lockPath, "wx");
+    fd = fs10.openSync(lockPath, "wx");
   } catch {
     throw new SettingsLockError(lockPath);
   }
   try {
     return fn();
   } finally {
-    fs9.closeSync(fd);
-    fs9.rmSync(lockPath, { force: true });
+    fs10.closeSync(fd);
+    fs10.rmSync(lockPath, { force: true });
   }
 }
 function ensure_managed_hooks(settings_path, matrix) {
@@ -9587,11 +9690,11 @@ function ensure_managed_hooks(settings_path, matrix) {
 }
 
 // src/scripts/_lib/agent_settings.ts
-import { createRequire } from "node:module";
-import * as fs10 from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import * as fs11 from "node:fs";
 import * as os6 from "node:os";
-import * as path9 from "node:path";
-var _require = createRequire(import.meta.url);
+import * as path10 from "node:path";
+var _require2 = createRequire2(import.meta.url);
 var Logger = class {
   name = "scripts._lib.agent_settings";
   records = [];
@@ -9630,10 +9733,10 @@ var DEFAULT_PROJECT_FILE = ".agent-settings.yml";
 var LOCAL_PROJECT_FILE = ".agent-settings.local.yml";
 var LOCAL_PROJECT_SUBDIR = ["agents", "settings"];
 function _local_settings_path(project_root) {
-  return path9.join(project_root, ...LOCAL_PROJECT_SUBDIR, LOCAL_PROJECT_FILE);
+  return path10.join(project_root, ...LOCAL_PROJECT_SUBDIR, LOCAL_PROJECT_FILE);
 }
 function _canonical_settings_path(project_root) {
-  return path9.join(project_root, ...LOCAL_PROJECT_SUBDIR, DEFAULT_PROJECT_FILE);
+  return path10.join(project_root, ...LOCAL_PROJECT_SUBDIR, DEFAULT_PROJECT_FILE);
 }
 var USER_GLOBAL_FILENAME = "agent-settings.yml";
 function DEFAULT_USER_GLOBAL_FILE() {
@@ -9681,8 +9784,8 @@ var _AGENTS_DIR_MARKERS = [
 var _LEGACY_ANCHOR_ENV = "AGENT_CONFIG_LEGACY_ANCHOR";
 function _exists(p) {
   try {
-    fs10.lstatSync(p);
-    fs10.statSync(p);
+    fs11.lstatSync(p);
+    fs11.statSync(p);
     return true;
   } catch {
     return false;
@@ -9690,22 +9793,22 @@ function _exists(p) {
 }
 function _is_dir2(p) {
   try {
-    return fs10.statSync(p).isDirectory();
+    return fs11.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _is_file(p) {
   try {
-    return fs10.statSync(p).isFile();
+    return fs11.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _resolve(p) {
-  const absolute = path9.resolve(p);
+  const absolute = path10.resolve(p);
   try {
-    return fs10.realpathSync(absolute);
+    return fs11.realpathSync(absolute);
   } catch {
     return absolute;
   }
@@ -9715,7 +9818,7 @@ function _ancestor_chain(start) {
   let cursor = start;
   for (; ; ) {
     chain.push(cursor);
-    const parent = path9.dirname(cursor);
+    const parent = path10.dirname(cursor);
     if (parent === cursor) {
       break;
     }
@@ -9724,15 +9827,15 @@ function _ancestor_chain(start) {
   return chain;
 }
 function _boundary_anchor_at(dir) {
-  const agents_dir = path9.join(dir, "agents");
+  const agents_dir = path10.join(dir, "agents");
   if (_is_dir2(agents_dir)) {
     for (const marker of _AGENTS_DIR_MARKERS) {
-      if (_exists(path9.join(agents_dir, marker))) {
+      if (_exists(path10.join(agents_dir, marker))) {
         return ANCHOR_AGENTS_DIR;
       }
     }
   }
-  if (_exists(path9.join(dir, ".git"))) {
+  if (_exists(path10.join(dir, ".git"))) {
     return ANCHOR_GIT;
   }
   return null;
@@ -9743,7 +9846,7 @@ function find_project_root_with_anchor(start) {
   const chain = _ancestor_chain(current);
   if (legacy) {
     for (const candidate of chain) {
-      if (_exists(path9.join(candidate, ".git"))) {
+      if (_exists(path10.join(candidate, ".git"))) {
         return [candidate, ANCHOR_GIT];
       }
     }
@@ -9757,7 +9860,7 @@ function find_project_root_with_anchor(start) {
   }
   let outermost = null;
   for (const candidate of chain) {
-    if (_exists(path9.join(candidate, DEFAULT_PROJECT_FILE))) {
+    if (_exists(path10.join(candidate, DEFAULT_PROJECT_FILE))) {
       outermost = candidate;
     }
   }
@@ -9801,7 +9904,7 @@ function _expanduser(p) {
     return os6.homedir();
   }
   if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
-    return path9.join(os6.homedir(), p.slice(2));
+    return path10.join(os6.homedir(), p.slice(2));
   }
   return p;
 }
@@ -9830,13 +9933,13 @@ function resolve_project_root(arg, options = {}) {
 function _resolve_cascade_paths(cwd, project_path) {
   if (cwd === null) {
     const legacy = project_path ? project_path : DEFAULT_PROJECT_FILE;
-    const parent = path9.dirname(legacy);
+    const parent = path10.dirname(legacy);
     return [legacy, _canonical_settings_path(parent), _local_settings_path(parent)];
   }
   const root = find_project_root(cwd);
   if (root === null) {
     const legacy = project_path ? project_path : DEFAULT_PROJECT_FILE;
-    const parent = path9.dirname(legacy);
+    const parent = path10.dirname(legacy);
     return [legacy, _canonical_settings_path(parent), _local_settings_path(parent)];
   }
   const cwd_resolved = _resolve(cwd);
@@ -9847,7 +9950,7 @@ function _resolve_cascade_paths(cwd, project_path) {
     if (cursor === root) {
       break;
     }
-    const parent = path9.dirname(cursor);
+    const parent = path10.dirname(cursor);
     if (parent === cursor) {
       break;
     }
@@ -9855,7 +9958,7 @@ function _resolve_cascade_paths(cwd, project_path) {
   }
   chain.reverse();
   return [
-    ...chain.map((d) => path9.join(d, DEFAULT_PROJECT_FILE)),
+    ...chain.map((d) => path10.join(d, DEFAULT_PROJECT_FILE)),
     _canonical_settings_path(root),
     _local_settings_path(root)
   ];
@@ -9890,13 +9993,13 @@ function _read_yaml(p) {
   }
   let YAML3;
   try {
-    YAML3 = _require("yaml");
+    YAML3 = _require2("yaml");
   } catch {
     return null;
   }
   let data;
   try {
-    const text = fs10.readFileSync(p, "utf-8");
+    const text = fs11.readFileSync(p, "utf-8");
     data = YAML3.parse(text, { version: "1.1" });
     if (data === null || data === void 0) {
       data = {};
@@ -9988,11 +10091,11 @@ function _is_plain_dict(value) {
 }
 
 // src/install/rule_scope.ts
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 
 // src/install/ruleInScope.ts
 var YAML2 = __toESM(require_dist(), 1);
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 function parseYaml2(text) {
   try {
     const data = YAML2.parse(text, { version: "1.1" });
@@ -10030,7 +10133,7 @@ function rule_in_scope(source_path, scope, pack_scope = null, role_scope = null)
   if (scope === null && pack_scope === null && role_scope === null) {
     return true;
   }
-  const [meta] = parseFrontmatter(fs11.readFileSync(source_path, "utf-8"));
+  const [meta] = parseFrontmatter(fs12.readFileSync(source_path, "utf-8"));
   if (meta["type"] === "always" || meta["alwaysApply"] === true) {
     return true;
   }
@@ -10056,23 +10159,32 @@ function _list(value) {
   }
   return null;
 }
-function ruleScopeFromSettings(settings) {
+function ruleScopeFromSettings(settings, packageRoot) {
   const proj = settings["projection"];
   if (typeof proj !== "object" || proj === null || Array.isArray(proj)) {
     return LEGACY_ALL;
   }
   const p = proj;
+  const packs = packageRoot === void 0 ? _list(p["rule_packs"]) : resolve_rule_pack_scope(
+    p["rule_packs"],
+    packageRoot,
+    _list(_runtimeActivePacks(settings)) ?? []
+  );
   return {
     workspaces: _list(p["rule_workspaces"]),
-    packs: _list(p["rule_packs"]),
+    packs,
     roles: _list(p["rule_roles"])
   };
 }
+function _runtimeActivePacks(settings) {
+  const rt = settings["runtime"];
+  return typeof rt === "object" && rt !== null && !Array.isArray(rt) ? rt["active_packs"] : null;
+}
 function ruleFileArrives(sourcePath, scope) {
   if (!sourcePath.endsWith(".md")) {
     return true;
   }
-  const basename5 = path10.basename(sourcePath);
+  const basename5 = path11.basename(sourcePath);
   if (COMPAT_ALWAYS_EXCLUDED.includes(basename5)) {
     return false;
   }
@@ -10630,8 +10742,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path15, errorMaps, issueData } = params;
-  const fullPath = [...path15, ...issueData.path || []];
+  const { data, path: path16, errorMaps, issueData } = params;
+  const fullPath = [...path16, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -10747,11 +10859,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path15, key) {
+  constructor(parent, value, path16, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path15;
+    this._path = path16;
     this._key = key;
   }
   get path() {
@@ -14233,8 +14345,8 @@ var settingsSchema = external_exports.object({
     rule_workspaces: external_exports.array(external_exports.string()).default([]).describe(
       "Workspace scope for the RULE layer only (road-to-request-scoped-rule-load P1/P1b, opt-in). Absent or empty = legacy-all: every rule projects AND installs. Non-empty = only rules whose workspaces frontmatter intersects this list are projected (condense) and installed (install.sh + global wizard payload). Kernel rules always ship; untagged rules fail safe. The default flip to a scoped value is a HUMAN release gate \u2014 do not set this from automation."
     ),
-    rule_packs: external_exports.array(external_exports.string()).default([]).describe(
-      "Optional second scoping axis for the RULE layer, per pack ids (src/config/discovery/packs.yml). When set, a non-kernel rule also needs a packs frontmatter intersection to ship \u2014 e.g. deselecting frontend-design drops ui-audit-gate + design-fidelity. Same opt-in / human-gate semantics as rule_workspaces."
+    rule_packs: external_exports.union([external_exports.literal("auto"), external_exports.array(external_exports.string())]).default([]).describe(
+      'Optional second scoping axis for the RULE layer, per pack ids (src/config/discovery/packs.yml). When set, a non-kernel rule also needs a packs frontmatter intersection to ship \u2014 e.g. deselecting frontend-design drops ui-audit-gate + design-fidelity. Same opt-in / human-gate semantics as rule_workspaces. The literal "auto" derives the id list from the active-pack set (the same set the skill/command prune uses), so a domain safety floor stops shipping into installs that do not have the pack it guards; an explicit list stays supported and wins over the derivation.'
     )
   }).default({ mode: "legacy-all" }),
   rule_loading_tier: ruleLoadingTier.default("balanced").describe(
@@ -14258,7 +14370,18 @@ var settingsSchema = external_exports.object({
       ),
       monthly: external_exports.number().min(0).default(0).describe(
         "Calendar-month USD ceiling. Pairs with cost.enforcement = hard-stop for a hard cap on agent spend before the next billing cycle. Set 0 to disable."
-      )
+      ),
+      per_tier: external_exports.object({
+        cheap: external_exports.number().min(0).nullable().default(null).describe(
+          "USD ceiling for the cheap model tier under budget-aware delegation (docs/contracts/budget-routing.md). null = no separate tier cap; global ceilings still apply."
+        ),
+        medium: external_exports.number().min(0).nullable().default(null).describe(
+          "USD ceiling for the medium model tier. null = no separate tier cap."
+        ),
+        strong: external_exports.number().min(0).nullable().default(null).describe(
+          "USD ceiling for the strong model tier. null = no separate tier cap \u2014 with cheap exhausted and strong funded, budget routing uses the strong tier rather than blocking work."
+        )
+      }).default({ cheap: null, medium: null, strong: null })
     }),
     enforcement: enforcementMode.default("advisory").describe(
       "What happens when a budget hits 100%. advisory = show a banner, keep working (default \u2014 never blocks an active task). hard-stop = refuse further model calls until the budget resets or you raise the ceiling."
@@ -14283,7 +14406,7 @@ var settingsSchema = external_exports.object({
       "Prefer short bullets and tables (true, default) vs verbose prose with rationale (false). Affects every chat reply; flip to false during debugging when you want the agent to think out loud."
     ),
     canary_name: external_exports.string().default("").describe(
-      'Session canary \u2014 the name the agent addresses you with at the start of every new task (e.g. "Alex"). When the greeting silently disappears, the context window is degrading: start a fresh conversation. Also keeps the reply-close markers (end-summary, PR URL as literal last line) alive. Empty = off. See rules/session-canary.md.'
+      'Session canary \u2014 the name the agent addresses you with at the start of every new task (e.g. "Alex"). When the greeting silently disappears, the context window is degrading: start a fresh conversation. Also keeps the reply-close markers (end-summary, PR URL as literal last line) alive. Empty = fall back to the user-global canary_name, then to identity.name from the setup wizard; no name anywhere = off. See rules/session-canary.md.'
     ),
     play_by_play: external_exports.boolean().default(false).describe(
       `Narrate intermediate findings between tool calls ("Found it.", "Let me check Y."). Off by default \u2014 most users find it noisy. Turn on when you want to follow the agent's reasoning step by step.`
@@ -14367,8 +14490,8 @@ var settingsSchema = external_exports.object({
     quality_cadence: qualityCadence.default("end_of_roadmap").describe(
       "When the agent runs the full quality / test suite during /roadmap:process-* runs. end_of_roadmap = once, after the last step (fastest, default). per_phase = after each phase boundary. per_step = after every single step (slowest, highest confidence)."
     ),
-    dashboard_regen_cadence: regenCadence.default("per_step").describe(
-      "How often the agent regenerates agents/roadmaps/dashboard.md during a roadmap run. per_step = after every step (default, freshest dashboard). every_5_steps = batch the regen. phase_boundary = only at phase edges."
+    dashboard_regen_cadence: regenCadence.default("every_5_steps").describe(
+      "How often the agent regenerates agents/roadmaps/dashboard.md during a roadmap run. every_5_steps = batch the regen (default). per_step = after every step (freshest dashboard, highest subprocess overhead). phase_boundary = only at phase edges. A rename, phase add, or archive always regenerates immediately regardless."
     ),
     horizon_weeks: external_exports.number().int().min(0).default(0).describe(
       'Optional planning horizon (weeks) the agent shows in roadmap framing ("next 4 weeks"). Set 0 to omit the horizon \u2014 most teams prefer to ship without a hardcoded window.'
@@ -14468,6 +14591,9 @@ var settingsSchema = external_exports.object({
     downshift: external_exports.boolean().default(true).describe(
       "Route delegable sub-tasks to the lowest-capable model tier (cost + speed via model downshift). false = every subagent runs on the session tier."
     ),
+    budget_routing: external_exports.enum(["ask", "auto", "off"]).default("ask").describe(
+      "Budget-aware cheap-request delegation (docs/contracts/budget-routing.md): pick the cheapest classifier-adequate tier WITH available budget (cost.budgets.per_tier); cheap exhausted but strong funded \u2192 strong tier; all exhausted \u2192 session model + notice. Work is never blocked to save money; the session model is never switched (delegation with a model override). ask = confirm the first budget-motivated downshift per session (default). auto = apply silently with telemetry. off = today's behavior (single-flip rollback). Distinct from downshift: that is the quality/cost knob, this is the resource-availability gate."
+    ),
     quota_arbitrage: external_exports.boolean().default(true).describe(
       "Prefer a separate quota-pool model for delegable sub-tasks where the host manifest reports one. Optional bonus only \u2014 identical behaviour (minus the quota win) where unsupported. Never load-bearing."
     ),
@@ -15981,8 +16107,8 @@ var zodToJsonSchema = (schema, options) => {
 };
 
 // src/scripts/_lib/module_detection.ts
-import * as fs12 from "node:fs";
-import * as path11 from "node:path";
+import * as fs13 from "node:fs";
+import * as path12 from "node:path";
 var _SKIP_DIRS = /* @__PURE__ */ new Set([".module-template", ".example"]);
 var _RULES = [
   ["app/Modules", "laravel-hmvc", "App\\Modules\\{ModuleName}"],
@@ -15996,14 +16122,14 @@ var _RULES = [
 ];
 function _isDir(p) {
   try {
-    return fs12.statSync(p).isDirectory();
+    return fs13.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _isFile(p) {
   try {
-    return fs12.statSync(p).isFile();
+    return fs13.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -16017,13 +16143,13 @@ function _isUpperChar(ch) {
 function _list_module_subdirs(root) {
   let entries;
   try {
-    entries = fs12.readdirSync(root).sort();
+    entries = fs13.readdirSync(root).sort();
   } catch {
     return [];
   }
   const out = [];
   for (const name of entries) {
-    if (!_isDir(path11.join(root, name))) {
+    if (!_isDir(path12.join(root, name))) {
       continue;
     }
     if (name.startsWith(".")) {
@@ -16045,11 +16171,11 @@ function _score_confidence(stack, root, subdirs) {
     return capitalized.length > 0 ? "high" : "medium";
   }
   if (stack === "node-monorepo") {
-    const withPkgJson = subdirs.filter((name) => _isFile(path11.join(root, name, "package.json")));
+    const withPkgJson = subdirs.filter((name) => _isFile(path12.join(root, name, "package.json")));
     return withPkgJson.length > 0 ? "high" : "medium";
   }
   if (stack === "python-src") {
-    const withInit = subdirs.filter((name) => _isFile(path11.join(root, name, "__init__.py")));
+    const withInit = subdirs.filter((name) => _isFile(path12.join(root, name, "__init__.py")));
     return withInit.length > 0 ? "high" : "medium";
   }
   if (stack === "go-internal") {
@@ -16061,7 +16187,7 @@ function detect_module_roots(project_root) {
   const high = [];
   const medium = [];
   for (const [rel_path, stack, namespace_template] of _RULES) {
-    const abs_path = path11.join(project_root, rel_path);
+    const abs_path = path12.join(project_root, rel_path);
     if (!_isDir(abs_path)) {
       continue;
     }
@@ -16083,7 +16209,7 @@ function detect_module_roots(project_root) {
 }
 
 // src/scripts/_lib/model_tier.ts
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 var TIER_TO_CLAUDE_MODEL = {
   high: "opus",
   medium: "sonnet",
@@ -16091,8 +16217,8 @@ var TIER_TO_CLAUDE_MODEL = {
 };
 var MODEL_TIER_RE = /^model_tier:\s*"?([a-z]+)"?\s*$/m;
 function read_model_tier(skill_md) {
-  if (!fs13.existsSync(skill_md)) return null;
-  const text = fs13.readFileSync(skill_md).toString("utf-8");
+  if (!fs14.existsSync(skill_md)) return null;
+  const text = fs14.readFileSync(skill_md).toString("utf-8");
   if (!text.startsWith("---\n")) return null;
   const end = text.indexOf("\n---\n", 4);
   if (end === -1) return null;
@@ -16109,39 +16235,39 @@ function render_native_model_md(text, tier) {
 
 // src/scripts/_cli/cmd_migrate.ts
 import { spawnSync } from "node:child_process";
-import * as fs15 from "node:fs";
-import * as path13 from "node:path";
+import * as fs16 from "node:fs";
+import * as path14 from "node:path";
 import process2 from "node:process";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 
 // src/scripts/_lib/package_root.ts
-import * as fs14 from "node:fs";
-import * as path12 from "node:path";
+import * as fs15 from "node:fs";
+import * as path13 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var PACKAGE_NAME = "@event4u/agent-config";
 var MAX_ASCENT = 16;
 function resolvePackageRoot(fromUrlOrPath, legacyHops = 3) {
   const start = fromUrlOrPath.startsWith("file:") ? fileURLToPath2(fromUrlOrPath) : fromUrlOrPath;
-  const startDir = path12.dirname(start);
+  const startDir = path13.dirname(start);
   let dir = startDir;
   for (let i = 0; i < MAX_ASCENT; i++) {
-    const manifest = path12.join(dir, "package.json");
-    if (fs14.existsSync(manifest)) {
+    const manifest = path13.join(dir, "package.json");
+    if (fs15.existsSync(manifest)) {
       try {
-        const parsed = JSON.parse(fs14.readFileSync(manifest, "utf8"));
+        const parsed = JSON.parse(fs15.readFileSync(manifest, "utf8"));
         if (parsed.name === PACKAGE_NAME) {
           return dir;
         }
       } catch {
       }
     }
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir) {
       break;
     }
     dir = parent;
   }
-  return path12.resolve(startDir, ...Array.from({ length: legacyHops }, () => ".."));
+  return path13.resolve(startDir, ...Array.from({ length: legacyHops }, () => ".."));
 }
 
 // src/scripts/_cli/cmd_migrate.ts
@@ -16162,7 +16288,7 @@ var LEGACY_SETTINGS_FILES = [".agent-settings.yml", ".agent-user.yml"];
 var LEGACY_STATE_FILENAME = ".implement-ticket-state.json";
 var LEGACY_STATE_V1_FILENAME = ".work-state.json";
 var LEGACY_AGENT_CONFIG_SHELL = "agent-config";
-var _HERE_DIR = path13.dirname(fileURLToPath3(import.meta.url));
+var _HERE_DIR = path14.dirname(fileURLToPath3(import.meta.url));
 var ArgparseExit = class extends Error {
   code;
   constructor(code) {
@@ -16261,38 +16387,38 @@ function _jsonDumpsIndentAscii(value, indent) {
 }
 function _isFile2(p) {
   try {
-    return fs15.statSync(p).isFile();
+    return fs16.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function _isDir2(p) {
   try {
-    return fs15.statSync(p).isDirectory();
+    return fs16.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _isSymlink(p) {
   try {
-    return fs15.lstatSync(p).isSymbolicLink();
+    return fs16.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function _exists2(p) {
   try {
-    fs15.lstatSync(p);
+    fs16.lstatSync(p);
     return true;
   } catch {
     return false;
   }
 }
 function _readText(p) {
-  return fs15.readFileSync(p, { encoding: "utf-8" });
+  return fs16.readFileSync(p, { encoding: "utf-8" });
 }
 function _writeText(p, text) {
-  fs15.writeFileSync(p, text, { encoding: "utf-8" });
+  fs16.writeFileSync(p, text, { encoding: "utf-8" });
 }
 function _jsonLoadFile(p) {
   return JSON.parse(_readText(p));
@@ -16348,7 +16474,7 @@ function _classify_symlink(link) {
   }
   let target;
   try {
-    target = fs15.readlinkSync(link);
+    target = fs16.readlinkSync(link);
   } catch {
     return null;
   }
@@ -16359,16 +16485,16 @@ function _classify_symlink(link) {
   return "user";
 }
 function _detect_legacy_state(project) {
-  return _isFile2(path13.join(project, LEGACY_STATE_FILENAME));
+  return _isFile2(path14.join(project, LEGACY_STATE_FILENAME));
 }
 function _detect_legacy_settings(project) {
   const found = [];
   for (const name of LEGACY_SETTINGS_FILES) {
-    const flat = path13.join(project, name);
+    const flat = path14.join(project, name);
     if (_isFile2(flat)) {
       found.push(flat);
     }
-    const typed = path13.join(project, "settings", name);
+    const typed = path14.join(project, "settings", name);
     if (_isFile2(typed)) {
       found.push(typed);
     }
@@ -16376,25 +16502,25 @@ function _detect_legacy_settings(project) {
   return found;
 }
 function _detect_empty_shell(project) {
-  const shell = path13.join(project, LEGACY_AGENT_CONFIG_SHELL);
+  const shell = path14.join(project, LEGACY_AGENT_CONFIG_SHELL);
   if (!_isDir2(shell) || _isSymlink(shell)) {
     return false;
   }
   try {
-    return fs15.readdirSync(shell).length === 0;
+    return fs16.readdirSync(shell).length === 0;
   } catch {
     return false;
   }
 }
 function _detect_already_migrated(project) {
-  if (_detect_npm(path13.join(project, "package.json"))) {
+  if (_detect_npm(path14.join(project, "package.json"))) {
     return false;
   }
-  if (_detect_composer(path13.join(project, "composer.json"))) {
+  if (_detect_composer(path14.join(project, "composer.json"))) {
     return false;
   }
   for (const name of MANAGED_SYMLINKS) {
-    if (_classify_symlink(path13.join(project, name)) === "legacy") {
+    if (_classify_symlink(path14.join(project, name)) === "legacy") {
       return false;
     }
   }
@@ -16465,11 +16591,11 @@ function _purge_legacy_symlinks(project) {
   const removed = [];
   const preserved = [];
   for (const name of MANAGED_SYMLINKS) {
-    const link = path13.join(project, name);
+    const link = path14.join(project, name);
     const kind = _classify_symlink(link);
     if (kind === "legacy") {
       try {
-        fs15.unlinkSync(link);
+        fs16.unlinkSync(link);
         removed.push(name);
       } catch {
         preserved.push(name);
@@ -16481,14 +16607,14 @@ function _purge_legacy_symlinks(project) {
   return [removed, preserved];
 }
 function _migrate_state_file(project) {
-  const source = path13.join(project, LEGACY_STATE_FILENAME);
+  const source = path14.join(project, LEGACY_STATE_FILENAME);
   if (!_isFile2(source)) {
     return null;
   }
-  const target = path13.join(project, LEGACY_STATE_V1_FILENAME);
+  const target = path14.join(project, LEGACY_STATE_V1_FILENAME);
   if (_exists2(target)) {
     try {
-      fs15.unlinkSync(source);
+      fs16.unlinkSync(source);
       return `removed stale ${LEGACY_STATE_FILENAME} (v1 already present)`;
     } catch {
       return null;
@@ -16503,7 +16629,7 @@ function _migrate_state_file(project) {
 }
 function _load_state_migrator() {
   const pkg_root = resolvePackageRoot(import.meta.url);
-  const rel = path13.join(
+  const rel = path14.join(
     "agent-src",
     "templates",
     "scripts",
@@ -16511,8 +16637,8 @@ function _load_state_migrator() {
     "migration",
     "v0_to_v1.ts"
   );
-  const driver = [path13.join(pkg_root, "dist", rel), path13.join(pkg_root, "src", rel)].find(
-    (p) => fs15.existsSync(p)
+  const driver = [path14.join(pkg_root, "dist", rel), path14.join(pkg_root, "src", rel)].find(
+    (p) => fs16.existsSync(p)
   ) ?? null;
   if (driver === null) {
     return null;
@@ -16520,12 +16646,12 @@ function _load_state_migrator() {
   const binName = process2.platform === "win32" ? "tsx.cmd" : "tsx";
   let tsxBin = null;
   for (let dir = pkg_root; ; ) {
-    const cand = path13.join(dir, "node_modules", ".bin", binName);
-    if (fs15.existsSync(cand)) {
+    const cand = path14.join(dir, "node_modules", ".bin", binName);
+    if (fs16.existsSync(cand)) {
       tsxBin = cand;
       break;
     }
-    const parent = path13.dirname(dir);
+    const parent = path14.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -16552,17 +16678,17 @@ function _delete_legacy_settings(project) {
   const removed = [];
   for (const p of _detect_legacy_settings(project)) {
     try {
-      fs15.unlinkSync(p);
-      removed.push(path13.relative(project, p));
+      fs16.unlinkSync(p);
+      removed.push(path14.relative(project, p));
     } catch {
       continue;
     }
   }
-  const settings_dir = path13.join(project, "settings");
+  const settings_dir = path14.join(project, "settings");
   if (_isDir2(settings_dir) && !_isSymlink(settings_dir)) {
     try {
-      if (fs15.readdirSync(settings_dir).length === 0) {
-        fs15.rmdirSync(settings_dir);
+      if (fs16.readdirSync(settings_dir).length === 0) {
+        fs16.rmdirSync(settings_dir);
         removed.push("settings/");
       }
     } catch {
@@ -16571,12 +16697,12 @@ function _delete_legacy_settings(project) {
   return removed;
 }
 function _remove_empty_shell(project) {
-  const shell = path13.join(project, LEGACY_AGENT_CONFIG_SHELL);
+  const shell = path14.join(project, LEGACY_AGENT_CONFIG_SHELL);
   if (!_detect_empty_shell(project)) {
     return false;
   }
   try {
-    fs15.rmdirSync(shell);
+    fs16.rmdirSync(shell);
   } catch {
     return false;
   }
@@ -16586,7 +16712,7 @@ function _reEscape(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function _update_gitignore(project) {
-  const gitignore = path13.join(project, ".gitignore");
+  const gitignore = path14.join(project, ".gitignore");
   const block = `${GITIGNORE_BLOCK_START}
 ${GITIGNORE_NEW_BODY}${GITIGNORE_BLOCK_END}
 `;
@@ -16617,16 +16743,16 @@ ${GITIGNORE_NEW_BODY}${GITIGNORE_BLOCK_END}
 }
 function _build_plan(project) {
   return {
-    npm: _detect_npm(path13.join(project, "package.json")),
-    composer: _detect_composer(path13.join(project, "composer.json")),
+    npm: _detect_npm(path14.join(project, "package.json")),
+    composer: _detect_composer(path14.join(project, "composer.json")),
     symlinks_legacy: MANAGED_SYMLINKS.filter(
-      (name) => _classify_symlink(path13.join(project, name)) === "legacy"
+      (name) => _classify_symlink(path14.join(project, name)) === "legacy"
     ),
     symlinks_user: MANAGED_SYMLINKS.filter(
-      (name) => _classify_symlink(path13.join(project, name)) === "user"
+      (name) => _classify_symlink(path14.join(project, name)) === "user"
     ),
-    state_file: _isFile2(path13.join(project, LEGACY_STATE_FILENAME)),
-    settings_files: _detect_legacy_settings(project).map((p) => path13.relative(project, p)),
+    state_file: _isFile2(path14.join(project, LEGACY_STATE_FILENAME)),
+    settings_files: _detect_legacy_settings(project).map((p) => path14.relative(project, p)),
     empty_shell: _detect_empty_shell(project)
   };
 }
@@ -16690,10 +16816,10 @@ function _warn_on_major_mismatch(from_major, plan, out) {
 }
 function _apply(project, out, err) {
   const summary = [];
-  if (_strip_npm_entry(path13.join(project, "package.json"))) {
+  if (_strip_npm_entry(path14.join(project, "package.json"))) {
     summary.push(`removed ${PACKAGE_NAME_NPM} from package.json`);
   }
-  if (_strip_composer_entry(path13.join(project, "composer.json"))) {
+  if (_strip_composer_entry(path14.join(project, "composer.json"))) {
     summary.push(`removed ${PACKAGE_NAME_COMPOSER} from composer.json`);
   }
   const [removed_links, preserved_links] = _purge_legacy_symlinks(project);
@@ -16819,13 +16945,13 @@ function _isCliEntry() {
   if (process2.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL(path13.resolve(process2.argv[1])).href;
+  const argvUrl = pathToFileURL(path14.resolve(process2.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs15.realpathSync(fileURLToPath3(import.meta.url));
-    const argv = fs15.realpathSync(path13.resolve(process2.argv[1]));
+    const here = fs16.realpathSync(fileURLToPath3(import.meta.url));
+    const argv = fs16.realpathSync(path14.resolve(process2.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -16862,34 +16988,34 @@ var ArgparseExit2 = class extends Error {
 function expanduser6(p) {
   if (p === "~") return os7.homedir();
   if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return path14.join(os7.homedir(), p.slice(2));
+    return path15.join(os7.homedir(), p.slice(2));
   }
   return p;
 }
 function resolvePath(p) {
   try {
-    return fs16.realpathSync(path14.resolve(p));
+    return fs17.realpathSync(path15.resolve(p));
   } catch {
-    return path14.resolve(p);
+    return path15.resolve(p);
   }
 }
 function isFile(p) {
   try {
-    return fs16.statSync(p).isFile();
+    return fs17.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir(p) {
   try {
-    return fs16.statSync(p).isDirectory();
+    return fs17.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function pathExists(p) {
   try {
-    fs16.statSync(p);
+    fs17.statSync(p);
     return true;
   } catch {
     return false;
@@ -16897,24 +17023,24 @@ function pathExists(p) {
 }
 function isSymlink(p) {
   try {
-    return fs16.lstatSync(p).isSymbolicLink();
+    return fs17.lstatSync(p).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function readText(p) {
-  return fs16.readFileSync(p, "utf-8");
+  return fs17.readFileSync(p, "utf-8");
 }
 function writeText(p, content) {
-  fs16.writeFileSync(p, content, "utf-8");
+  fs17.writeFileSync(p, content, "utf-8");
 }
 function mkdirp(p) {
-  fs16.mkdirSync(p, { recursive: true });
+  fs17.mkdirSync(p, { recursive: true });
 }
 function sortedGlobStems(directory, suffix) {
   let entries;
   try {
-    entries = fs16.readdirSync(directory);
+    entries = fs17.readdirSync(directory);
   } catch {
     return [];
   }
@@ -16934,7 +17060,7 @@ function sortedGlobStems(directory, suffix) {
 function countZips(directory) {
   if (!isDir(directory)) return 0;
   let n = 0;
-  for (const name of fs16.readdirSync(directory)) {
+  for (const name of fs17.readdirSync(directory)) {
     if (name.endsWith(".zip")) n += 1;
   }
   return n;
@@ -16942,35 +17068,35 @@ function countZips(directory) {
 function sha256OfFile(p) {
   let data;
   try {
-    data = fs16.readFileSync(p);
+    data = fs17.readFileSync(p);
   } catch {
     return null;
   }
   return crypto3.createHash("sha256").update(data).digest("hex");
 }
 function atomicWrite0644(target, body, prefix) {
-  const dir = path14.dirname(target);
-  const tmpName = path14.join(
+  const dir = path15.dirname(target);
+  const tmpName = path15.join(
     dir,
     `${prefix}${process3.pid}.${crypto3.randomBytes(6).toString("hex")}.yml.tmp`
   );
   let fd = null;
   try {
-    fd = fs16.openSync(tmpName, "wx", 420);
-    fs16.writeFileSync(fd, body, "utf-8");
-    fs16.closeSync(fd);
+    fd = fs17.openSync(tmpName, "wx", 420);
+    fs17.writeFileSync(fd, body, "utf-8");
+    fs17.closeSync(fd);
     fd = null;
-    fs16.chmodSync(tmpName, 420);
-    fs16.renameSync(tmpName, target);
+    fs17.chmodSync(tmpName, 420);
+    fs17.renameSync(tmpName, target);
   } catch (err) {
     if (fd !== null) {
       try {
-        fs16.closeSync(fd);
+        fs17.closeSync(fd);
       } catch {
       }
     }
     try {
-      fs16.unlinkSync(tmpName);
+      fs17.unlinkSync(tmpName);
     } catch {
     }
     throw err;
@@ -17070,7 +17196,7 @@ function jsonDumpsCompact(value) {
   }
   return _jsonStrNoAscii(String(value));
 }
-function yamlSafeLoad(text) {
+function yamlSafeLoad2(text) {
   let YAML3;
   try {
     YAML3 = require_dist();
@@ -17094,12 +17220,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 path14.join(project_root, ...SETTINGS_SUBDIR, SETTINGS_FILE);
+  return path15.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 = path14.join(project_root, SETTINGS_FILE);
+  const legacy = path15.join(project_root, SETTINGS_FILE);
   if (pathExists(legacy)) return legacy;
   return canonical;
 }
@@ -17163,9 +17289,9 @@ function fail(msg) {
   throw new SystemExitError(1);
 }
 function detect_package_root(project_root) {
-  const npm_path = path14.join(project_root, "node_modules", "@event4u", "agent-config");
+  const npm_path = path15.join(project_root, "node_modules", "@event4u", "agent-config");
   if (isDir(npm_path)) return resolvePath(npm_path);
-  if (pathExists(path14.join(project_root, "src", "config", "profiles", "minimal.ini"))) {
+  if (pathExists(path15.join(project_root, "src", "config", "profiles", "minimal.ini"))) {
     return project_root;
   }
   fail(
@@ -17173,12 +17299,12 @@ function detect_package_root(project_root) {
   );
 }
 function detect_package_type(package_root) {
-  if (package_root.split(path14.sep).includes("node_modules")) return "npm";
+  if (package_root.split(path15.sep).includes("node_modules")) return "npm";
   return "local";
 }
 function detect_package_type_for_project(project_root, package_root) {
   const npm_path = resolvePath(
-    path14.join(project_root, "node_modules", "@event4u", "agent-config")
+    path15.join(project_root, "node_modules", "@event4u", "agent-config")
   );
   const package_resolved = resolvePath(package_root);
   if (package_resolved === npm_path) return "npm";
@@ -17198,7 +17324,7 @@ function ensure_directory(p) {
   mkdirp(p);
 }
 function write_file(p, content) {
-  ensure_directory(path14.dirname(p));
+  ensure_directory(path15.dirname(p));
   writeText(p, content);
 }
 function read_json_file(p) {
@@ -17369,7 +17495,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 = path14.join(project_root, LEGACY_SETTINGS_FILE);
+  const legacy_target = path15.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);
@@ -17384,9 +17510,9 @@ function _migrate_legacy_if_present(project_root, template_body) {
     }
   }
   rendered = _append_unknown_legacy(rendered, values, unknown);
-  const backup_target = path14.join(project_root, LEGACY_BACKUP_FILE);
+  const backup_target = path15.join(project_root, LEGACY_BACKUP_FILE);
   writeText(backup_target, legacy_text);
-  fs16.unlinkSync(legacy_target);
+  fs17.unlinkSync(legacy_target);
   info(`Migrated legacy ${LEGACY_SETTINGS_FILE} \u2192 ${SETTINGS_FILE}`);
   info(`Backup saved to ${LEGACY_BACKUP_FILE}`);
   if (unknown.length > 0) {
@@ -17421,7 +17547,7 @@ function _render_template(template, profile_values) {
   return body;
 }
 function _load_valid_user_types(package_root) {
-  const directory = path14.join(package_root, USER_TYPES_DIR);
+  const directory = path15.join(package_root, USER_TYPES_DIR);
   if (!isDir(directory)) return [];
   return sortedGlobStems(directory, ".yml");
 }
@@ -17478,8 +17604,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 = path14.join(package_root, "src", "config", "profiles", `${profile}.ini`);
-  const template_source = path14.join(package_root, "src", "config", "agent-settings.template.yml");
+  const profile_source = path15.join(package_root, "src", "config", "profiles", `${profile}.ini`);
+  const template_source = path15.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);
@@ -17493,21 +17619,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 ${path14.basename(profile_source)} has rule_loading_tier=${got} but --profile=${profile}`
+      `Profile preset ${path15.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 = path14.join(project_root, SETTINGS_FILE);
+  const legacy_root = path15.join(project_root, SETTINGS_FILE);
   if (isFile(legacy_root) && !pathExists(target)) {
-    mkdirp(path14.dirname(target));
+    mkdirp(path15.dirname(target));
     writeText(target, readText(legacy_root));
-    fs16.unlinkSync(legacy_root);
+    fs17.unlinkSync(legacy_root);
     success(`Migrated ${SETTINGS_FILE} \u2192 agents/settings/${SETTINGS_FILE} (ADR-038)`);
     return;
   }
-  const legacy_target = path14.join(project_root, LEGACY_SETTINGS_FILE);
+  const legacy_target = path15.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.`
@@ -17524,7 +17650,7 @@ function ensure_agent_settings(project_root, package_root, profile, force, user_
     skip(`${SETTINGS_FILE} already exists`);
     return;
   }
-  mkdirp(path14.dirname(target));
+  mkdirp(path15.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}` : "";
@@ -17537,7 +17663,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 } };
   merge_json_file(
-    path14.join(project_root, ".vscode", "settings.json"),
+    path15.join(project_root, ".vscode", "settings.json"),
     bridge,
     force,
     ".vscode/settings.json"
@@ -17546,14 +17672,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(
-    path14.join(project_root, ".augment", "settings.json"),
+    path15.join(project_root, ".augment", "settings.json"),
     bridge,
     force,
     ".augment/settings.json"
   );
 }
-var AUGMENT_USER_DIR = path14.join(os7.homedir(), ".augment");
-var AUGMENT_USER_HOOKS_DIR = path14.join(AUGMENT_USER_DIR, "hooks");
+var AUGMENT_USER_DIR = path15.join(os7.homedir(), ".augment");
+var AUGMENT_USER_HOOKS_DIR = path15.join(AUGMENT_USER_DIR, "hooks");
 var AUGMENT_DISPATCHER_TRAMPOLINE = "augment-dispatcher.sh";
 var AUGMENT_LEGACY_TRAMPOLINES = [
   "augment-chat-history.sh",
@@ -17569,29 +17695,29 @@ var AUGMENT_DISPATCHER_BINDINGS = [
   ["post_tool_use", "PostToolUse"]
 ];
 function _deploy_augment_trampoline(package_root, name, force) {
-  const src = path14.join(package_root, "scripts", "hooks", name);
+  const src = path15.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 = path14.join(AUGMENT_USER_HOOKS_DIR, name);
+  const dst = path15.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);
-    fs16.chmodSync(dst, 493);
+    fs17.chmodSync(dst, 493);
     success(`~/.augment/hooks/${name} installed`);
   }
   return dst;
 }
 function _remove_legacy_augment_trampolines() {
   for (const name of AUGMENT_LEGACY_TRAMPOLINES) {
-    const legacy = path14.join(AUGMENT_USER_HOOKS_DIR, name);
+    const legacy = path15.join(AUGMENT_USER_HOOKS_DIR, name);
     try {
       if (isFile(legacy)) {
-        fs16.unlinkSync(legacy);
+        fs17.unlinkSync(legacy);
         skip(`removed legacy ~/.augment/hooks/${name}`);
       }
     } catch {
@@ -17610,7 +17736,7 @@ function ensure_augment_user_hooks(package_root, force) {
   }
   const settings_patch = { hooks: per_event };
   return merge_json_file(
-    path14.join(AUGMENT_USER_DIR, "settings.json"),
+    path15.join(AUGMENT_USER_DIR, "settings.json"),
     settings_patch,
     force,
     "~/.augment/settings.json"
@@ -17635,7 +17761,7 @@ function _heal_legacy_claude_plugin_ids(p) {
   return removed;
 }
 function ensure_claude_bridge(project_root, force) {
-  const target = path14.join(project_root, ".claude", "settings.json");
+  const target = path15.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}\``);
@@ -17660,29 +17786,29 @@ function ensure_cursor_bridge(project_root, force) {
   }
   const bridge = { version: 1, hooks };
   return merge_json_file(
-    path14.join(project_root, ".cursor", "hooks.json"),
+    path15.join(project_root, ".cursor", "hooks.json"),
     bridge,
     force,
     ".cursor/hooks.json"
   );
 }
-var CURSOR_USER_DIR = path14.join(os7.homedir(), ".cursor");
-var CURSOR_USER_HOOKS_DIR = path14.join(CURSOR_USER_DIR, "hooks");
+var CURSOR_USER_DIR = path15.join(os7.homedir(), ".cursor");
+var CURSOR_USER_HOOKS_DIR = path15.join(CURSOR_USER_DIR, "hooks");
 var CURSOR_DISPATCHER_TRAMPOLINE = "cursor-dispatcher.sh";
 function ensure_cursor_user_hooks(package_root, force) {
-  const src = path14.join(package_root, "scripts", "hooks", CURSOR_DISPATCHER_TRAMPOLINE);
+  const src = path15.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 = path14.join(CURSOR_USER_HOOKS_DIR, CURSOR_DISPATCHER_TRAMPOLINE);
+  const dst = path15.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);
-    fs16.chmodSync(dst, 493);
+    fs17.chmodSync(dst, 493);
     success(`~/.cursor/hooks/${CURSOR_DISPATCHER_TRAMPOLINE} installed`);
   }
   const hooks = {};
@@ -17691,7 +17817,7 @@ function ensure_cursor_user_hooks(package_root, force) {
   }
   const settings_patch = { version: 1, hooks };
   return merge_json_file(
-    path14.join(CURSOR_USER_DIR, "hooks.json"),
+    path15.join(CURSOR_USER_DIR, "hooks.json"),
     settings_patch,
     force,
     "~/.cursor/hooks.json"
@@ -17734,12 +17860,12 @@ exit 0
 `;
 }
 function ensure_cline_bridge(project_root, force) {
-  const hooks_dir = path14.join(project_root, ".clinerules", "hooks");
+  const hooks_dir = path15.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 = path14.join(hooks_dir, native_event);
+    const target = path15.join(hooks_dir, native_event);
     const body = clineProjectHookBody(native_event, ac_event, workspace_quoted);
     if (pathExists(target) && readText(target) === body && !force) {
       continue;
@@ -17749,7 +17875,7 @@ function ensure_cline_bridge(project_root, force) {
       continue;
     }
     writeText(target, body);
-    fs16.chmodSync(target, 493);
+    fs17.chmodSync(target, 493);
     written += 1;
   }
   if (written) {
@@ -17758,27 +17884,27 @@ function ensure_cline_bridge(project_root, force) {
     skip(".clinerules/hooks/ already up to date");
   }
 }
-var CLINE_USER_DIR = path14.join(os7.homedir(), "Documents", "Cline", "Hooks");
+var CLINE_USER_DIR = path15.join(os7.homedir(), "Documents", "Cline", "Hooks");
 var CLINE_DISPATCHER_TRAMPOLINE = "cline-dispatcher.sh";
 function ensure_cline_user_hooks(package_root, force) {
-  const src = path14.join(package_root, "scripts", "hooks", CLINE_DISPATCHER_TRAMPOLINE);
+  const src = path15.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 = path14.join(CLINE_USER_DIR, CLINE_DISPATCHER_TRAMPOLINE);
+  const trampoline = path15.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);
-    fs16.chmodSync(trampoline, 493);
+    fs17.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 = path14.join(CLINE_USER_DIR, native_event);
+    const wrapper = path15.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}.
@@ -17788,7 +17914,7 @@ exec ${trampoline_quoted} ${ac_event} ${native_event}
       continue;
     }
     writeText(wrapper, body);
-    fs16.chmodSync(wrapper, 493);
+    fs17.chmodSync(wrapper, 493);
   }
 }
 var WINDSURF_DISPATCHER_BINDINGS = [
@@ -17809,29 +17935,29 @@ function ensure_windsurf_bridge(project_root, force) {
   }
   const bridge = { hooks };
   return merge_json_file(
-    path14.join(project_root, ".windsurf", "hooks.json"),
+    path15.join(project_root, ".windsurf", "hooks.json"),
     bridge,
     force,
     ".windsurf/hooks.json"
   );
 }
-var WINDSURF_USER_DIR = path14.join(os7.homedir(), ".codeium", "windsurf");
-var WINDSURF_USER_HOOKS_DIR = path14.join(WINDSURF_USER_DIR, "hooks");
+var WINDSURF_USER_DIR = path15.join(os7.homedir(), ".codeium", "windsurf");
+var WINDSURF_USER_HOOKS_DIR = path15.join(WINDSURF_USER_DIR, "hooks");
 var WINDSURF_DISPATCHER_TRAMPOLINE = "windsurf-dispatcher.sh";
 function ensure_windsurf_user_hooks(package_root, force) {
-  const src = path14.join(package_root, "scripts", "hooks", WINDSURF_DISPATCHER_TRAMPOLINE);
+  const src = path15.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 = path14.join(WINDSURF_USER_HOOKS_DIR, WINDSURF_DISPATCHER_TRAMPOLINE);
+  const dst = path15.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);
-    fs16.chmodSync(dst, 493);
+    fs17.chmodSync(dst, 493);
     success(`~/.codeium/windsurf/hooks/${WINDSURF_DISPATCHER_TRAMPOLINE} installed`);
   }
   const hooks = {};
@@ -17843,7 +17969,7 @@ function ensure_windsurf_user_hooks(package_root, force) {
   }
   const settings_patch = { hooks };
   return merge_json_file(
-    path14.join(WINDSURF_USER_DIR, "hooks.json"),
+    path15.join(WINDSURF_USER_DIR, "hooks.json"),
     settings_patch,
     force,
     "~/.codeium/windsurf/hooks.json"
@@ -17872,43 +17998,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(
-    path14.join(project_root, ".gemini", "settings.json"),
+    path15.join(project_root, ".gemini", "settings.json"),
     bridge,
     force,
     ".gemini/settings.json"
   );
 }
-var GEMINI_USER_DIR = path14.join(os7.homedir(), ".gemini");
-var GEMINI_USER_HOOKS_DIR = path14.join(GEMINI_USER_DIR, "hooks");
+var GEMINI_USER_DIR = path15.join(os7.homedir(), ".gemini");
+var GEMINI_USER_HOOKS_DIR = path15.join(GEMINI_USER_DIR, "hooks");
 var GEMINI_DISPATCHER_TRAMPOLINE = "gemini-dispatcher.sh";
 function ensure_gemini_user_hooks(package_root, force) {
-  const src = path14.join(package_root, "scripts", "hooks", GEMINI_DISPATCHER_TRAMPOLINE);
+  const src = path15.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 = path14.join(GEMINI_USER_HOOKS_DIR, GEMINI_DISPATCHER_TRAMPOLINE);
+  const dst = path15.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);
-    fs16.chmodSync(dst, 493);
+    fs17.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(
-    path14.join(GEMINI_USER_DIR, "settings.json"),
+    path15.join(GEMINI_USER_DIR, "settings.json"),
     settings_patch,
     force,
     "~/.gemini/settings.json"
   );
 }
 function ensure_copilot_bridge(project_root, force) {
-  const target = path14.join(project_root, ".github", "plugin", "marketplace.json");
+  const target = path15.join(project_root, ".github", "plugin", "marketplace.json");
   const bridge = {
     marketplace: {
       name: "event4u-agent-marketplace",
@@ -17951,7 +18077,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 = path14.join(project_root, ".roo", "rules", "agent-config.md");
+  const target = path15.join(project_root, ".roo", "rules", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".roo/rules/agent-config.md already exists");
     return;
@@ -17973,7 +18099,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 = path14.join(project_root, ".claude-desktop", "agent-config.md");
+  const target = path15.join(project_root, ".claude-desktop", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".claude-desktop/agent-config.md already exists");
     return;
@@ -17998,7 +18124,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 = path14.join(project_root, ".aider", "agent-config.md");
+  const target = path15.join(project_root, ".aider", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".aider/agent-config.md already exists");
     return;
@@ -18017,7 +18143,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 = path14.join(project_root, ".codex", "agent-config.md");
+  const target = path15.join(project_root, ".codex", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".codex/agent-config.md already exists");
     return;
@@ -18035,7 +18161,7 @@ rules per session. The canonical rule and skill source lives under
 orientation).
 `;
 function ensure_continue_bridge(project_root, force) {
-  const target = path14.join(project_root, ".continue", "rules", "agent-config.md");
+  const target = path15.join(project_root, ".continue", "rules", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".continue/rules/agent-config.md already exists");
     return;
@@ -18066,7 +18192,7 @@ orientation).
 See \`docs/setup/per-ide/kilocode.md\` for the full activation guide.
 `;
 function ensure_kilocode_bridge(project_root, force) {
-  const target = path14.join(project_root, ".kilocode", "rules", "agent-config.md");
+  const target = path15.join(project_root, ".kilocode", "rules", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".kilocode/rules/agent-config.md already exists");
     return;
@@ -18093,7 +18219,7 @@ canonical source (or symlink it):
 Canonical rule and skill source: \`.augment/\` (see \`AGENTS.md\`).
 `;
 function ensure_zed_bridge(project_root, force) {
-  const target = path14.join(project_root, ".zed", "agent-config.md");
+  const target = path15.join(project_root, ".zed", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".zed/agent-config.md already exists");
     return;
@@ -18114,7 +18240,7 @@ rules into your JetBrains profile.
 Canonical rule and skill source: \`.augment/\` (see \`AGENTS.md\`).
 `;
 function ensure_jetbrains_bridge(project_root, force) {
-  const target = path14.join(project_root, ".jetbrains", "agent-config.md");
+  const target = path15.join(project_root, ".jetbrains", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".jetbrains/agent-config.md already exists");
     return;
@@ -18145,7 +18271,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 = path14.join(project_root, ".kiro", "steering", "agent-config.md");
+  const target = path15.join(project_root, ".kiro", "steering", "agent-config.md");
   if (pathExists(target) && !force) {
     skip(".kiro/steering/agent-config.md already exists");
     return;
@@ -18171,35 +18297,35 @@ var SMOKE_BRIDGE_PATHS = {
 };
 function dirHasEntries(p) {
   try {
-    return fs16.readdirSync(p).length > 0;
+    return fs17.readdirSync(p).length > 0;
   } catch {
     return false;
   }
 }
 function _resolve_tsx_invocation(scriptPath, scriptArgs) {
   const binName = process3.platform === "win32" ? "tsx.cmd" : "tsx";
-  let dir = path14.dirname(scriptPath);
+  let dir = path15.dirname(scriptPath);
   for (; ; ) {
-    const candidate = path14.join(dir, "node_modules", ".bin", binName);
+    const candidate = path15.join(dir, "node_modules", ".bin", binName);
     if (isFile(candidate)) {
       return { command: candidate, args: [scriptPath, ...scriptArgs] };
     }
-    const parent = path14.dirname(dir);
+    const parent = path15.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 = path14.join(package_root, "scripts", "hooks", "dispatch_hook.ts");
-  const manifest = path14.join(package_root, "scripts", "hook_manifest.yaml");
+  const dispatcher = path15.join(package_root, "scripts", "hooks", "dispatch_hook.ts");
+  const manifest = path15.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 ? path14.join(project_root, rel_bridge) : null;
+    const bridge_path = rel_bridge ? path15.join(project_root, rel_bridge) : null;
     const bridge_present = Boolean(
       bridge_path && (isFile(bridge_path) || isDir(bridge_path) && dirHasEntries(bridge_path))
     );
@@ -18399,9 +18525,9 @@ To remove this marker, delete this file.
 `;
 }
 var _CLAUDE_DESKTOP_BUNDLES_SUBPATH = "claude-desktop/bundles";
-var GLOBAL_ROOT = path14.join(os7.homedir(), ".event4u", "agent-config");
-var GLOBAL_USER_SETTINGS_PATH = path14.join(GLOBAL_ROOT, ".agent-user.yml");
-var GLOBAL_AGENT_SETTINGS_PATH = path14.join(GLOBAL_ROOT, ".agent-settings.yml");
+var GLOBAL_ROOT = path15.join(os7.homedir(), ".event4u", "agent-config");
+var GLOBAL_USER_SETTINGS_PATH = path15.join(GLOBAL_ROOT, ".agent-user.yml");
+var GLOBAL_AGENT_SETTINGS_PATH = path15.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] ?? "";
@@ -18446,11 +18572,11 @@ function _load_yaml_doc(p) {
   } catch {
     return {};
   }
-  const data = yamlSafeLoad(text);
+  const data = yamlSafeLoad2(text);
   return _isPlainObject2(data) ? data : {};
 }
 function _load_default_settings(package_root) {
-  const template_source = path14.join(package_root, "src", "config", "agent-settings.template.yml");
+  const template_source = path15.join(package_root, "src", "config", "agent-settings.template.yml");
   if (!pathExists(template_source)) return {};
   let text;
   try {
@@ -18459,7 +18585,7 @@ function _load_default_settings(package_root) {
     return {};
   }
   const rendered = text.split(RULE_LOADING_TIER_PLACEHOLDER).join(DEFAULT_PROFILE).split(USER_TYPE_PLACEHOLDER).join("");
-  const data = yamlSafeLoad(rendered);
+  const data = yamlSafeLoad2(rendered);
   return _isPlainObject2(data) ? data : {};
 }
 function _resolve_scope(opts, detected, detect_reason, custom_path) {
@@ -18538,9 +18664,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(path14.join(cwd, m))) ?? null;
-  const has_ai_dir = SCOPE_DETECT_AI_DIRS.find((d) => isDir(path14.join(cwd, d))) ?? null;
-  const has_ai_file = SCOPE_DETECT_AI_FILES.find((f) => pathExists(path14.join(cwd, f))) ?? null;
+  const has_manifest = SCOPE_DETECT_MANIFESTS.find((m) => pathExists(path15.join(cwd, m))) ?? null;
+  const has_ai_dir = SCOPE_DETECT_AI_DIRS.find((d) => isDir(path15.join(cwd, d))) ?? null;
+  const has_ai_file = SCOPE_DETECT_AI_FILES.find((f) => pathExists(path15.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})`];
@@ -18561,7 +18687,7 @@ function readLineSyncRaw(promptText) {
   for (; ; ) {
     let n;
     try {
-      n = fs16.readSync(0, buf, 0, 1, null);
+      n = fs17.readSync(0, buf, 0, 1, null);
     } catch (err) {
       const code = err.code;
       if (code === "EAGAIN") {
@@ -18636,8 +18762,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 (!path14.isAbsolute(marker_path)) {
-      marker_path = path14.join(project_root, marker_path);
+    if (!path15.isAbsolute(marker_path)) {
+      marker_path = path15.join(project_root, marker_path);
     }
     out[tool_id] = [_file_entry(marker_path, "bridge", false)];
   }
@@ -18676,26 +18802,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) ? path14.relative(project_root, target) : target;
+    const rel = isRelativeTo(target, project_root) ? path15.relative(project_root, target) : target;
     info(`Manifest updated: ${rel}`);
   }
   return 0;
 }
 function isRelativeTo(child, parent) {
-  const rel = path14.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel);
+  const rel = path15.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path15.isAbsolute(rel);
 }
 function _resolve_package_root_for_global() {
   const here = resolvePath(_HERE2);
-  const candidate = path14.dirname(path14.dirname(path14.dirname(here)));
-  if (!pathExists(path14.join(candidate, "src", "config", "profiles", "minimal.ini"))) {
+  const candidate = path15.dirname(path15.dirname(path15.dirname(here)));
+  if (!pathExists(path15.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 = path14.join("agents", ".event4u-bridge.yml");
+var CONSUMER_BRIDGE_MARKER_RELPATH = path15.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";
@@ -18703,7 +18829,7 @@ function _is_agent_config_source_repo(project_root) {
   if (process3.env["AGENT_CONFIG_CONSUMER_MODE"] === "1") {
     return [false, "consumer-mode-override"];
   }
-  const pkg_json = path14.join(project_root, "package.json");
+  const pkg_json = path15.join(project_root, "package.json");
   if (isFile(pkg_json)) {
     let data = {};
     try {
@@ -18715,18 +18841,18 @@ function _is_agent_config_source_repo(project_root) {
       return [true, "package.json:name"];
     }
   }
-  if (isDir(path14.join(project_root, ".agent-src.uncondensed"))) {
+  if (isDir(path15.join(project_root, ".agent-src.uncondensed"))) {
     return [true, ".agent-src.uncondensed/"];
   }
-  const packages_dir = path14.join(project_root, "packages");
+  const packages_dir = path15.join(project_root, "packages");
   if (isDir(packages_dir)) {
-    for (const child of fs16.readdirSync(packages_dir)) {
-      if (isDir(path14.join(packages_dir, child, ".agent-src.uncondensed"))) {
+    for (const child of fs17.readdirSync(packages_dir)) {
+      if (isDir(path15.join(packages_dir, child, ".agent-src.uncondensed"))) {
         return [true, `packages/${child}/.agent-src.uncondensed/`];
       }
     }
   }
-  const installer_self = path14.join(project_root, "scripts", "install.py");
+  const installer_self = path15.join(project_root, "scripts", "install.py");
   try {
     if (isFile(installer_self) && resolvePath(installer_self) === resolvePath(_HERE2)) {
       return [true, "src/scripts/install.py (self)"];
@@ -18746,17 +18872,17 @@ function _detect_legacy_for_migration(project_root) {
     }
     return [];
   }
-  if (isFile(path14.join(project_root, INSTALL_MODE_MARKER_REL))) return [];
+  if (isFile(path15.join(project_root, INSTALL_MODE_MARKER_REL))) return [];
   const found = [];
   for (const name of MIGRATE_LEGACY_YAML_FILES) {
-    if (isFile(path14.join(project_root, name))) {
+    if (isFile(path15.join(project_root, name))) {
       found.push(name);
-    } else if (isFile(path14.join(project_root, "settings", name))) {
+    } else if (isFile(path15.join(project_root, "settings", name))) {
       found.push(`settings/${name}`);
     }
   }
   for (const name of MIGRATE_LEGACY_TOOL_DIRS) {
-    const p = path14.join(project_root, name);
+    const p = path15.join(project_root, name);
     if (isDir(p) && !isSymlink(p)) {
       found.push(`${name}/`);
     }
@@ -18768,7 +18894,7 @@ function _prompt_migrate_to_global(project_root, artefacts) {
     process3.stdout.write("\n");
     warn("Legacy project-local artefacts detected \u2014 pre-ADR-020 layout:");
     for (const rel of artefacts) {
-      info(`  ${path14.join(project_root, rel)}`);
+      info(`  ${path15.join(project_root, rel)}`);
     }
     info("The unified `agent-config migrate` sweeps these in one pass.");
     info("The wizard recreates fresh config afterwards.");
@@ -18799,20 +18925,20 @@ function _run_migrate_to_global(project_root) {
 function _format_global_root_for_marker(global_root) {
   const home = resolvePath(os7.homedir());
   const resolved = resolvePath(global_root);
-  const rel = path14.relative(home, resolved);
-  if (rel === "" || rel.startsWith("..") || path14.isAbsolute(rel)) {
+  const rel = path15.relative(home, resolved);
+  if (rel === "" || rel.startsWith("..") || path15.isAbsolute(rel)) {
     return global_root;
   }
-  return `~/${rel.split(path14.sep).join("/")}`;
+  return `~/${rel.split(path15.sep).join("/")}`;
 }
 function _remove_legacy_consumer_bridge_marker(project_root, env = null) {
   const env_map = env ?? process3.env;
   if (env_map["AGENT_CONFIG_DEV_MODE"] === "1") return null;
-  if (isDir(path14.join(project_root, ".agent-src.uncondensed"))) return null;
-  const target = path14.join(project_root, CONSUMER_BRIDGE_MARKER_RELPATH);
+  if (isDir(path15.join(project_root, ".agent-src.uncondensed"))) return null;
+  const target = path15.join(project_root, CONSUMER_BRIDGE_MARKER_RELPATH);
   if (!isFile(target)) return null;
   try {
-    fs16.rmSync(target);
+    fs17.rmSync(target);
   } catch {
     return null;
   }
@@ -18826,7 +18952,7 @@ var PROJECT_ANCHOR_TOOLS = {
 function _write_per_tool_project_anchors(project_root, tools, env = null, now = null) {
   const env_map = env ?? process3.env;
   if (env_map["AGENT_CONFIG_DEV_MODE"] === "1") return [];
-  if (isDir(path14.join(project_root, ".agent-src.uncondensed"))) return [];
+  if (isDir(path15.join(project_root, ".agent-src.uncondensed"))) return [];
   const global_root_str = _format_global_root_for_marker(
     event4u_root(env_map)
   );
@@ -18835,8 +18961,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 = path14.join(project_root, rel_path);
-    mkdirp(path14.dirname(target));
+    const target = path15.join(project_root, rel_path);
+    mkdirp(path15.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
@@ -18854,7 +18980,7 @@ installed_at: ${stamp}
 }
 var PACKAGE_TAG_ID = "event4u/agent-config";
 function _inject_package_tag(target, source, package_root) {
-  if (path14.extname(target) !== ".md") return;
+  if (path15.extname(target) !== ".md") return;
   let text;
   try {
     text = readText(target);
@@ -18882,8 +19008,8 @@ function _inject_package_tag(target, source, package_root) {
       resolved_src = source;
     }
     if (package_root !== null) {
-      const rel = path14.relative(resolvePath(package_root), resolved_src);
-      if (rel !== "" && !rel.startsWith("..") && !path14.isAbsolute(rel)) {
+      const rel = path15.relative(resolvePath(package_root), resolved_src);
+      if (rel !== "" && !rel.startsWith("..") && !path15.isAbsolute(rel)) {
         source_value = rel;
       } else {
         source_value = resolved_src;
@@ -18918,7 +19044,7 @@ function _escapes_package_root(resolved, package_root) {
   if (package_root === null) return false;
   let root;
   try {
-    root = fs16.realpathSync(package_root);
+    root = fs17.realpathSync(package_root);
   } catch {
     return false;
   }
@@ -18933,7 +19059,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 = fs16.realpathSync(src);
+      resolved_src = fs17.realpathSync(src);
     } catch {
       resolved_src = src;
     }
@@ -18941,10 +19067,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(path14.dirname(dest));
+    mkdirp(path15.dirname(dest));
     const decision = _resolve_file_conflict(dest, force);
     if (decision === "skip") return [0, 1, written_paths];
-    fs16.copyFileSync(src, dest);
+    fs17.copyFileSync(src, dest);
     _inject_package_tag(dest, src, package_root);
     written_paths.push(dest);
     return [1, 0, written_paths];
@@ -18952,11 +19078,11 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
   mkdirp(dest);
   const walk = (node) => {
     const acc = [];
-    const names = fs16.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const names = fs17.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const name of names) {
-      const entry = path14.join(node, name);
+      const entry = path15.join(node, name);
       acc.push(entry);
-      const lst = fs16.lstatSync(entry);
+      const lst = fs17.lstatSync(entry);
       if (lst.isDirectory() && !lst.isSymbolicLink()) {
         acc.push(...walk(entry));
       }
@@ -18964,9 +19090,9 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
     return acc;
   };
   for (const entry of walk(src)) {
-    const rel = path14.relative(src, entry);
-    const target = path14.join(dest, rel);
-    const lst = fs16.lstatSync(entry);
+    const rel = path15.relative(src, entry);
+    const target = path15.join(dest, rel);
+    const lst = fs17.lstatSync(entry);
     if (lst.isDirectory() && !lst.isSymbolicLink()) {
       mkdirp(target);
       continue;
@@ -18974,8 +19100,8 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
     let resolvedIsDir = false;
     let resolved = entry;
     try {
-      resolved = fs16.realpathSync(entry);
-      resolvedIsDir = fs16.statSync(entry).isDirectory();
+      resolved = fs17.realpathSync(entry);
+      resolvedIsDir = fs17.statSync(entry).isDirectory();
     } catch {
       resolvedIsDir = false;
     }
@@ -19005,8 +19131,8 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
       skipped += 1;
       continue;
     }
-    mkdirp(path14.dirname(target));
-    fs16.copyFileSync(resolved, target);
+    mkdirp(path15.dirname(target));
+    fs17.copyFileSync(resolved, target);
     _inject_package_tag(target, resolved, package_root);
     written += 1;
     written_paths.push(target);
@@ -19018,7 +19144,7 @@ function _claude_desktop_bundles_dir() {
 }
 function _write_claude_desktop_marker(_force, lockfile_path2, bundles_dir, bundle_count) {
   const anchor = expanduser6(USER_SCOPE_PATHS["claude-desktop"]);
-  const target = path14.join(anchor, "agent-config.md");
+  const target = path15.join(anchor, "agent-config.md");
   mkdirp(anchor);
   const body = claudeDesktopMarkerBody(lockfile_path2, anchor, bundles_dir, bundle_count);
   writeText(target, body);
@@ -19042,23 +19168,23 @@ function _apply_claude_flat_command_wrappers(anchor, package_root, current_files
   const wrapped = [];
   const collisions = [];
   const reserved = [];
-  const commands_dir = path14.join(anchor, "commands");
+  const commands_dir = path15.join(anchor, "commands");
   let flat_entries = [];
   try {
-    flat_entries = fs16.readdirSync(commands_dir).filter((f) => f.endsWith(".md"));
+    flat_entries = fs17.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;
-    fs16.rmSync(path14.join(commands_dir, fname), { force: true });
+    fs17.rmSync(path15.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(
-      fs16.readFileSync(path14.join(package_root, "dist", "discovery", "discovery-manifest.json"), "utf8")
+      fs17.readFileSync(path15.join(package_root, "dist", "discovery", "discovery-manifest.json"), "utf8")
     );
     for (const a of manifest.artefacts ?? []) {
       if (a.category !== "command" || typeof a.slug !== "string") continue;
@@ -19069,22 +19195,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 = path14.join(anchor, "commands", `${slug}.md`);
-    if (!fs16.existsSync(flat_abs)) continue;
-    const skill_dir = path14.join(anchor, "skills", slug);
-    if (fs16.existsSync(skill_dir)) {
+    const flat_abs = path15.join(anchor, "commands", `${slug}.md`);
+    if (!fs17.existsSync(flat_abs)) continue;
+    const skill_dir = path15.join(anchor, "skills", slug);
+    if (fs17.existsSync(skill_dir)) {
       collisions.push(slug);
       continue;
     }
-    let body = fs16.readFileSync(flat_abs, "utf8");
+    let body = fs17.readFileSync(flat_abs, "utf8");
     if (body.startsWith("---\n") && !/^name:/m.test(body.split("\n---")[0] ?? "")) {
       body = body.replace("---\n", `---
 name: ${slug}
 `);
     }
-    fs16.mkdirSync(skill_dir, { recursive: true });
-    fs16.writeFileSync(path14.join(skill_dir, "SKILL.md"), body, "utf8");
-    fs16.rmSync(flat_abs, { force: true });
+    fs17.mkdirSync(skill_dir, { recursive: true });
+    fs17.writeFileSync(path15.join(skill_dir, "SKILL.md"), body, "utf8");
+    fs17.rmSync(flat_abs, { force: true });
     current_files.delete(flat_rel);
     current_files.add(`skills/${slug}/SKILL.md`);
     wrapped.push(slug);
@@ -19116,8 +19242,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 = path14.join(package_root, src_rel);
-      const dest = dest_sub ? path14.join(anchor, dest_sub) : anchor;
+      const src = path15.join(package_root, src_rel);
+      const dest = dest_sub ? path15.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,
@@ -19191,10 +19317,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 = path14.join(package_root, "src", "scripts", "hook_manifest.yaml");
+        const manifest = path15.join(package_root, "src", "scripts", "hook_manifest.yaml");
         const matrix = build_claude_hook_matrix(manifest);
         const res = ensure_managed_hooks(
-          path14.join(anchor, "settings.json"),
+          path15.join(anchor, "settings.json"),
           matrix
         );
         if (!state.QUIET) {
@@ -19231,7 +19357,7 @@ function _preview_global_reap(tools, package_root) {
     const anchor = expanduser6(anchor_raw);
     let current_files = /* @__PURE__ */ new Set();
     for (const [src_rel, dest_sub] of plan) {
-      const src = path14.join(package_root, src_rel);
+      const src = path15.join(package_root, src_rel);
       current_files = setUnion(
         current_files,
         expected_deploy_files(
@@ -19265,14 +19391,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 ? path14.join(anchor, dest_sub) : anchor;
+    const target = dest_sub ? path15.join(anchor, dest_sub) : anchor;
     const label = dest_sub || ".";
     if (!isDir(target)) {
       missing.push(label);
       continue;
     }
     try {
-      const entries = fs16.readdirSync(target);
+      const entries = fs17.readdirSync(target);
       if (entries.length === 0) missing.push(label);
     } catch {
       missing.push(label);
@@ -19287,13 +19413,13 @@ function _prune_modules_by(deploy_results, is_pruned) {
     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(path14.sep);
+      const parts = p.split(path15.sep);
       if (parts.includes("skills")) {
         const i = parts.indexOf("skills");
         if (i + 1 < parts.length) {
-          const skill_root = parts.slice(0, i + 2).join(path14.sep);
+          const skill_root = parts.slice(0, i + 2).join(path15.sep);
           if (!pruned_skill_dirs.has(skill_root)) {
-            const skillmd = path14.join(skill_root, "SKILL.md");
+            const skillmd = path15.join(skill_root, "SKILL.md");
             if (pathExists(skillmd) && is_pruned(skillmd)) {
               pruned_skill_dirs.add(skill_root);
             }
@@ -19304,25 +19430,25 @@ function _prune_modules_by(deploy_results, is_pruned) {
     const keep = [];
     const delete_files = [];
     for (const p of paths) {
-      const parts = p.split(path14.sep);
+      const parts = p.split(path15.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(path14.sep))) {
+        if (i + 1 < parts.length && pruned_skill_dirs.has(parts.slice(0, i + 2).join(path15.sep))) {
           is_target = true;
         }
-      } else if (parts.includes("commands") && path14.extname(p) === ".md" && is_pruned(p)) {
+      } else if (parts.includes("commands") && path15.extname(p) === ".md" && is_pruned(p)) {
         is_target = true;
       }
       (is_target ? delete_files : keep).push(p);
     }
     for (const d of pruned_skill_dirs) {
-      fs16.rmSync(d, { recursive: true, force: true });
+      fs17.rmSync(d, { recursive: true, force: true });
     }
     for (const p of delete_files) {
-      if (p.split(path14.sep).includes("commands") && pathExists(p)) {
+      if (p.split(path15.sep).includes("commands") && pathExists(p)) {
         try {
-          fs16.unlinkSync(p);
+          fs17.unlinkSync(p);
         } catch {
         }
       }
@@ -19335,64 +19461,17 @@ function _prune_modules_by(deploy_results, is_pruned) {
 function _prune_lab_modules(deploy_results, lab_ids) {
   return _prune_modules_by(deploy_results, (p) => is_lab_artefact(p, lab_ids));
 }
-var SCOPED_ACTIVE_WORKSPACES = /* @__PURE__ */ new Set(["engineering", "agent-config-maintainer"]);
-function _load_packs_registry(package_root) {
-  const vocab_path = path14.join(package_root, "src", "config", "discovery", "packs.yml");
-  const data = yamlSafeLoad(readText(vocab_path));
-  if (!Array.isArray(data)) {
-    throw new Error(`packs.yml did not parse to a list: ${vocab_path}`);
-  }
-  const out = [];
-  for (const entry of data) {
-    if (!_isPlainObject2(entry)) continue;
-    const id = entry["id"];
-    if (typeof id !== "string" || id === "") continue;
-    const workspaces_raw = entry["workspaces"];
-    const workspaces = Array.isArray(workspaces_raw) ? workspaces_raw.filter((w) => typeof w === "string") : [];
-    const requires_raw = entry["requires"] ?? entry["requires_hint"];
-    const requires = Array.isArray(requires_raw) ? requires_raw.filter((r) => typeof r === "string") : [];
-    out.push({ id, workspaces, requires });
-  }
-  return out;
-}
-function _compute_active_pack_ids(packs, runtime_active_packs) {
-  const by_id = /* @__PURE__ */ new Map();
-  for (const p of packs) by_id.set(p.id, p);
-  const active = /* @__PURE__ */ new Set();
-  for (const p of packs) {
-    if (p.workspaces.some((w) => SCOPED_ACTIVE_WORKSPACES.has(w))) {
-      active.add(p.id);
-    }
-  }
-  for (const id of runtime_active_packs) {
-    active.add(id);
-  }
-  let frontier = [...active];
-  while (frontier.length > 0) {
-    const next = [];
-    for (const id of frontier) {
-      const rec = by_id.get(id);
-      if (rec === void 0) continue;
-      for (const dep of rec.requires) {
-        if (!active.has(dep)) {
-          active.add(dep);
-          next.push(dep);
-        }
-      }
-    }
-    frontier = next;
-  }
-  return active;
-}
+var _load_packs_registry = load_packs_registry;
+var _compute_active_pack_ids = compute_active_pack_ids;
 function _resolve_global_settings_doc() {
   const p = _resolve_global_settings_path();
   return p === null ? null : _load_yaml_doc(p);
 }
 function _resolve_global_settings_path() {
   const root = event4u_root();
-  const canonical = path14.join(root, "settings", SETTINGS_FILE);
+  const canonical = path15.join(root, "settings", SETTINGS_FILE);
   if (pathExists(canonical)) return canonical;
-  const legacy = path14.join(root, SETTINGS_FILE);
+  const legacy = path15.join(root, SETTINGS_FILE);
   if (pathExists(legacy)) return legacy;
   return null;
 }
@@ -19409,7 +19488,7 @@ function _resolve_global_rule_scope(package_root) {
   const settings_path = _resolve_global_settings_path();
   if (settings_path === null) {
     try {
-      return ruleScopeFromSettings(_load_default_settings(package_root));
+      return ruleScopeFromSettings(_load_default_settings(package_root), package_root);
     } catch {
       return LEGACY_ALL;
     }
@@ -19423,7 +19502,7 @@ function _resolve_global_rule_scope(package_root) {
     );
     return LEGACY_ALL;
   }
-  const parsed = yamlSafeLoad(text);
+  const parsed = yamlSafeLoad2(text);
   if (!_isPlainObject2(parsed)) {
     warn(
       `${settings_path} is not a YAML mapping \u2014 rule scoping falls back to legacy-all, so ALL rules including maintainer-only ones will be installed. Fix the file to restore scoping.`
@@ -19431,7 +19510,7 @@ function _resolve_global_rule_scope(package_root) {
     return LEGACY_ALL;
   }
   try {
-    return ruleScopeFromSettings(parsed);
+    return ruleScopeFromSettings(parsed, package_root);
   } catch (e) {
     warn(
       `could not derive rule scope from ${settings_path} (${String(e)}) \u2014 falling back to legacy-all; ALL rules will be installed.`
@@ -19444,14 +19523,10 @@ function _rule_filter_for_source(src_rel, scope) {
   return (srcFile) => ruleFileArrives(srcFile, scope);
 }
 function _prune_scoped_modules(deploy_results, active_ids) {
-  return _prune_modules_by(deploy_results, (p) => {
-    const packs = frontmatter_packs(p);
-    if (packs.size === 0) return false;
-    for (const id of packs) {
-      if (active_ids.has(id)) return false;
-    }
-    return true;
-  });
+  return _prune_modules_by(
+    deploy_results,
+    (p) => is_pruned_under_scoped(p, active_ids)
+  );
 }
 function install_global(tools, force, project_root = null, core_only = false) {
   const migrated = migrate_legacy_namespace();
@@ -19507,7 +19582,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(path14.join(project_root, ".agent-src.uncondensed"))) {
+  if (project_root !== null && pathExists(_resolve_settings_read(project_root)) && !isDir(path15.join(project_root, ".agent-src.uncondensed"))) {
     const drift = collect_drift(project_root);
     if (!state.QUIET) {
       process3.stdout.write("\n");
@@ -19607,19 +19682,19 @@ function install_global(tools, force, project_root = null, core_only = false) {
       }
     }
   }
-  if (project_root !== null && pathExists(_resolve_settings_read(project_root)) && !isDir(path14.join(project_root, ".agent-src.uncondensed"))) {
+  if (project_root !== null && pathExists(_resolve_settings_read(project_root)) && !isDir(path15.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) ? path14.relative(project_root, removed_marker) : removed_marker;
+      const rel = isRelativeTo(removed_marker, project_root) ? path15.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) ? path14.relative(project_root, p) : p;
+        const rel = isRelativeTo(p, project_root) ? path15.relative(project_root, p) : p;
         info(`Project anchor written: ${rel}`);
       }
     }
@@ -19636,8 +19711,8 @@ function install_global(tools, force, project_root = null, core_only = false) {
   }
   return 0;
 }
-var SETTINGS_SURFACE_REL = path14.join("state", "settings-surface.json");
-var SETTINGS_DELTA_REL = path14.join("state", "settings-delta.json");
+var SETTINGS_SURFACE_REL = path15.join("state", "settings-surface.json");
+var SETTINGS_DELTA_REL = path15.join("state", "settings-delta.json");
 function _current_settings_surface(version) {
   const jsonSchema = zodToJsonSchema(settingsSchema, {
     name: "AgentSettings",
@@ -19648,20 +19723,20 @@ function _current_settings_surface(version) {
 }
 function _write_settings_surface_snapshot(installed_version) {
   const root = event4u_root();
-  const surface_path = path14.join(root, SETTINGS_SURFACE_REL);
-  const delta_path = path14.join(root, SETTINGS_DELTA_REL);
+  const surface_path = path15.join(root, SETTINGS_SURFACE_REL);
+  const delta_path = path15.join(root, SETTINGS_DELTA_REL);
   const next = _current_settings_surface(installed_version);
   let previous = null;
   try {
-    const parsed = JSON.parse(fs16.readFileSync(surface_path, "utf8"));
+    const parsed = JSON.parse(fs17.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) {
-      fs16.mkdirSync(path14.dirname(delta_path), { recursive: true, mode: 448 });
-      fs16.writeFileSync(delta_path, `${JSON.stringify(delta, null, 2)}
+      fs17.mkdirSync(path15.dirname(delta_path), { recursive: true, mode: 448 });
+      fs17.writeFileSync(delta_path, `${JSON.stringify(delta, null, 2)}
 `, { mode: 384 });
       if (!state.QUIET) {
         const counts = {};
@@ -19673,8 +19748,8 @@ function _write_settings_surface_snapshot(installed_version) {
       }
     }
   }
-  fs16.mkdirSync(path14.dirname(surface_path), { recursive: true, mode: 448 });
-  fs16.writeFileSync(surface_path, `${JSON.stringify(next, null, 2)}
+  fs17.mkdirSync(path15.dirname(surface_path), { recursive: true, mode: 448 });
+  fs17.writeFileSync(surface_path, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 });
 }
 function arrayStrEqual(a, b) {
@@ -19886,13 +19961,13 @@ function _minimal_templates_root() {
   const chain = [start];
   let cur = start;
   for (; ; ) {
-    const parent = path14.dirname(cur);
+    const parent = path15.dirname(cur);
     if (parent === cur) break;
     chain.push(parent);
     cur = parent;
   }
   for (const ancestor of chain) {
-    const candidate = path14.join(ancestor, "src", "templates", "minimal");
+    const candidate = path15.join(ancestor, "src", "templates", "minimal");
     if (isDir(candidate)) return candidate;
   }
   fail("Could not locate src/templates/minimal/ \u2014 package install is corrupt.");
@@ -19900,9 +19975,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 = path14.join(project_root, INSTALL_MODE_MARKER_REL);
+  const marker = path15.join(project_root, INSTALL_MODE_MARKER_REL);
   try {
-    mkdirp(path14.dirname(marker));
+    mkdirp(path15.dirname(marker));
     writeText(marker, `${mode}
 `);
   } catch {
@@ -19911,7 +19986,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 = path14.dirname(target_root);
+  const parent = path15.dirname(target_root);
   if (parent !== target_root) {
     const existing = find_project_root_with_anchor(parent);
     if (existing !== null && existing[0] !== target_root) {
@@ -19922,21 +19997,21 @@ function install_minimal(target_root_in, force, user_type = "") {
     }
   }
   const templates = _minimal_templates_root();
-  const settings_src = path14.join(templates, SETTINGS_FILE);
-  const overrides_gitkeep_src = path14.join(templates, "overrides-gitkeep");
-  const overrides_readme_src = path14.join(templates, "agents-overrides-readme.md");
+  const settings_src = path15.join(templates, SETTINGS_FILE);
+  const overrides_gitkeep_src = path15.join(templates, "overrides-gitkeep");
+  const overrides_readme_src = path15.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 = path14.join(target_root, "agents", "overrides");
+  const overrides_root = path15.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 = path14.join(overrides_root, sub);
+    const sub_dir = path15.join(overrides_root, sub);
     mkdirp(sub_dir);
-    const gitkeep_dst = path14.join(sub_dir, ".gitkeep");
+    const gitkeep_dst = path15.join(sub_dir, ".gitkeep");
     if (pathExists(gitkeep_dst) && !force) {
       skip(`agents/overrides/${sub}/.gitkeep already exists (use --force to overwrite)`);
     } else {
@@ -19944,7 +20019,7 @@ function install_minimal(target_root_in, force, user_type = "") {
       success(`Wrote agents/overrides/${sub}/.gitkeep`);
     }
   }
-  const readme_dst = path14.join(overrides_root, "README.md");
+  const readme_dst = path15.join(overrides_root, "README.md");
   if (pathExists(readme_dst) && !force) {
     skip("agents/overrides/README.md already exists (use --force to overwrite)");
   } else {
@@ -19962,14 +20037,14 @@ function install_minimal(target_root_in, force, user_type = "") {
 personal:
   user_type: ${user_type}
 `;
-      mkdirp(path14.dirname(settings_dst));
+      mkdirp(path15.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) ? path14.relative(target_root, removed_marker) : removed_marker;
+    const rel = isRelativeTo(removed_marker, target_root) ? path15.relative(target_root, removed_marker) : removed_marker;
     success(`Removed legacy bridge marker: ${rel}`);
   }
   _write_install_mode_marker(target_root, "minimal");
@@ -20043,7 +20118,7 @@ function run_interactive_init(project_root, force) {
     );
     return 0;
   }
-  const target = path14.join(project_root, _LOCAL_CONFIG_FILE);
+  const target = path15.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.`
@@ -20070,7 +20145,7 @@ function run_interactive_init(project_root, force) {
     warn(`Could not write ${target}: ${String(exc)}`);
     return 1;
   }
-  success(`Wrote ${path14.relative(project_root, target)} (${user_type} / ${stack} / ${verbosity})`);
+  success(`Wrote ${path15.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?$/;
@@ -20088,12 +20163,12 @@ function _wizard_should_launch(opts) {
   return [true, ""];
 }
 function _wizard_cli_dist(_project_root) {
-  const package_root = path14.dirname(path14.dirname(path14.dirname(resolvePath(_HERE2))));
-  const cli = path14.join(package_root, "dist", "cli", "agent-config.js");
+  const package_root = path15.dirname(path15.dirname(path15.dirname(resolvePath(_HERE2))));
+  const cli = path15.join(package_root, "dist", "cli", "agent-config.js");
   return pathExists(cli) ? cli : null;
 }
 function _server_info_path() {
-  return path14.join(os7.homedir(), ".event4u", "agent-config", "local-server.json");
+  return path15.join(os7.homedir(), ".event4u", "agent-config", "local-server.json");
 }
 function _pid_is_agent_config(pid) {
   let res;
@@ -20110,7 +20185,7 @@ function _pid_is_agent_config(pid) {
 }
 function unlinkMissingOk(p) {
   try {
-    fs16.unlinkSync(p);
+    fs17.unlinkSync(p);
   } catch {
   }
 }
@@ -20188,14 +20263,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 = path14.join(
+  const log_path = path15.join(
     os7.tmpdir(),
     `agent-config-wizard-${process3.pid}-${Date.now()}.log`
   );
   let child;
   let log_fd = null;
   try {
-    log_fd = fs16.openSync(log_path, "w");
+    log_fd = fs17.openSync(log_path, "w");
     child = spawn(cmd[0], cmd.slice(1), {
       env,
       detached: true,
@@ -20213,7 +20288,7 @@ function _wizard_run_sync(cmd, env, cli) {
   } finally {
     if (log_fd !== null) {
       try {
-        fs16.closeSync(log_fd);
+        fs17.closeSync(log_fd);
       } catch {
       }
     }
@@ -20463,8 +20538,8 @@ function main2(argv) {
     const target_root = resolvePath(
       opts.custom_path || opts.project || process3.env["PROJECT_ROOT"] || process3.cwd()
     );
-    const minimal_package_root = path14.dirname(
-      path14.dirname(path14.dirname(_minimal_templates_root()))
+    const minimal_package_root = path15.dirname(
+      path15.dirname(path15.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);
@@ -20493,7 +20568,7 @@ function main2(argv) {
     return rc2;
   }
   const project_root = custom_path || resolvePath(opts.project || process3.env["PROJECT_ROOT"] || process3.cwd());
-  const is_first_run = !pathExists(path14.join(project_root, SETTINGS_FILE));
+  const is_first_run = !pathExists(path15.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);
@@ -20557,16 +20632,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 = path14.join(project_root, ".claude", "skills");
-  const augment_skills = path14.join(project_root, ".augment", "skills");
+  const claude_skills = path15.join(project_root, ".claude", "skills");
+  const augment_skills = path15.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 = fs16.readdirSync(claude_skills).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const entries = fs17.readdirSync(claude_skills).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
   for (const name of entries) {
-    const entry = path14.join(claude_skills, name);
-    const src_dir = path14.join(augment_skills, name);
-    const src_md = path14.join(src_dir, "SKILL.md");
+    const entry = path15.join(claude_skills, name);
+    const src_dir = path15.join(augment_skills, name);
+    const src_md = path15.join(src_dir, "SKILL.md");
     let tier;
     try {
       tier = read_model_tier(src_md);
@@ -20575,22 +20650,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)) {
-      fs16.unlinkSync(entry);
+      fs17.unlinkSync(entry);
     } else if (isDir(entry)) {
-      fs16.rmSync(entry, { recursive: true, force: true });
+      fs17.rmSync(entry, { recursive: true, force: true });
     }
     mkdirp(entry);
-    const srcFiles = fs16.readdirSync(src_dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const srcFiles = fs17.readdirSync(src_dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const fname of srcFiles) {
       if (fname === "SKILL.md") {
         writeText(
-          path14.join(entry, "SKILL.md"),
+          path15.join(entry, "SKILL.md"),
           render_native_model_md(readText(src_md), tier)
         );
       } else {
-        fs16.symlinkSync(
-          path14.join("../../../.augment/skills", name, fname),
-          path14.join(entry, fname)
+        fs17.symlinkSync(
+          path15.join("../../../.augment/skills", name, fname),
+          path15.join(entry, fname)
         );
       }
     }
@@ -20608,7 +20683,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(path14.join(package_root, "src", "config", "profiles", "minimal.ini"))) {
+    if (!pathExists(path15.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);
@@ -20743,9 +20818,9 @@ function _main_project_install(opts, project_root, parsed_tools, is_first_run) {
 function _resolvedArgv1() {
   if (process3.argv[1] === void 0) return void 0;
   try {
-    return fs16.realpathSync(path14.resolve(process3.argv[1]));
+    return fs17.realpathSync(path15.resolve(process3.argv[1]));
   } catch {
-    return path14.resolve(process3.argv[1]);
+    return path15.resolve(process3.argv[1]);
   }
 }
 var _argv1 = _resolvedArgv1();