@event4u/agent-config 12.1.0 → 13.0.0

package/dist/hooks/dispatch.js

@@ -112,17 +112,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path74) {
-      const ctrl = callVisitor(key, node, visitor, path74);
+    function visit_(key, node, visitor, path77) {
+      const ctrl = callVisitor(key, node, visitor, path77);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path74, ctrl);
-        return visit_(key, ctrl, visitor, path74);
+        replaceNode(key, path77, ctrl);
+        return visit_(key, ctrl, visitor, path77);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path74 = Object.freeze(path74.concat(node));
+          path77 = Object.freeze(path77.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path74);
+            const ci = visit_(i, node.items[i], visitor, path77);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -133,13 +133,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path74 = Object.freeze(path74.concat(node));
-          const ck = visit_("key", node.key, visitor, path74);
+          path77 = Object.freeze(path77.concat(node));
+          const ck = visit_("key", node.key, visitor, path77);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path74);
+          const cv = visit_("value", node.value, visitor, path77);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -160,17 +160,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path74) {
-      const ctrl = await callVisitor(key, node, visitor, path74);
+    async function visitAsync_(key, node, visitor, path77) {
+      const ctrl = await callVisitor(key, node, visitor, path77);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path74, ctrl);
-        return visitAsync_(key, ctrl, visitor, path74);
+        replaceNode(key, path77, ctrl);
+        return visitAsync_(key, ctrl, visitor, path77);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path74 = Object.freeze(path74.concat(node));
+          path77 = Object.freeze(path77.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path74);
+            const ci = await visitAsync_(i, node.items[i], visitor, path77);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -181,13 +181,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path74 = Object.freeze(path74.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path74);
+          path77 = Object.freeze(path77.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path77);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path74);
+          const cv = await visitAsync_("value", node.value, visitor, path77);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -214,23 +214,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path74) {
+    function callVisitor(key, node, visitor, path77) {
       if (typeof visitor === "function")
-        return visitor(key, node, path74);
+        return visitor(key, node, path77);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path74);
+        return visitor.Map?.(key, node, path77);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path74);
+        return visitor.Seq?.(key, node, path77);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path74);
+        return visitor.Pair?.(key, node, path77);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path74);
+        return visitor.Scalar?.(key, node, path77);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path74);
+        return visitor.Alias?.(key, node, path77);
       return void 0;
     }
-    function replaceNode(key, path74, node) {
-      const parent = path74[path74.length - 1];
+    function replaceNode(key, path77, node) {
+      const parent = path77[path77.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -840,10 +840,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path74, value) {
+    function collectionFromPath(schema, path77, value) {
       let v = value;
-      for (let i = path74.length - 1; i >= 0; --i) {
-        const k = path74[i];
+      for (let i = path77.length - 1; i >= 0; --i) {
+        const k = path77[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -862,7 +862,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path74) => path74 == null || typeof path74 === "object" && !!path74[Symbol.iterator]().next().done;
+    var isEmptyPath = (path77) => path77 == null || typeof path77 === "object" && !!path77[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -892,11 +892,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(path74, value) {
-        if (isEmptyPath(path74))
+      addIn(path77, value) {
+        if (isEmptyPath(path77))
           this.add(value);
         else {
-          const [key, ...rest] = path74;
+          const [key, ...rest] = path77;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -910,8 +910,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path74) {
-        const [key, ...rest] = path74;
+      deleteIn(path77) {
+        const [key, ...rest] = path77;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -925,8 +925,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path74, keepScalar) {
-        const [key, ...rest] = path74;
+      getIn(path77, keepScalar) {
+        const [key, ...rest] = path77;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -944,8 +944,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path74) {
-        const [key, ...rest] = path74;
+      hasIn(path77) {
+        const [key, ...rest] = path77;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -955,8 +955,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(path74, value) {
-        const [key, ...rest] = path74;
+      setIn(path77, value) {
+        const [key, ...rest] = path77;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3471,9 +3471,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path74, value) {
+      addIn(path77, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path74, value);
+          this.contents.addIn(path77, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3548,14 +3548,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path74) {
-        if (Collection.isEmptyPath(path74)) {
+      deleteIn(path77) {
+        if (Collection.isEmptyPath(path77)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path74) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path77) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3570,10 +3570,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path74, keepScalar) {
-        if (Collection.isEmptyPath(path74))
+      getIn(path77, keepScalar) {
+        if (Collection.isEmptyPath(path77))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path74, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path77, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3584,10 +3584,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path74) {
-        if (Collection.isEmptyPath(path74))
+      hasIn(path77) {
+        if (Collection.isEmptyPath(path77))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path74) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path77) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3604,13 +3604,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(path74, value) {
-        if (Collection.isEmptyPath(path74)) {
+      setIn(path77, value) {
+        if (Collection.isEmptyPath(path77)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path74), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path77), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path74, value);
+          this.contents.setIn(path77, value);
         }
       }
       /**
@@ -5570,9 +5570,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path74) => {
+    visit.itemAtPath = (cst, path77) => {
       let item = cst;
-      for (const [field, index] of path74) {
+      for (const [field, index] of path77) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5581,23 +5581,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path74) => {
-      const parent = visit.itemAtPath(cst, path74.slice(0, -1));
-      const field = path74[path74.length - 1][0];
+    visit.parentCollection = (cst, path77) => {
+      const parent = visit.itemAtPath(cst, path77.slice(0, -1));
+      const field = path77[path77.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path74, item, visitor) {
-      let ctrl = visitor(item, path74);
+    function _visit(path77, item, visitor) {
+      let ctrl = visitor(item, path77);
       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(path74.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path77.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5608,10 +5608,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path74);
+            ctrl = ctrl(item, path77);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path74) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path77) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6913,14 +6913,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs71 = this.flowScalar(this.type);
+              const fs74 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs71, sep: [] });
+                map.items.push({ start, key: fs74, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs71);
+                this.stack.push(fs74);
               } else {
-                Object.assign(it, { key: fs71, sep: [] });
+                Object.assign(it, { key: fs74, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7048,13 +7048,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs71 = this.flowScalar(this.type);
+              const fs74 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs71, sep: [] });
+                fc.items.push({ start: [], key: fs74, sep: [] });
               else if (it.sep)
-                this.stack.push(fs71);
+                this.stack.push(fs74);
               else
-                Object.assign(it, { key: fs71, sep: [] });
+                Object.assign(it, { key: fs74, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7363,15 +7363,15 @@ var require_dist = __commonJS({
 });
 
 // src/scripts/hooks/dispatch_entry.ts
-import * as path73 from "node:path";
-import { fileURLToPath as fileURLToPath52 } from "node:url";
+import * as path76 from "node:path";
+import { fileURLToPath as fileURLToPath54 } from "node:url";
 
 // src/scripts/hooks/dispatch_hook.ts
 var import_yaml6 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync8 } from "node:child_process";
-import fs70 from "node:fs";
-import path72 from "node:path";
-import { fileURLToPath as fileURLToPath51, pathToFileURL as pathToFileURL44 } from "node:url";
+import fs73 from "node:fs";
+import path75 from "node:path";
+import { fileURLToPath as fileURLToPath53, pathToFileURL as pathToFileURL46 } from "node:url";
 
 // src/scripts/_lib/spawn_env.ts
 var DENY_EXACT = /* @__PURE__ */ new Set([
@@ -14841,7 +14841,7 @@ var OpenAICliClient = class extends CliClient {
     if (measuredOn === void 0) return null;
     return {
       code: "model_unsupported_on_transport",
-      detail: `openai member pins model \`${this.model}\`, which the codex CLI (subscription transport) refused when measured on ${measuredOn}: "The '${this.model}' model is not supported when using Codex with a ChatGPT account." The CLI publishes no list of models it DOES accept, so there is no supported set to offer here \u2014 the one configuration measured to work is no pin at all. Fix: remove the \`model:\` line from the openai member (or set it to \`codex-default\`) to use the CLI's own default. A pinned model is only reachable on the API transport (\`api_key_ref:\` without \`mode: cli\`).`
+      detail: `openai member pins model \`${this.model}\`, which the codex CLI (subscription transport) refused when measured on ${measuredOn}: "The '${this.model}' model is not supported when using Codex with a ChatGPT account." The CLI publishes no list of models it DOES accept, so there is no supported set to offer here \u2014 the one configuration measured to work is no pin at all. Fix: set \`model: codex-default\` on the openai member. Do NOT delete the \`model:\` line \u2014 an enabled member with no model fails config load, so that takes EVERY provider to NOT CONFIGURED. A pin is reachable only on the API transport.`
     };
   }
   /**
@@ -14956,7 +14956,7 @@ var OpenAICliClient = class extends CliClient {
           // needs and neither of which the error code carries.
           detail: failure.slice(0, 400),
           ...unsupported ? {
-            hint: "the codex subscription transport serves no explicitly pinned model measured so far \u2014 remove the `model:` line from the openai member to use the CLI default"
+            hint: "the codex subscription transport serves no explicitly pinned model measured so far \u2014 set `model: codex-default` on the openai member; deleting the line fails config load"
           } : {}
         }
       });
@@ -23772,15 +23772,15 @@ function targets_kernel_rule(filePath) {
   if (segments.length === 0) {
     return null;
   }
-  const basename7 = segments[segments.length - 1];
-  if (!is_kernel_rule(basename7)) {
+  const basename8 = segments[segments.length - 1];
+  if (!is_kernel_rule(basename8)) {
     return null;
   }
   const dirSegments = segments.slice(0, -1);
   if (!dirSegments.includes("rules")) {
     return null;
   }
-  return basename7.replace(/\.md$/, "");
+  return basename8.replace(/\.md$/, "");
 }
 var _MUTATOR_VERBS = /* @__PURE__ */ new Set([
   "sed",
@@ -26830,13 +26830,602 @@ if (_isCliEntry30()) {
   process.exit(main40());
 }
 
+// src/scripts/hooks/skill_route_hook.ts
+import fs63 from "node:fs";
+import path64 from "node:path";
+import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL37 } from "node:url";
+
+// src/scripts/_lib/skill_catalogue.ts
+import * as fs61 from "node:fs";
+import * as path62 from "node:path";
+var DEFAULT_CATALOGUE_ROOTS = [".claude/skills", "src/skills"];
+function resolveSkillsRoot(workspaceRoot2) {
+  for (const candidate of DEFAULT_CATALOGUE_ROOTS) {
+    const abs = path62.join(workspaceRoot2, candidate);
+    try {
+      if (fs61.existsSync(abs) && fs61.statSync(abs).isDirectory()) return abs;
+    } catch {
+    }
+  }
+  return null;
+}
+var OBSERVATION_LOG = path62.join(
+  "agents",
+  "evidence",
+  "metrics",
+  "skill-catalogue.jsonl"
+);
+
+// src/scripts/skill_tools/score_skill_relevance.ts
+import * as fs62 from "node:fs";
+import * as path63 from "node:path";
+import { fileURLToPath as fileURLToPath43, pathToFileURL as pathToFileURL36 } from "node:url";
+
+// src/scripts/_lib/value_ladder.ts
+function pyRound(value, ndigits = 0) {
+  if (!Number.isFinite(value) || value === 0) {
+    return value;
+  }
+  const sign = value < 0 ? -1 : 1;
+  const abs = Math.abs(value);
+  let str9 = abs.toPrecision(17);
+  if (str9.includes("e") || str9.includes("E")) {
+    const factor2 = 10 ** ndigits;
+    return value > 0 ? Math.round(abs * factor2) / factor2 * sign : -Math.round(abs * factor2) / factor2;
+  }
+  let [intPart, fracPart = ""] = str9.split(".");
+  while (fracPart.length <= ndigits) {
+    fracPart += "0";
+  }
+  const keepFrac = fracPart.slice(0, ndigits);
+  const deciderStr = fracPart.slice(ndigits);
+  const scaledIntStr = intPart + keepFrac;
+  let scaledInt = BigInt(scaledIntStr === "" ? "0" : scaledIntStr);
+  const firstDecider = deciderStr.charAt(0);
+  const restNonZero = /[1-9]/u.test(deciderStr.slice(1));
+  let roundUp = false;
+  if (firstDecider > "5" || firstDecider === "5" && restNonZero) {
+    roundUp = true;
+  } else if (firstDecider === "5" && !restNonZero) {
+    roundUp = scaledInt % 2n === 1n;
+  }
+  if (roundUp) {
+    scaledInt += 1n;
+  }
+  const factor = 10 ** ndigits;
+  return Number(scaledInt) / factor * sign;
+}
+
+// src/scripts/skill_tools/score_skill_relevance.ts
+var _HERE7 = fileURLToPath43(import.meta.url);
+var ROOT2 = path63.resolve(path63.dirname(_HERE7), "..", "..", "..");
+var DEFAULT_SKILLS_DIR = path63.join(ROOT2, ".agent-src.uncondensed", "skills");
+var TOKEN_RE2 = /[a-z][a-z0-9]+/g;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "of",
+  "for",
+  "with",
+  "to",
+  "in",
+  "on",
+  "at",
+  "by",
+  "from",
+  "as",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "use",
+  "when",
+  "even",
+  "via",
+  "via:",
+  "into",
+  "onto",
+  "use:",
+  "skill",
+  "skills",
+  "task",
+  "tasks",
+  "code",
+  "file",
+  "files",
+  "doing",
+  "make",
+  "do",
+  "go",
+  "get",
+  "set",
+  "not",
+  "no",
+  "yes",
+  "any",
+  "some",
+  "all",
+  "one",
+  "two",
+  "new",
+  "old",
+  "user",
+  "users",
+  "our",
+  "your",
+  "their",
+  "they",
+  "we",
+  "you",
+  "i",
+  "me"
+]);
+function pyLen(s) {
+  let n = 0;
+  for (const _ of s) {
+    n++;
+  }
+  return n;
+}
+function _tokenize(text) {
+  const out = /* @__PURE__ */ new Set();
+  const matches = text.toLowerCase().match(TOKEN_RE2) ?? [];
+  for (const t of matches) {
+    if (!STOPWORDS.has(t) && pyLen(t) > 2) {
+      out.add(t);
+    }
+  }
+  return out;
+}
+function _parse_frontmatter(filePath) {
+  const text = fs62.readFileSync(filePath, "utf-8");
+  if (!text.startsWith("---")) {
+    return {};
+  }
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) {
+    return {};
+  }
+  const block = text.slice(3, end);
+  const out = {};
+  let currentListKey = null;
+  for (const raw of _splitlines3(block)) {
+    const line = _rstrip(raw);
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    if (currentListKey !== null && line.startsWith("  - ")) {
+      const existing = out[currentListKey];
+      const list = Array.isArray(existing) ? existing : [];
+      if (!Array.isArray(existing)) {
+        out[currentListKey] = list;
+      }
+      list.push(line.slice(4).trim());
+      continue;
+    }
+    currentListKey = null;
+    const m = /^([a-zA-Z_][\w-]*)[ \t\r\f\v]*:[ \t\r\f\v]*(.*)$/u.exec(line);
+    if (!m) {
+      continue;
+    }
+    const key = m[1];
+    let val = m[2].trim();
+    if (val === "") {
+      currentListKey = key;
+      continue;
+    }
+    if (val.startsWith('"') && val.endsWith('"')) {
+      val = val.slice(1, -1);
+    }
+    out[key] = val;
+  }
+  return out;
+}
+function _splitlines3(s) {
+  if (s === "") {
+    return [];
+  }
+  return s.split(/\r\n|\r|\n/u);
+}
+function _rstrip(s) {
+  return s.replace(/\s+$/u, "");
+}
+function _load_skills(skillsDir) {
+  const skills = [];
+  for (const skillMd of _globSkillMd(skillsDir)) {
+    const fm = _parse_frontmatter(skillMd);
+    const rawName = fm["name"];
+    const name = _truthyStr(rawName) ? String(rawName) : path63.basename(path63.dirname(skillMd));
+    const rawDesc = fm["description"];
+    const desc = _truthyStr(rawDesc) ? String(rawDesc) : "";
+    let personas = fm["personas"] ?? [];
+    if (typeof personas === "string") {
+      personas = [personas];
+    }
+    const personaList = [...personas];
+    skills.push({
+      name,
+      description: desc,
+      personas: personaList,
+      terms: _tokenize(name + " " + desc)
+    });
+  }
+  return skills;
+}
+function _truthyStr(v) {
+  if (typeof v === "string") {
+    return v !== "";
+  }
+  return false;
+}
+function _globSkillMd(root) {
+  let names;
+  try {
+    names = fs62.readdirSync(root);
+  } catch {
+    return [];
+  }
+  const dirs = [];
+  for (const name of names) {
+    const dir = path63.join(root, name);
+    const skillMd = path63.join(dir, "SKILL.md");
+    try {
+      if (fs62.statSync(dir).isDirectory() && fs62.statSync(skillMd).isFile()) {
+        dirs.push(name);
+      }
+    } catch {
+    }
+  }
+  dirs.sort();
+  return dirs.map((name) => path63.join(root, name, "SKILL.md"));
+}
+function _score3(taskTerms, skill) {
+  if (taskTerms.size === 0) {
+    return 0;
+  }
+  const skillTerms = skill.terms;
+  let inter = 0;
+  for (const t of taskTerms) {
+    if (skillTerms.has(t)) {
+      inter++;
+    }
+  }
+  const overlap = inter / Math.max(taskTerms.size, 1);
+  let personaHit = 0;
+  const taskLower = [...taskTerms].join(" ");
+  for (const persona of skill.personas) {
+    const slug = String(persona).toLowerCase();
+    const parts = slug.split("-");
+    if (taskLower.includes(slug) || parts.some((part) => taskTerms.has(part))) {
+      personaHit = 1;
+      break;
+    }
+  }
+  return pyRound(overlap * 70 + personaHit * 30, 0);
+}
+function rank(task, skillsDir) {
+  const taskTerms = _tokenize(task);
+  const skills = _load_skills(skillsDir);
+  const rows = [];
+  for (const s of skills) {
+    const score = _score3(taskTerms, s);
+    if (score > 0) {
+      rows.push([s.name, score, [...s.personas]]);
+    }
+  }
+  rows.sort((a, b) => {
+    if (b[1] !== a[1]) {
+      return b[1] - a[1];
+    }
+    if (a[0] < b[0]) {
+      return -1;
+    }
+    if (a[0] > b[0]) {
+      return 1;
+    }
+    return 0;
+  });
+  return rows;
+}
+function _ljust2(s, w) {
+  const len = pyLen(s);
+  return len >= w ? s : s + " ".repeat(w - len);
+}
+function _rjust3(n) {
+  const s = String(n);
+  return s.length >= 3 ? s : " ".repeat(3 - s.length) + s;
+}
+function _print_human(rowsIn, top) {
+  let rows = rowsIn;
+  if (top) {
+    rows = rows.slice(0, top);
+  }
+  if (rows.length === 0) {
+    return ["(no relevant skills found)"];
+  }
+  const width = Math.max(...rows.map((r) => pyLen(r[0])));
+  const lines = [];
+  for (const [name, score, personas] of rows) {
+    const personaStr = personas.length > 0 ? personas.join(", ") : "\u2014";
+    lines.push(`  ${_rjust3(score)}  ${_ljust2(name, width)}  ${personaStr}`);
+  }
+  return lines;
+}
+function _pyJsonStr3(s) {
+  let out = '"';
+  for (const ch of s) {
+    const code = ch.codePointAt(0);
+    if (ch === '"') {
+      out += '\\"';
+    } else if (ch === "\\") {
+      out += "\\\\";
+    } else if (ch === "\n") {
+      out += "\\n";
+    } else if (ch === "\r") {
+      out += "\\r";
+    } else if (ch === "	") {
+      out += "\\t";
+    } else if (ch === "\b") {
+      out += "\\b";
+    } else if (ch === "\f") {
+      out += "\\f";
+    } else if (code < 32) {
+      out += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else if (code < 127) {
+      out += ch;
+    } else if (code <= 65535) {
+      out += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else {
+      const c = code - 65536;
+      const hi = 55296 + (c >> 10);
+      const lo = 56320 + (c & 1023);
+      out += `\\u${hi.toString(16).padStart(4, "0")}\\u${lo.toString(16).padStart(4, "0")}`;
+    }
+  }
+  return out + '"';
+}
+function pyJsonDumpsIndent2(obj, level = 0) {
+  if (obj === null) {
+    return "null";
+  }
+  if (typeof obj === "number") {
+    return String(obj);
+  }
+  if (typeof obj === "string") {
+    return _pyJsonStr3(obj);
+  }
+  if (obj === true) {
+    return "true";
+  }
+  if (obj === false) {
+    return "false";
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return "[]";
+    }
+    const pad2 = " ".repeat(2 * (level + 1));
+    const closePad2 = " ".repeat(2 * level);
+    return `[
+${obj.map((v) => pad2 + pyJsonDumpsIndent2(v, level + 1)).join(",\n")}
+${closePad2}]`;
+  }
+  const keys = Object.keys(obj);
+  if (keys.length === 0) {
+    return "{}";
+  }
+  const pad = " ".repeat(2 * (level + 1));
+  const closePad = " ".repeat(2 * level);
+  const parts = keys.map(
+    (k) => `${pad}${_pyJsonStr3(k)}: ${pyJsonDumpsIndent2(obj[k], level + 1)}`
+  );
+  return `{
+${parts.join(",\n")}
+${closePad}}`;
+}
+var PROG3 = "score_skill_relevance.py";
+function _argError4(message) {
+  process.stderr.write(`${PROG3}: error: ${message}
+`);
+  process.exit(2);
+}
+function _parseInt2(raw) {
+  if (!/^[+-]?\d+$/u.test(raw.trim())) {
+    _argError4(`argument --top: invalid int value: '${raw}'`);
+  }
+  return parseInt(raw, 10);
+}
+function parse_args8(argv) {
+  const args = {
+    task: "",
+    skills_dir: DEFAULT_SKILLS_DIR,
+    top: 0,
+    json: false,
+    sample: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") {
+      args.json = true;
+    } else if (a === "--sample") {
+      args.sample = true;
+    } else if (a === "--task") {
+      const v = argv[++i];
+      if (v === void 0) {
+        _argError4("argument --task: expected one argument");
+      }
+      args.task = v;
+    } else if (a.startsWith("--task=")) {
+      args.task = a.slice("--task=".length);
+    } else if (a === "--skills-dir") {
+      const v = argv[++i];
+      if (v === void 0) {
+        _argError4("argument --skills-dir: expected one argument");
+      }
+      args.skills_dir = v;
+    } else if (a.startsWith("--skills-dir=")) {
+      args.skills_dir = a.slice("--skills-dir=".length);
+    } else if (a === "--top") {
+      const v = argv[++i];
+      if (v === void 0) {
+        _argError4("argument --top: expected one argument");
+      }
+      args.top = _parseInt2(v);
+    } else if (a.startsWith("--top=")) {
+      args.top = _parseInt2(a.slice("--top=".length));
+    } else {
+      _argError4(`unrecognized arguments: ${a}`);
+    }
+  }
+  return args;
+}
+var _SAMPLE = {
+  task: "build a livewire component for the user dashboard with reactive state"
+};
+function main41(argv = null) {
+  const args = parse_args8(argv ?? process.argv.slice(2));
+  const task = args.sample ? _SAMPLE.task : args.task;
+  if (!task) {
+    _argError4("--task is required (or pass --sample)");
+  }
+  const rows = rank(task, args.skills_dir);
+  if (args.json) {
+    const sliced = args.top ? rows.slice(0, args.top) : rows;
+    const payload = sliced.map(([n, s, p]) => ({ name: n, score: s, personas: p }));
+    process.stdout.write(pyJsonDumpsIndent2({ task, ranked: payload }));
+    process.stdout.write("\n");
+  } else {
+    const lines = _print_human(rows, args.top || null);
+    process.stdout.write(lines.join("\n") + "\n");
+  }
+  return 0;
+}
+function _isCliEntry31() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL36(path63.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs62.realpathSync(fileURLToPath43(import.meta.url));
+    const argv = fs62.realpathSync(path63.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var _isMain5 = _isCliEntry31();
+if (_isMain5) {
+  process.exitCode = main41();
+}
+
+// src/scripts/hooks/skill_route_hook.ts
+var EXIT_ALLOW18 = 0;
+var EXIT_WARN10 = 2;
+var MIN_TOP_SCORE = 31;
+var MIN_TASK_TERMS = 3;
+var TOP_K = 3;
+function _isObject14(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function routePointers(prompt, skillsDir) {
+  if (skillsDir === null) return [];
+  try {
+    if (_tokenize(prompt).size < MIN_TASK_TERMS) return [];
+  } catch {
+    return [];
+  }
+  let rows;
+  try {
+    rows = rank(prompt, skillsDir);
+  } catch {
+    return [];
+  }
+  const top = rows[0];
+  if (top === void 0 || top[1] < MIN_TOP_SCORE) return [];
+  return rows.slice(0, TOP_K);
+}
+function buildRouteLine(rows) {
+  const pointers = rows.map(([name, score]) => `${name} (${score})`).join(", ");
+  return `<skill-route>ranked skill pointers for this prompt: ${pointers}. Deterministic keyword ranker, top-1 at or above ${MIN_TOP_SCORE}/100 \u2014 pointers only, no bodies loaded. Open one if it fits; ignore the line if it does not.</skill-route>`;
+}
+function _extractPrompt3(payload) {
+  for (const key of ["prompt", "userPrompt", "user_prompt", "message", "text"]) {
+    const v = payload[key];
+    if (typeof v === "string" && v.trim()) return v;
+  }
+  return "";
+}
+function _workspaceRoot4(envelope) {
+  const v = envelope["workspace_root"];
+  return typeof v === "string" && v ? v : process.cwd();
+}
+function main42() {
+  let envelope = {};
+  try {
+    const raw = readHookStdin();
+    envelope = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return EXIT_ALLOW18;
+  }
+  const env = _isObject14(envelope) ? envelope : {};
+  const event = env["event"];
+  const slot = typeof event === "string" && event !== "" ? event : "user_prompt_submit";
+  if (slot !== "user_prompt_submit") return EXIT_ALLOW18;
+  const payload = _isObject14(env["payload"]) ? env["payload"] : env;
+  const prompt = _extractPrompt3(payload);
+  if (!prompt) return EXIT_ALLOW18;
+  if (isSyntheticPrompt(prompt)) return EXIT_ALLOW18;
+  const rows = routePointers(prompt, resolveSkillsRoot(_workspaceRoot4(env)));
+  if (rows.length === 0) return EXIT_ALLOW18;
+  process.stdout.write(
+    `${JSON.stringify({
+      decision: "warn",
+      reason: `skill-route: ${rows.length} pointer(s), top ${rows[0][1]}/100`,
+      additional_context: buildRouteLine(rows)
+    })}
+`
+  );
+  return EXIT_WARN10;
+}
+function _isCliEntry32() {
+  if (true) return false;
+  if (process.argv[1] === void 0) return false;
+  const argvUrl = pathToFileURL37(path64.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) return true;
+  try {
+    const here = fs63.realpathSync(fileURLToPath44(import.meta.url));
+    const argv = fs63.realpathSync(path64.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry32()) {
+  process.exit(main42());
+}
+
 // src/scripts/hooks/end_review_nudge_hook.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
 import * as crypto6 from "node:crypto";
-import * as fs61 from "node:fs";
+import * as fs64 from "node:fs";
 import * as os7 from "node:os";
-import * as path62 from "node:path";
-import { fileURLToPath as fileURLToPath43, pathToFileURL as pathToFileURL36 } from "node:url";
+import * as path65 from "node:path";
+import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL38 } from "node:url";
 
 // src/scripts/_lib/review_skipped_record.ts
 function isNonNegInt(n) {
@@ -26883,19 +27472,19 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   const homeDir = opts.homeDir ?? os7.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs61.realpathSync(homeDir);
-    const realPath = fs61.realpathSync(rawPath);
-    const relative9 = path62.relative(realHome, realPath);
-    if (relative9 === "" || relative9.startsWith("..") || path62.isAbsolute(relative9)) {
+    const realHome = fs64.realpathSync(homeDir);
+    const realPath = fs64.realpathSync(rawPath);
+    const relative9 = path65.relative(realHome, realPath);
+    if (relative9 === "" || relative9.startsWith("..") || path65.isAbsolute(relative9)) {
       return false;
     }
-    const { size } = fs61.statSync(realPath);
+    const { size } = fs64.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
   }
 }
-var EXIT_WARN10 = 2;
+var EXIT_WARN11 = 2;
 function parseNumstat(raw) {
   const rows = [];
   for (const line of raw.split("\n")) {
@@ -27032,19 +27621,19 @@ function appendReviewSkippedTelemetry(workspaceRoot2, diffLines, mutationMeasure
   });
   if (errors.length || line === null) return;
   try {
-    const dir = path62.join(workspaceRoot2, "agents", "runtime", "state", "audit");
-    fs61.mkdirSync(dir, { recursive: true });
-    const file = path62.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs61.appendFileSync(file, `${JSON.stringify(line)}
+    const dir = path65.join(workspaceRoot2, "agents", "runtime", "state", "audit");
+    fs64.mkdirSync(dir, { recursive: true });
+    const file = path65.join(dir, `${ts.slice(0, 7)}.jsonl`);
+    fs64.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
 }
 function sessionStateDir(workspaceRoot2) {
-  return path62.join(workspaceRoot2, "agents", "runtime", "state", "end-review-nudge");
+  return path65.join(workspaceRoot2, "agents", "runtime", "state", "end-review-nudge");
 }
 function sessionStateFile(workspaceRoot2, sessionKey) {
-  return path62.join(sessionStateDir(workspaceRoot2), `${sessionKey}.json`);
+  return path65.join(sessionStateDir(workspaceRoot2), `${sessionKey}.json`);
 }
 function deriveSessionKey(envelope, payload) {
   const raw = str3(envelope["session_id"]) || str3(payload["transcript_path"] ?? payload["transcriptPath"]);
@@ -27053,7 +27642,7 @@ function deriveSessionKey(envelope, payload) {
 }
 function hasFiredThisSession(workspaceRoot2, sessionKey) {
   try {
-    return fs61.existsSync(sessionStateFile(workspaceRoot2, sessionKey));
+    return fs64.existsSync(sessionStateFile(workspaceRoot2, sessionKey));
   } catch {
     return false;
   }
@@ -27067,7 +27656,7 @@ function markFiredThisSession(workspaceRoot2, sessionKey, ts) {
 function _read_stdin3() {
   return readHookStdin();
 }
-function main41() {
+function main43() {
   const [envelope, payload] = unwrap(_read_stdin3(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
@@ -27096,7 +27685,7 @@ function main41() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs61.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs64.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -27117,42 +27706,42 @@ function main41() {
     })}
 `
   );
-  return EXIT_WARN10;
+  return EXIT_WARN11;
 }
-function _isCliEntry31() {
+function _isCliEntry33() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL36(path62.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL38(path65.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs61.realpathSync(fileURLToPath43(import.meta.url));
-    const argv = fs61.realpathSync(path62.resolve(process.argv[1]));
+    const here = fs64.realpathSync(fileURLToPath45(import.meta.url));
+    const argv = fs64.realpathSync(path65.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry31()) {
-  process.exit(main41());
+if (_isCliEntry33()) {
+  process.exit(main43());
 }
 
 // src/scripts/hooks/turn_end_gate_hook.ts
 import * as crypto8 from "node:crypto";
-import * as fs63 from "node:fs";
-import * as path64 from "node:path";
-import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL38 } from "node:url";
+import * as fs66 from "node:fs";
+import * as path67 from "node:path";
+import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL40 } from "node:url";
 
 // src/scripts/hooks/subagent_ledger_hook.ts
 import * as crypto7 from "node:crypto";
-import * as fs62 from "node:fs";
-import * as path63 from "node:path";
-import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL37 } from "node:url";
+import * as fs65 from "node:fs";
+import * as path66 from "node:path";
+import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL39 } from "node:url";
 
 // src/scripts/_lib/subagent_response.ts
 var MAX_SUMMARY_CHARS = 2e3;
@@ -27242,11 +27831,11 @@ function validateResponse(input) {
 }
 
 // src/scripts/hooks/subagent_ledger_hook.ts
-var EXIT_ALLOW18 = 0;
+var EXIT_ALLOW19 = 0;
 function isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var LEDGER_DIR = path63.join("agents", "runtime", "state", "subagent-ledger");
+var LEDGER_DIR = path66.join("agents", "runtime", "state", "subagent-ledger");
 var OPEN_SUBDIR = "open";
 var OPEN_RECORD_TTL_MS = 24 * 60 * 60 * 1e3;
 function refFor(agentId) {
@@ -27327,10 +27916,10 @@ function _jsonObjectCandidates(message) {
   return out;
 }
 function openDir(root) {
-  return path63.join(root, LEDGER_DIR, OPEN_SUBDIR);
+  return path66.join(root, LEDGER_DIR, OPEN_SUBDIR);
 }
 function openFile(root, ref) {
-  return path63.join(openDir(root), `${ref}.json`);
+  return path66.join(openDir(root), `${ref}.json`);
 }
 var DEPTH_BASES = /* @__PURE__ */ new Set(["observed", "asserted-parent", "assumed-root"]);
 function _asOpenRecord(value, expectedRef) {
@@ -27357,7 +27946,7 @@ function readOpenRecords(root) {
   const out = /* @__PURE__ */ new Map();
   let names;
   try {
-    names = fs62.readdirSync(openDir(root));
+    names = fs65.readdirSync(openDir(root));
   } catch {
     return out;
   }
@@ -27365,7 +27954,7 @@ function readOpenRecords(root) {
     if (!name.endsWith(".json")) continue;
     const expectedRef = name.slice(0, -".json".length);
     try {
-      const raw = fs62.readFileSync(path63.join(openDir(root), name), "utf8");
+      const raw = fs65.readFileSync(path66.join(openDir(root), name), "utf8");
       const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
       if (rec) out.set(rec.ref, rec);
     } catch {
@@ -27380,13 +27969,13 @@ function resolveDepth(parentRef, open) {
   return { depth: parent.depth + 1, depth_basis: "observed" };
 }
 function ledgerFileFor(root, ts) {
-  return path63.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
+  return path66.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
 }
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
   const file = ledgerFileFor(root, ts);
-  fs62.mkdirSync(path63.dirname(file), { recursive: true });
-  fs62.appendFileSync(file, `${JSON.stringify(line)}
+  fs65.mkdirSync(path66.dirname(file), { recursive: true });
+  fs65.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 var WALL_CLOCK_ARMS_MS = [
@@ -27400,7 +27989,7 @@ function armsExceeded(elapsedMs) {
   return WALL_CLOCK_ARMS_MS.filter((a) => elapsedMs >= a.ms).map((a) => a.label);
 }
 function openRecordStats(root, nowMs = Date.now()) {
-  const ledgerPresent = fs62.existsSync(path63.join(root, LEDGER_DIR));
+  const ledgerPresent = fs65.existsSync(path66.join(root, LEDGER_DIR));
   const open = readOpenRecords(root);
   let maxDepth = 0;
   let counted = 0;
@@ -27428,13 +28017,13 @@ function writeOpenRecord(root, rec) {
 function removeOpenRecord(root, ref) {
   if (is_replay_mode()) return;
   try {
-    fs62.unlinkSync(openFile(root, ref));
+    fs65.unlinkSync(openFile(root, ref));
   } catch {
   }
 }
 function countOpen(root) {
   try {
-    return fs62.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+    return fs65.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
   } catch {
     return 0;
   }
@@ -27558,9 +28147,9 @@ function handleStop(root, payload, nowIso, sessionId2) {
 }
 function processEnvelope2(envelope, consumerRoot) {
   try {
-    if (!isObject7(envelope)) return EXIT_ALLOW18;
+    if (!isObject7(envelope)) return EXIT_ALLOW19;
     const event = envelope["event"];
-    if (event !== "subagent_start" && event !== "subagent_stop") return EXIT_ALLOW18;
+    if (event !== "subagent_start" && event !== "subagent_stop") return EXIT_ALLOW19;
     const payload = unwrapPayload2(envelope);
     const nowIso = (/* @__PURE__ */ new Date()).toISOString();
     const sessionId2 = str4(payload, "session_id", "sessionId") ?? str4(envelope, "session_id", "sessionId");
@@ -27568,9 +28157,9 @@ function processEnvelope2(envelope, consumerRoot) {
     if (event === "subagent_start") handleStart(consumerRoot, payload, nowIso, sessionId2);
     else handleStop(consumerRoot, payload, nowIso, sessionId2);
   } catch {
-    return EXIT_ALLOW18;
+    return EXIT_ALLOW19;
   }
-  return EXIT_ALLOW18;
+  return EXIT_ALLOW19;
 }
 function resolveConsumerRoot(envelope) {
   if (isObject7(envelope)) {
@@ -27582,34 +28171,34 @@ function resolveConsumerRoot(envelope) {
   }
   return process.cwd();
 }
-function main42() {
+function main44() {
   const raw = readHookStdin();
   let envelope = {};
   try {
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW18;
+    return EXIT_ALLOW19;
   }
   return processEnvelope2(envelope, resolveConsumerRoot(envelope));
 }
-function _isCliEntry32() {
+function _isCliEntry34() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL37(path63.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL39(path66.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs62.realpathSync(fileURLToPath44(import.meta.url)) === fs62.realpathSync(path63.resolve(process.argv[1]));
+    return fs65.realpathSync(fileURLToPath46(import.meta.url)) === fs65.realpathSync(path66.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry32()) process.exit(main42());
+if (_isCliEntry34()) process.exit(main44());
 
 // src/scripts/hooks/turn_end_gate_hook.ts
 var EXIT_BLOCK4 = 1;
-var EXIT_ALLOW19 = 0;
+var EXIT_ALLOW20 = 0;
 var TRANSCRIPT_READ_MAX_BYTES = 8 * 1024 * 1024;
 function stripFencedBlocks(text) {
   const out = [];
@@ -27713,7 +28302,7 @@ function detectPromissory(reply) {
 }
 function readCiSettled(workspaceRoot2) {
   try {
-    const raw = fs63.readFileSync(path64.join(workspaceRoot2, STATE_FILE3), "utf-8");
+    const raw = fs66.readFileSync(path67.join(workspaceRoot2, STATE_FILE3), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       const ci = decoded["ci_last"];
@@ -27747,7 +28336,7 @@ function detectCompletionClaim(reply, ci) {
 }
 function readLanguagePin(workspaceRoot2) {
   try {
-    const raw = fs63.readFileSync(path64.join(workspaceRoot2, STATE_FILE5), "utf-8");
+    const raw = fs66.readFileSync(path67.join(workspaceRoot2, STATE_FILE5), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       const lang = decoded["language"];
@@ -27796,17 +28385,17 @@ function detectUnverifiedEdit(toolCalls) {
   };
 }
 function stateDir(workspaceRoot2) {
-  return path64.join(workspaceRoot2, "agents", "runtime", "state", "turn-end-gate");
+  return path67.join(workspaceRoot2, "agents", "runtime", "state", "turn-end-gate");
 }
 function sessionStateFile2(workspaceRoot2, sessionKey) {
-  return path64.join(stateDir(workspaceRoot2), `${sessionKey}.json`);
+  return path67.join(stateDir(workspaceRoot2), `${sessionKey}.json`);
 }
 function deriveSessionKey2(sessionId2) {
   return crypto8.createHash("sha256").update(sessionId2).digest("hex").slice(0, 32);
 }
 function alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal) {
   try {
-    const raw = fs63.readFileSync(sessionStateFile2(workspaceRoot2, sessionKey), "utf-8");
+    const raw = fs66.readFileSync(sessionStateFile2(workspaceRoot2, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -27831,10 +28420,10 @@ function readTranscriptTail(transcriptPath, opts = {}) {
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs63.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs66.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs63.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs66.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
@@ -27910,15 +28499,15 @@ function _messageText(content) {
 function str5(v) {
   return typeof v === "string" ? v : "";
 }
-function main43() {
+function main45() {
   let envelope;
   let payload;
   try {
     [envelope, payload] = unwrap(readHookStdin(), "claude");
   } catch {
-    return EXIT_ALLOW19;
+    return EXIT_ALLOW20;
   }
-  if (payload["stop_hook_active"] === true) return EXIT_ALLOW19;
+  if (payload["stop_hook_active"] === true) return EXIT_ALLOW20;
   const workspaceRoot2 = str5(envelope["workspace_root"]) || process.cwd();
   let dispatchOpen = false;
   try {
@@ -27931,11 +28520,11 @@ function main43() {
   const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
     maxBytes: TRANSCRIPT_READ_MAX_BYTES
   });
-  if (!lastAssistant) return EXIT_ALLOW19;
+  if (!lastAssistant) return EXIT_ALLOW20;
   const sessionKey = deriveSessionKey2(
     str5(envelope["session_id"]) || "unknown-session"
   );
-  if (alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal)) return EXIT_ALLOW19;
+  if (alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal)) return EXIT_ALLOW20;
   const findings = [];
   for (const f of [
     // A and D are the completion-adjacent pair a pending dispatch excuses
@@ -27955,7 +28544,7 @@ function main43() {
   ]) {
     if (f) findings.push(f);
   }
-  if (findings.length === 0) return EXIT_ALLOW19;
+  if (findings.length === 0) return EXIT_ALLOW20;
   markRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal, findings[0].detector);
   const lines = findings.map(
     (f) => `  \xB7 ${f.detector}: ${f.reason}
@@ -27970,37 +28559,37 @@ ${lines.join("\n")}
   );
   return EXIT_BLOCK4;
 }
-function _isCliEntry33() {
+function _isCliEntry35() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL38(path64.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL40(path67.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs63.realpathSync(fileURLToPath45(import.meta.url));
-    const argv = fs63.realpathSync(path64.resolve(process.argv[1]));
+    const here = fs66.realpathSync(fileURLToPath47(import.meta.url));
+    const argv = fs66.realpathSync(path67.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry33()) {
-  process.exit(main43());
+if (_isCliEntry35()) {
+  process.exit(main45());
 }
 
 // src/scripts/hooks/edit_shape_hook.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
 import * as crypto9 from "node:crypto";
-import * as fs64 from "node:fs";
-import * as path65 from "node:path";
-import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL39 } from "node:url";
-var EXIT_ALLOW20 = 0;
-var EXIT_WARN11 = 2;
+import * as fs67 from "node:fs";
+import * as path68 from "node:path";
+import { fileURLToPath as fileURLToPath48, pathToFileURL as pathToFileURL41 } from "node:url";
+var EXIT_ALLOW21 = 0;
+var EXIT_WARN12 = 2;
 var MIN_FILE_LINES = 50;
 var MAX_DIFF_RATIO = 0.2;
 var EXEMPT_PATH_PATTERNS = [
@@ -28051,7 +28640,7 @@ function effectiveDiffLines(cwd, relPath) {
 }
 function fileLineCount(absPath) {
   try {
-    const text = fs64.readFileSync(absPath, "utf8");
+    const text = fs67.readFileSync(absPath, "utf8");
     if (text.length === 0) return 0;
     return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
   } catch {
@@ -28068,11 +28657,11 @@ function deriveSessionKey3(envelope, payload) {
   return crypto9.createHash("sha256").update(material).digest("hex");
 }
 function sessionStateFile3(workspaceRoot2, sessionKey) {
-  return path65.join(workspaceRoot2, "agents", "runtime", "state", "edit-shape", `${sessionKey}.json`);
+  return path68.join(workspaceRoot2, "agents", "runtime", "state", "edit-shape", `${sessionKey}.json`);
 }
 function hasFiredThisSession2(workspaceRoot2, sessionKey) {
   try {
-    return fs64.existsSync(sessionStateFile3(workspaceRoot2, sessionKey));
+    return fs67.existsSync(sessionStateFile3(workspaceRoot2, sessionKey));
   } catch {
     return false;
   }
@@ -28093,26 +28682,26 @@ function extractFilePath(payload) {
   if (!isObject8(ti)) return "";
   return str6(ti["file_path"] ?? ti["path"] ?? ti["filePath"]);
 }
-function main44() {
+function main46() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
     const event = str6(envelope["event"]);
-    if (event !== "" && event !== "post_tool_use") return EXIT_ALLOW20;
+    if (event !== "" && event !== "post_tool_use") return EXIT_ALLOW21;
     const toolName = extractToolName2(payload);
-    if (toolName !== "Write") return EXIT_ALLOW20;
+    if (toolName !== "Write") return EXIT_ALLOW21;
     const filePath = extractFilePath(payload);
-    if (!filePath) return EXIT_ALLOW20;
+    if (!filePath) return EXIT_ALLOW21;
     const workspaceRoot2 = str6(envelope["workspace_root"]).trim() || process.cwd();
-    const absPath = path65.isAbsolute(filePath) ? filePath : path65.resolve(workspaceRoot2, filePath);
-    const relPath = path65.relative(workspaceRoot2, absPath);
-    if (isExemptPath(relPath) || isExemptPath(absPath)) return EXIT_ALLOW20;
+    const absPath = path68.isAbsolute(filePath) ? filePath : path68.resolve(workspaceRoot2, filePath);
+    const relPath = path68.relative(workspaceRoot2, absPath);
+    if (isExemptPath(relPath) || isExemptPath(absPath)) return EXIT_ALLOW21;
     const fileLines = fileLineCount(absPath);
-    if (fileLines < MIN_FILE_LINES) return EXIT_ALLOW20;
+    if (fileLines < MIN_FILE_LINES) return EXIT_ALLOW21;
     const diffLines = effectiveDiffLines(workspaceRoot2, relPath.startsWith("..") ? absPath : relPath);
-    if (diffLines === 0) return EXIT_ALLOW20;
-    if (diffLines / fileLines > MAX_DIFF_RATIO) return EXIT_ALLOW20;
+    if (diffLines === 0) return EXIT_ALLOW21;
+    if (diffLines / fileLines > MAX_DIFF_RATIO) return EXIT_ALLOW21;
     const sessionKey = deriveSessionKey3(envelope, payload);
-    if (hasFiredThisSession2(workspaceRoot2, sessionKey)) return EXIT_ALLOW20;
+    if (hasFiredThisSession2(workspaceRoot2, sessionKey)) return EXIT_ALLOW21;
     markFiredThisSession2(workspaceRoot2, sessionKey);
     process.stdout.write(
       `${JSON.stringify({
@@ -28122,41 +28711,41 @@ function main44() {
       })}
 `
     );
-    return EXIT_WARN11;
+    return EXIT_WARN12;
   } catch {
-    return EXIT_ALLOW20;
+    return EXIT_ALLOW21;
   }
 }
-function _isCliEntry34() {
+function _isCliEntry36() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL39(path65.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL41(path68.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs64.realpathSync(fileURLToPath46(import.meta.url));
-    const argv = fs64.realpathSync(path65.resolve(process.argv[1]));
+    const here = fs67.realpathSync(fileURLToPath48(import.meta.url));
+    const argv = fs67.realpathSync(path68.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry34()) {
-  process.exit(main44());
+if (_isCliEntry36()) {
+  process.exit(main46());
 }
 
 // src/scripts/hooks/reread_guard_hook.ts
 import * as crypto10 from "node:crypto";
-import * as fs65 from "node:fs";
-import * as path66 from "node:path";
-import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL40 } from "node:url";
-var EXIT_ALLOW21 = 0;
-var EXIT_WARN12 = 2;
+import * as fs68 from "node:fs";
+import * as path69 from "node:path";
+import { fileURLToPath as fileURLToPath49, pathToFileURL as pathToFileURL42 } from "node:url";
+var EXIT_ALLOW22 = 0;
+var EXIT_WARN13 = 2;
 var EXEMPT_PATH_PATTERNS2 = [
   /(^|\/)dist\//i,
   // dist/**
@@ -28190,11 +28779,11 @@ function deriveSessionKey4(envelope, payload) {
   return crypto10.createHash("sha256").update(material).digest("hex");
 }
 function ledgerFile(workspaceRoot2, sessionKey) {
-  return path66.join(workspaceRoot2, "agents", "runtime", "state", "reread-guard", `${sessionKey}.json`);
+  return path69.join(workspaceRoot2, "agents", "runtime", "state", "reread-guard", `${sessionKey}.json`);
 }
 function readLedger(workspaceRoot2, sessionKey) {
   try {
-    const parsed = JSON.parse(fs65.readFileSync(ledgerFile(workspaceRoot2, sessionKey), "utf8"));
+    const parsed = JSON.parse(fs68.readFileSync(ledgerFile(workspaceRoot2, sessionKey), "utf8"));
     if (!isObject9(parsed)) return emptyLedger();
     return {
       reads: isObject9(parsed["reads"]) ? parsed["reads"] : {},
@@ -28235,41 +28824,41 @@ function buildDuplicateReadLine(relPath, earlierTs) {
 function buildPostEditReadLine(relPath) {
   return `re-read guard: this session just edited ${relPath} \u2014 a full-file re-read re-pays for content you already have; a ranged Read (offset/limit) over the edited hunk is enough to verify the change.`;
 }
-function main45() {
+function main47() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
     const event = str7(envelope["event"]);
-    if (event !== "" && event !== "pre_tool_use") return EXIT_ALLOW21;
+    if (event !== "" && event !== "pre_tool_use") return EXIT_ALLOW22;
     const toolName = extractToolName3(payload);
     const isRead = READ_TOOLS.has(toolName);
     const isWrite = WRITE_TOOLS2.has(toolName);
-    if (!isRead && !isWrite) return EXIT_ALLOW21;
+    if (!isRead && !isWrite) return EXIT_ALLOW22;
     const toolInput = extractToolInput2(payload);
     const filePath = extractFilePath2(toolInput);
-    if (!filePath) return EXIT_ALLOW21;
+    if (!filePath) return EXIT_ALLOW22;
     const workspaceRoot2 = str7(envelope["workspace_root"]).trim() || process.cwd();
-    const absPath = path66.isAbsolute(filePath) ? filePath : path66.resolve(workspaceRoot2, filePath);
-    const relPath = path66.relative(workspaceRoot2, absPath);
-    if (isExemptPath2(relPath) || isExemptPath2(absPath)) return EXIT_ALLOW21;
+    const absPath = path69.isAbsolute(filePath) ? filePath : path69.resolve(workspaceRoot2, filePath);
+    const relPath = path69.relative(workspaceRoot2, absPath);
+    if (isExemptPath2(relPath) || isExemptPath2(absPath)) return EXIT_ALLOW22;
     const sessionKey = deriveSessionKey4(envelope, payload);
     const ledger = readLedger(workspaceRoot2, sessionKey);
     const key = relPath.startsWith("..") ? absPath : relPath;
     if (isWrite) {
       ledger.writes[key] = Date.now();
       writeLedger(workspaceRoot2, sessionKey, ledger);
-      return EXIT_ALLOW21;
+      return EXIT_ALLOW22;
     }
     if (isRangedRead(toolInput)) {
-      return EXIT_ALLOW21;
+      return EXIT_ALLOW22;
     }
     let mtime;
     let size;
     try {
-      const st = fs65.statSync(absPath);
+      const st = fs68.statSync(absPath);
       mtime = st.mtimeMs;
       size = st.size;
     } catch {
-      return EXIT_ALLOW21;
+      return EXIT_ALLOW22;
     }
     const prior = ledger.reads[key];
     const ownWrite = ledger.writes[key];
@@ -28284,7 +28873,7 @@ function main45() {
     if (ownWrite !== void 0) delete ledger.writes[key];
     if (advisory !== null) ledger.fired[key] = true;
     writeLedger(workspaceRoot2, sessionKey, ledger);
-    if (advisory === null) return EXIT_ALLOW21;
+    if (advisory === null) return EXIT_ALLOW22;
     process.stdout.write(
       `${JSON.stringify({
         decision: "warn",
@@ -28293,39 +28882,39 @@ function main45() {
       })}
 `
     );
-    return EXIT_WARN12;
+    return EXIT_WARN13;
   } catch {
-    return EXIT_ALLOW21;
+    return EXIT_ALLOW22;
   }
 }
-function _isCliEntry35() {
+function _isCliEntry37() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL40(path66.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL42(path69.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs65.realpathSync(fileURLToPath47(import.meta.url));
-    const argv = fs65.realpathSync(path66.resolve(process.argv[1]));
+    const here = fs68.realpathSync(fileURLToPath49(import.meta.url));
+    const argv = fs68.realpathSync(path69.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry35()) {
-  process.exit(main45());
+if (_isCliEntry37()) {
+  process.exit(main47());
 }
 
 // src/scripts/hooks/session_eol_hook.ts
-import * as fs67 from "node:fs";
-import * as path69 from "node:path";
+import * as fs70 from "node:fs";
+import * as path72 from "node:path";
 import process11 from "node:process";
-import { fileURLToPath as fileURLToPath48, pathToFileURL as pathToFileURL41 } from "node:url";
+import { fileURLToPath as fileURLToPath50, pathToFileURL as pathToFileURL43 } from "node:url";
 
 // src/config/recycle-threshold-budget.json
 var recycle_threshold_budget_default = {
@@ -28343,13 +28932,13 @@ var recycle_threshold_budget_default = {
 
 // src/scripts/_lib/session_eol.ts
 import * as crypto11 from "node:crypto";
-import * as fs66 from "node:fs";
-import * as path68 from "node:path";
+import * as fs69 from "node:fs";
+import * as path71 from "node:path";
 
 // src/scripts/_lib/cc_transcript.ts
-import * as path67 from "node:path";
+import * as path70 from "node:path";
 import { homedir as homedir6 } from "node:os";
-var DEFAULT_PROJECTS_ROOT = path67.join(homedir6(), ".claude", "projects");
+var DEFAULT_PROJECTS_ROOT = path70.join(homedir6(), ".claude", "projects");
 function billableInputTokens(u) {
   return u.input_tokens + u.cache_read_input_tokens + u.cache_creation_input_tokens;
 }
@@ -28458,17 +29047,17 @@ function scanEolSlice(text, prior) {
   return next;
 }
 function eolStateDir(workspaceRoot2) {
-  return path68.join(workspaceRoot2, "agents", "runtime", "state", "session-eol");
+  return path71.join(workspaceRoot2, "agents", "runtime", "state", "session-eol");
 }
 function eolStateFile(workspaceRoot2, sessionKey) {
-  return path68.join(eolStateDir(workspaceRoot2), `${sessionKey}.json`);
+  return path71.join(eolStateDir(workspaceRoot2), `${sessionKey}.json`);
 }
 function eolSessionKey(raw) {
   return crypto11.createHash("sha256").update(raw || "unknown-session").digest("hex");
 }
 function readNewCompleteLines(filePath, fromByte) {
   try {
-    const { size } = fs66.statSync(filePath);
+    const { size } = fs69.statSync(filePath);
     if (size < fromByte) {
       return { text: "", nextOffset: 0, truncated: true };
     }
@@ -28477,11 +29066,11 @@ function readNewCompleteLines(filePath, fromByte) {
     }
     const length = size - fromByte;
     const buffer = Buffer.alloc(length);
-    const fd = fs66.openSync(filePath, "r");
+    const fd = fs69.openSync(filePath, "r");
     try {
-      fs66.readSync(fd, buffer, 0, length, fromByte);
+      fs69.readSync(fd, buffer, 0, length, fromByte);
     } finally {
-      fs66.closeSync(fd);
+      fs69.closeSync(fd);
     }
     const lastNewline = buffer.lastIndexOf(10);
     if (lastNewline === -1) {
@@ -28498,9 +29087,9 @@ function readNewCompleteLines(filePath, fromByte) {
 }
 
 // src/scripts/hooks/session_eol_hook.ts
-var EXIT_WARN13 = 2;
+var EXIT_WARN14 = 2;
 var THRESHOLD_OVERRIDE_ENV = "AGENT_RECYCLE_THRESHOLD_TOKENS";
-var CONTEXT_FILL_REL = path69.join("agents", "runtime", "state", "context-fill.json");
+var CONTEXT_FILL_REL = path72.join("agents", "runtime", "state", "context-fill.json");
 function str8(value) {
   return typeof value === "string" ? value : "";
 }
@@ -28512,7 +29101,7 @@ function deriveSessionKey5(envelope, payload) {
 }
 function readState3(file) {
   try {
-    const parsed = JSON.parse(fs67.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs70.readFileSync(file, "utf-8"));
     if (parsed && typeof parsed === "object" && parsed.schema_version === 1 && parsed.counters && typeof parsed.counters.scanned_bytes === "number") {
       return {
         schema_version: 1,
@@ -28533,10 +29122,10 @@ function readState3(file) {
   };
 }
 function envelopeExists(workspaceRoot2, since = null) {
-  const target = path69.join(workspaceRoot2, RECYCLE_ENVELOPE_REL);
+  const target = path72.join(workspaceRoot2, RECYCLE_ENVELOPE_REL);
   let raw;
   try {
-    raw = fs67.readFileSync(target, "utf-8");
+    raw = fs70.readFileSync(target, "utf-8");
   } catch (exc) {
     return exc?.code !== "ENOENT";
   }
@@ -28550,7 +29139,7 @@ function envelopeExists(workspaceRoot2, since = null) {
   }
 }
 function buildMissingEnvelopeLine(workspaceRoot2) {
-  return `recycle advised earlier, but no envelope exists at ${path69.join(workspaceRoot2, RECYCLE_ENVELOPE_REL)} \u2014 /clear now starts the successor from nothing. Re-run \`agent-config session:recycle\` and check that it prints the absolute path it wrote before clearing.`;
+  return `recycle advised earlier, but no envelope exists at ${path72.join(workspaceRoot2, RECYCLE_ENVELOPE_REL)} \u2014 /clear now starts the successor from nothing. Re-run \`agent-config session:recycle\` and check that it prints the absolute path it wrote before clearing.`;
 }
 function readThresholdTokens() {
   const override = process11.env[THRESHOLD_OVERRIDE_ENV];
@@ -28566,7 +29155,7 @@ function buildAdvisoryLine3(tokens, threshold) {
 }
 function writeContextFill(workspaceRoot2, tokens, threshold, ts) {
   try {
-    atomic_write_json(path69.join(workspaceRoot2, CONTEXT_FILL_REL), {
+    atomic_write_json(path72.join(workspaceRoot2, CONTEXT_FILL_REL), {
       schema_version: 1,
       final_context_tokens: tokens,
       recycle_threshold_tokens: threshold,
@@ -28576,7 +29165,7 @@ function writeContextFill(workspaceRoot2, tokens, threshold, ts) {
   } catch {
   }
 }
-function main46() {
+function main48() {
   const [envelope, payload] = unwrap(readHookStdin(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
@@ -28633,7 +29222,7 @@ function main46() {
       })}
 `
     );
-    return EXIT_WARN13;
+    return EXIT_WARN14;
   }
   if (shouldWarnMissing) {
     process11.stdout.write(
@@ -28644,42 +29233,42 @@ function main46() {
       })}
 `
     );
-    return EXIT_WARN13;
+    return EXIT_WARN14;
   }
   return 0;
 }
-function _isCliEntry36() {
+function _isCliEntry38() {
   if (true) {
     return false;
   }
   if (process11.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL41(path69.resolve(process11.argv[1])).href;
+  const argvUrl = pathToFileURL43(path72.resolve(process11.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs67.realpathSync(fileURLToPath48(import.meta.url));
-    const argv = fs67.realpathSync(path69.resolve(process11.argv[1]));
+    const here = fs70.realpathSync(fileURLToPath50(import.meta.url));
+    const argv = fs70.realpathSync(path72.resolve(process11.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry36()) {
-  process11.exit(main46());
+if (_isCliEntry38()) {
+  process11.exit(main48());
 }
 
 // src/scripts/hooks/tool_result_bytes_hook.ts
-import * as fs68 from "node:fs";
-import * as path70 from "node:path";
-import { fileURLToPath as fileURLToPath49, pathToFileURL as pathToFileURL42 } from "node:url";
-var EXIT_ALLOW22 = 0;
+import * as fs71 from "node:fs";
+import * as path73 from "node:path";
+import { fileURLToPath as fileURLToPath51, pathToFileURL as pathToFileURL44 } from "node:url";
+var EXIT_ALLOW23 = 0;
 function isObject10(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var CENSUS_FILE = path70.join("agents", "runtime", "state", "tool-result-census.jsonl");
+var CENSUS_FILE = path73.join("agents", "runtime", "state", "tool-result-census.jsonl");
 var RESULT_KEYS = ["tool_response", "toolResponse", "tool_result", "toolUseResult"];
 function _resultBytes(payload) {
   for (const key of RESULT_KEYS) {
@@ -28712,19 +29301,19 @@ function unwrapPayload3(envelope) {
   return isObject10(inner) ? inner : envelope;
 }
 function censusFile(consumerRoot) {
-  return path70.join(consumerRoot, CENSUS_FILE);
+  return path73.join(consumerRoot, CENSUS_FILE);
 }
 function _appendCensusLine(consumerRoot, line) {
   if (is_replay_mode()) return;
   const file = censusFile(consumerRoot);
-  fs68.mkdirSync(path70.dirname(file), { recursive: true });
-  fs68.appendFileSync(file, `${JSON.stringify(line)}
+  fs71.mkdirSync(path73.dirname(file), { recursive: true });
+  fs71.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 function processEnvelope3(envelope, consumerRoot) {
   try {
-    if (!isObject10(envelope)) return EXIT_ALLOW22;
-    if (envelope["event"] !== "post_tool_use") return EXIT_ALLOW22;
+    if (!isObject10(envelope)) return EXIT_ALLOW23;
+    if (envelope["event"] !== "post_tool_use") return EXIT_ALLOW23;
     const payload = unwrapPayload3(envelope);
     const bytes = _resultBytes(payload);
     _appendCensusLine(consumerRoot, {
@@ -28734,9 +29323,9 @@ function processEnvelope3(envelope, consumerRoot) {
       measurable: bytes !== null
     });
   } catch {
-    return EXIT_ALLOW22;
+    return EXIT_ALLOW23;
   }
-  return EXIT_ALLOW22;
+  return EXIT_ALLOW23;
 }
 function resolveConsumerRoot2(envelope) {
   if (isObject10(envelope)) {
@@ -28749,36 +29338,36 @@ function resolveConsumerRoot2(envelope) {
   }
   return process.cwd();
 }
-function main47() {
+function main49() {
   const raw = readHookStdin();
   let envelope = {};
   try {
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW22;
+    return EXIT_ALLOW23;
   }
   return processEnvelope3(envelope, resolveConsumerRoot2(envelope));
 }
-function _isCliEntry37() {
+function _isCliEntry39() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL42(path70.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL44(path73.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs68.realpathSync(fileURLToPath49(import.meta.url)) === fs68.realpathSync(path70.resolve(process.argv[1]));
+    return fs71.realpathSync(fileURLToPath51(import.meta.url)) === fs71.realpathSync(path73.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry37()) process.exit(main47());
+if (_isCliEntry39()) process.exit(main49());
 
 // src/scripts/hooks/spawn_guard_shadow_hook.ts
-import * as fs69 from "node:fs";
-import * as path71 from "node:path";
-import { fileURLToPath as fileURLToPath50, pathToFileURL as pathToFileURL43 } from "node:url";
-var EXIT_ALLOW23 = 0;
+import * as fs72 from "node:fs";
+import * as path74 from "node:path";
+import { fileURLToPath as fileURLToPath52, pathToFileURL as pathToFileURL45 } from "node:url";
+var EXIT_ALLOW24 = 0;
 function isObject11(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -28806,10 +29395,10 @@ function extractToolName4(payload) {
 }
 function processEnvelope4(envelope, consumerRoot) {
   try {
-    if (!isObject11(envelope)) return EXIT_ALLOW23;
+    if (!isObject11(envelope)) return EXIT_ALLOW24;
     const payload = unwrapPayload4(envelope);
     const toolName = extractToolName4(payload);
-    if (toolName === null || !DISPATCH_TOOL_NAMES2.has(toolName)) return EXIT_ALLOW23;
+    if (toolName === null || !DISPATCH_TOOL_NAMES2.has(toolName)) return EXIT_ALLOW24;
     const stats = openRecordStats(consumerRoot);
     const depthEstimate = stats.max_depth + 1;
     const verdicts = evaluateCandidates(depthEstimate, stats.open_count);
@@ -28837,32 +29426,32 @@ function processEnvelope4(envelope, consumerRoot) {
       posture: "shadow"
     });
   } catch {
-    return EXIT_ALLOW23;
+    return EXIT_ALLOW24;
   }
-  return EXIT_ALLOW23;
+  return EXIT_ALLOW24;
 }
-function main48() {
+function main50() {
   const raw = readHookStdin();
   let envelope = {};
   try {
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW23;
+    return EXIT_ALLOW24;
   }
   return processEnvelope4(envelope, resolveConsumerRoot(envelope));
 }
-function _isCliEntry38() {
+function _isCliEntry40() {
   if (true) return false;
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL43(path71.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL45(path74.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs69.realpathSync(fileURLToPath50(import.meta.url)) === fs69.realpathSync(path71.resolve(process.argv[1]));
+    return fs72.realpathSync(fileURLToPath52(import.meta.url)) === fs72.realpathSync(path74.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry38()) process.exit(main48());
+if (_isCliEntry40()) process.exit(main50());
 
 // src/scripts/hooks/concern_registry.ts
 var CONCERN_REGISTRY = {
@@ -28899,14 +29488,15 @@ var CONCERN_REGISTRY = {
   "src/scripts/hooks/ui_route_nudge_hook.ts": main37,
   "src/scripts/hooks/orchestration_record_hook.ts": main39,
   "src/scripts/hooks/delegation_nudge_hook.ts": main40,
-  "src/scripts/hooks/end_review_nudge_hook.ts": main41,
-  "src/scripts/hooks/turn_end_gate_hook.ts": main43,
-  "src/scripts/hooks/edit_shape_hook.ts": main44,
-  "src/scripts/hooks/reread_guard_hook.ts": main45,
-  "src/scripts/hooks/session_eol_hook.ts": main46,
-  "src/scripts/hooks/subagent_ledger_hook.ts": main42,
-  "src/scripts/hooks/tool_result_bytes_hook.ts": main47,
-  "src/scripts/hooks/spawn_guard_shadow_hook.ts": main48
+  "src/scripts/hooks/skill_route_hook.ts": main42,
+  "src/scripts/hooks/end_review_nudge_hook.ts": main43,
+  "src/scripts/hooks/turn_end_gate_hook.ts": main45,
+  "src/scripts/hooks/edit_shape_hook.ts": main46,
+  "src/scripts/hooks/reread_guard_hook.ts": main47,
+  "src/scripts/hooks/session_eol_hook.ts": main48,
+  "src/scripts/hooks/subagent_ledger_hook.ts": main44,
+  "src/scripts/hooks/tool_result_bytes_hook.ts": main49,
+  "src/scripts/hooks/spawn_guard_shadow_hook.ts": main50
 };
 
 // src/scripts/hooks/host_semantics.ts
@@ -28962,14 +29552,14 @@ function emitFor(platform, event, severity, reasons, legacyExit) {
 
 // src/scripts/hooks/dispatch_hook.ts
 var _IN_BUNDLE = true;
-var REPO_ROOT = path72.resolve(
-  path72.dirname(fileURLToPath51(import.meta.url)),
+var REPO_ROOT = path75.resolve(
+  path75.dirname(fileURLToPath53(import.meta.url)),
   ..._IN_BUNDLE ? ["..", ".."] : ["..", "..", ".."]
 );
-var MANIFEST_PATH = path72.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
-var EXIT_ALLOW24 = 0;
+var MANIFEST_PATH = path75.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
+var EXIT_ALLOW25 = 0;
 var EXIT_BLOCK5 = 1;
-var EXIT_WARN14 = 2;
+var EXIT_WARN15 = 2;
 var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "session_start",
   "session_end",
@@ -28983,11 +29573,11 @@ var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "subagent_stop"
 ]);
 var _SEVERITY_BY_EXIT = {
-  [EXIT_ALLOW24]: "allow",
+  [EXIT_ALLOW25]: "allow",
   [EXIT_BLOCK5]: "block",
-  [EXIT_WARN14]: "warn"
+  [EXIT_WARN15]: "warn"
 };
-function _isObject14(v) {
+function _isObject15(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function _severity_for(rc) {
@@ -29017,16 +29607,16 @@ function _parse_concern_stdout(stdout_text) {
   } catch {
     return { _raw_stdout: text.slice(0, 500) };
   }
-  return _isObject14(parsed) ? parsed : { _raw: parsed };
+  return _isObject15(parsed) ? parsed : { _raw: parsed };
 }
 function _load_yaml3(p) {
-  const text = fs70.readFileSync(p, "utf-8");
+  const text = fs73.readFileSync(p, "utf-8");
   const data = (0, import_yaml6.parse)(text, { version: "1.1" });
-  return _isObject14(data) ? data : {};
+  return _isObject15(data) ? data : {};
 }
 function _payload_tool_name(envelope) {
   const payload = envelope["payload"];
-  if (!_isObject14(payload)) {
+  if (!_isObject15(payload)) {
     return "";
   }
   const raw = payload["tool_name"];
@@ -29054,8 +29644,8 @@ function _role_drop_set(manifest, role, event) {
     return /* @__PURE__ */ new Set();
   }
   const rolesRaw = manifest["roles"];
-  const roleSpec = _isObject14(rolesRaw) ? rolesRaw[role] : void 0;
-  if (!_isObject14(roleSpec)) {
+  const roleSpec = _isObject15(rolesRaw) ? rolesRaw[role] : void 0;
+  if (!_isObject15(roleSpec)) {
     return /* @__PURE__ */ new Set();
   }
   const drop = roleSpec["drop"];
@@ -29066,28 +29656,28 @@ function _role_drop_set(manifest, role, event) {
 }
 function _resolve_concerns(manifest, platform, event, role = "orchestrator") {
   const platformsRaw = manifest["platforms"];
-  const platforms = _isObject14(platformsRaw) ? platformsRaw : {};
+  const platforms = _isObject15(platformsRaw) ? platformsRaw : {};
   const block = platforms[platform];
   if (!block) {
     return [];
   }
-  if (_isObject14(block) && block["fallback_only"]) {
+  if (_isObject15(block) && block["fallback_only"]) {
     return [];
   }
-  const names = _isObject14(block) ? block[event] : null;
+  const names = _isObject15(block) ? block[event] : null;
   if (!Array.isArray(names)) {
     return [];
   }
   const dropped = _role_drop_set(manifest, role, event);
   const concernsRaw = manifest["concerns"];
-  const concerns_def = _isObject14(concernsRaw) ? concernsRaw : {};
+  const concerns_def = _isObject15(concernsRaw) ? concernsRaw : {};
   const out = [];
   for (const name of names) {
     if (typeof name === "string" && dropped.has(name)) {
       continue;
     }
     const spec = typeof name === "string" ? concerns_def[name] : void 0;
-    if (!spec || !_isObject14(spec)) {
+    if (!spec || !_isObject15(spec)) {
       process.stderr.write(
         `dispatch_hook: unknown concern '${String(name)}' in manifest
 `
@@ -29177,7 +29767,7 @@ function _maybe_capture_payload(args, payload_text) {
   }
   try {
     const target = _expanduser3(capture_dir);
-    fs70.mkdirSync(target, { recursive: true });
+    fs73.mkdirSync(target, { recursive: true });
     let payload;
     try {
       payload = payload_text.trim() ? JSON.parse(payload_text) : {};
@@ -29194,8 +29784,8 @@ function _maybe_capture_payload(args, payload_text) {
     const ts = Date.now();
     const native = (args.native_event || args.event).replace(/\//g, "_");
     const fname = `${args.platform}__${native}__${ts}__${process.pid}.json`;
-    fs70.writeFileSync(
-      path72.join(target, fname),
+    fs73.writeFileSync(
+      path75.join(target, fname),
       _py_json_dumps2(record, 2) + "\n",
       { encoding: "utf-8" }
     );
@@ -29206,7 +29796,7 @@ function _maybe_capture_payload(args, payload_text) {
 function _expanduser3(p) {
   if (p === "~" || p.startsWith("~/")) {
     const home = process.env["HOME"] || process.env["USERPROFILE"] || "";
-    return path72.join(home, p.slice(1));
+    return path75.join(home, p.slice(1));
   }
   return p;
 }
@@ -29214,7 +29804,7 @@ function _build_envelope(args, payload_text) {
   let payload;
   try {
     payload = payload_text.trim() ? JSON.parse(payload_text) : {};
-    if (!_isObject14(payload)) {
+    if (!_isObject15(payload)) {
       payload = { _raw: payload };
     }
   } catch {
@@ -29238,25 +29828,25 @@ function _resolve_tsx_invocation2(scriptPath, scriptArgs) {
   const walkUp = (start) => {
     let dir = start;
     for (; ; ) {
-      const candidate = path72.join(dir, "node_modules", ".bin", binName);
+      const candidate = path75.join(dir, "node_modules", ".bin", binName);
       if (_isFile7(candidate)) {
         return candidate;
       }
-      const parent = path72.dirname(dir);
+      const parent = path75.dirname(dir);
       if (parent === dir) {
         return null;
       }
       dir = parent;
     }
   };
-  const tsx = walkUp(path72.dirname(scriptPath)) ?? walkUp(path72.dirname(fileURLToPath51(import.meta.url)));
+  const tsx = walkUp(path75.dirname(scriptPath)) ?? walkUp(path75.dirname(fileURLToPath53(import.meta.url)));
   if (tsx !== null) {
     return { command: tsx, args: [scriptPath, ...scriptArgs] };
   }
   return { command: "npx", args: ["tsx", scriptPath, ...scriptArgs] };
 }
 function _run_concern_inproc(main_fn, concern, envelope) {
-  const scriptAbs = path72.join(REPO_ROOT, String(concern["script"]));
+  const scriptAbs = path75.join(REPO_ROOT, String(concern["script"]));
   const argsList = Array.isArray(concern["args"]) ? concern["args"].map((a) => String(a)) : [];
   argsList.push("--platform", String(envelope["platform"] || "generic"));
   const workspace = String(envelope["workspace_root"] || process.cwd());
@@ -29333,7 +29923,7 @@ function _run_concern(concern, envelope) {
       return _run_concern_inproc(inproc, concern, envelope);
     }
   }
-  const script = path72.join(REPO_ROOT, String(concern["script"]));
+  const script = path75.join(REPO_ROOT, String(concern["script"]));
   const argsList = Array.isArray(concern["args"]) ? concern["args"].map((a) => String(a)) : [];
   const cmd = [script, ...argsList];
   cmd.push("--platform", String(envelope["platform"] || "generic"));
@@ -29390,7 +29980,7 @@ function _run_concern(concern, envelope) {
 }
 function _isFile7(p) {
   try {
-    return fs70.statSync(p).isFile();
+    return fs73.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -29402,20 +29992,20 @@ function _reduce(rcs) {
   if (rcs.some((rc) => rc === EXIT_BLOCK5)) {
     return EXIT_BLOCK5;
   }
-  if (rcs.some((rc) => rc === EXIT_WARN14)) {
-    return EXIT_WARN14;
+  if (rcs.some((rc) => rc === EXIT_WARN15)) {
+    return EXIT_WARN15;
   }
-  return EXIT_ALLOW24;
+  return EXIT_ALLOW25;
 }
 function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
   if (is_replay_mode()) {
     return;
   }
   const workspace = String(envelope["workspace_root"] || process.cwd());
-  const state_root = path72.join(workspace, "agents", "runtime", "state");
+  const state_root = path75.join(workspace, "agents", "runtime", "state");
   const fb_dir = feedback_dir(state_root, session_id);
   try {
-    fs70.mkdirSync(fb_dir, { recursive: true });
+    fs73.mkdirSync(fb_dir, { recursive: true });
   } catch (exc) {
     const msg = exc instanceof Error ? exc.message : String(exc);
     process.stderr.write(`dispatch_hook: feedback dir unavailable: ${msg}
@@ -29423,7 +30013,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     return;
   }
   for (const entry of entries) {
-    const target = path72.join(fb_dir, `${entry["concern"]}.json`);
+    const target = path75.join(fb_dir, `${entry["concern"]}.json`);
     try {
       atomic_write_json(target, entry);
     } catch (exc) {
@@ -29463,7 +30053,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     })
   };
   try {
-    atomic_write_json(path72.join(fb_dir, "summary.json"), summary);
+    atomic_write_json(path75.join(fb_dir, "summary.json"), summary);
   } catch (exc) {
     const msg = exc instanceof Error ? exc.message : String(exc);
     process.stderr.write(`dispatch_hook: summary write failed: ${msg}
@@ -29473,17 +30063,17 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
 function _record_rule_trips(envelope, entries) {
   if (is_replay_mode()) return;
   const tripped = entries.filter(
-    (e) => e["exit_code"] === EXIT_BLOCK5 || e["exit_code"] === EXIT_WARN14
+    (e) => e["exit_code"] === EXIT_BLOCK5 || e["exit_code"] === EXIT_WARN15
   );
   if (tripped.length === 0) return;
   try {
     const workspace = String(envelope["workspace_root"] || process.cwd());
-    const state_dir = path72.join(workspace, "agents", "runtime", "state");
-    const target = path72.join(state_dir, "rule-trips.json");
-    fs70.mkdirSync(state_dir, { recursive: true });
+    const state_dir = path75.join(workspace, "agents", "runtime", "state");
+    const target = path75.join(state_dir, "rule-trips.json");
+    fs73.mkdirSync(state_dir, { recursive: true });
     let doc = { schema_version: 1, concerns: {} };
     try {
-      const parsed = JSON.parse(fs70.readFileSync(target, "utf-8"));
+      const parsed = JSON.parse(fs73.readFileSync(target, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) doc = parsed;
     } catch {
     }
@@ -29494,7 +30084,7 @@ function _record_rule_trips(envelope, entries) {
       const prev = concerns[name] ?? { block: 0, warn: 0 };
       concerns[name] = {
         block: (Number(prev["block"]) || 0) + (e["exit_code"] === EXIT_BLOCK5 ? 1 : 0),
-        warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN14 ? 1 : 0),
+        warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN15 ? 1 : 0),
         last_trip: today
       };
     }
@@ -29582,7 +30172,7 @@ function _parse_args(argv) {
   }
   return args;
 }
-function main49(argv) {
+function main51(argv) {
   const args = _parse_args(argv ?? process.argv.slice(2));
   if (args.project_dir) {
     const project_dir = _expanduser3(args.project_dir);
@@ -29600,13 +30190,13 @@ function main49(argv) {
       `dispatch_hook: unknown event '${args.event}'; allowed: ${_sortedRepr(EVENT_VOCABULARY)}
 `
     );
-    return EXIT_ALLOW24;
+    return EXIT_ALLOW25;
   }
   const manifest_path = args.manifest;
-  if (!fs70.existsSync(manifest_path)) {
+  if (!fs73.existsSync(manifest_path)) {
     process.stderr.write(`dispatch_hook: manifest missing at ${manifest_path}
 `);
-    return EXIT_ALLOW24;
+    return EXIT_ALLOW25;
   }
   const manifest = _load_yaml3(manifest_path);
   if (args.min_version) {
@@ -29630,10 +30220,10 @@ function main49(argv) {
       concerns: concerns.map((c) => c["name"])
     };
     process.stdout.write(_py_json_dumps2(plan, 2) + "\n");
-    return EXIT_ALLOW24;
+    return EXIT_ALLOW25;
   }
   if (concerns.length === 0) {
-    return EXIT_ALLOW24;
+    return EXIT_ALLOW25;
   }
   const envelope = _build_envelope(args, payload_text);
   const session_id = _resolve_session_id(envelope);
@@ -29653,7 +30243,7 @@ function main49(argv) {
     const raw_rc = rc;
     if (rc >= 3) {
       if (!concern["fail_closed"]) {
-        rc = EXIT_ALLOW24;
+        rc = EXIT_ALLOW25;
       } else {
         rc = EXIT_BLOCK5;
       }
@@ -29666,7 +30256,7 @@ function main49(argv) {
         `dispatch_hook: concern '${String(concern["name"])}' is declared severity: advisory but returned BLOCK \u2014 downgraded to warn.
 `
       );
-      rc = EXIT_WARN14;
+      rc = EXIT_WARN15;
     }
     rcs.push(rc);
     const reply = _parse_concern_stdout(stdout_text);
@@ -29676,7 +30266,7 @@ function main49(argv) {
     if (message) {
       concern_messages.push({ rc, text: message });
     }
-    if (args.event === "session_start" && rc === EXIT_ALLOW24 && typeof reply["context"] === "string" && reply["context"].trim()) {
+    if (args.event === "session_start" && rc === EXIT_ALLOW25 && typeof reply["context"] === "string" && reply["context"].trim()) {
       context_blocks.push(reply["context"].trim());
     }
     feedback_entries.push({
@@ -29695,7 +30285,7 @@ function main49(argv) {
   const final_rc = _reduce(rcs);
   _write_feedback(envelope, session_id, feedback_entries, final_rc, started_at);
   _record_rule_trips(envelope, feedback_entries);
-  if (context_blocks.length > 0 && final_rc === EXIT_ALLOW24) {
+  if (context_blocks.length > 0 && final_rc === EXIT_ALLOW25) {
     process.stdout.write(context_blocks.join("\n\n") + "\n");
   }
   const decidingReasons = concern_messages.filter((m) => m.rc === final_rc).map((m) => m.text);
@@ -29716,7 +30306,7 @@ function main49(argv) {
 }
 function _isDir4(p) {
   try {
-    return fs70.statSync(p).isDirectory();
+    return fs73.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -29727,41 +30317,41 @@ function _sortedRepr(s) {
 }
 function _readStdin14() {
   try {
-    return fs70.readFileSync(0, "utf-8");
+    return fs73.readFileSync(0, "utf-8");
   } catch {
     return "";
   }
 }
-function _isCliEntry39() {
+function _isCliEntry41() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL44(path72.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL46(path75.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs70.realpathSync(fileURLToPath51(import.meta.url));
-    const argv = fs70.realpathSync(path72.resolve(process.argv[1]));
+    const here = fs73.realpathSync(fileURLToPath53(import.meta.url));
+    const argv = fs73.realpathSync(path75.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var isCliEntry13 = _isCliEntry39();
+var isCliEntry13 = _isCliEntry41();
 if (isCliEntry13) {
-  process.exit(main49(process.argv.slice(2)));
+  process.exit(main51(process.argv.slice(2)));
 }
 
 // src/scripts/hooks/dispatch_entry.ts
-var _selfPath = fileURLToPath52(import.meta.url);
-var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path73.resolve(process.argv[1]) === path73.resolve(_selfPath);
+var _selfPath = fileURLToPath54(import.meta.url);
+var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path76.resolve(process.argv[1]) === path76.resolve(_selfPath);
 if (_invokedDirectly2) {
-  process.exitCode = main49(process.argv.slice(2));
+  process.exitCode = main51(process.argv.slice(2));
 }
 export {
-  main49 as main
+  main51 as main
 };