@event4u/agent-config 9.23.0 → 9.25.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, path43) {
-      const ctrl = callVisitor(key, node, visitor, path43);
+    function visit_(key, node, visitor, path47) {
+      const ctrl = callVisitor(key, node, visitor, path47);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path43, ctrl);
-        return visit_(key, ctrl, visitor, path43);
+        replaceNode(key, path47, ctrl);
+        return visit_(key, ctrl, visitor, path47);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path43 = Object.freeze(path43.concat(node));
+          path47 = Object.freeze(path47.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path43);
+            const ci = visit_(i, node.items[i], visitor, path47);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -133,13 +133,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path43 = Object.freeze(path43.concat(node));
-          const ck = visit_("key", node.key, visitor, path43);
+          path47 = Object.freeze(path47.concat(node));
+          const ck = visit_("key", node.key, visitor, path47);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path43);
+          const cv = visit_("value", node.value, visitor, path47);
           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, path43) {
-      const ctrl = await callVisitor(key, node, visitor, path43);
+    async function visitAsync_(key, node, visitor, path47) {
+      const ctrl = await callVisitor(key, node, visitor, path47);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path43, ctrl);
-        return visitAsync_(key, ctrl, visitor, path43);
+        replaceNode(key, path47, ctrl);
+        return visitAsync_(key, ctrl, visitor, path47);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path43 = Object.freeze(path43.concat(node));
+          path47 = Object.freeze(path47.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path43);
+            const ci = await visitAsync_(i, node.items[i], visitor, path47);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -181,13 +181,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path43 = Object.freeze(path43.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path43);
+          path47 = Object.freeze(path47.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path47);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path43);
+          const cv = await visitAsync_("value", node.value, visitor, path47);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -214,23 +214,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path43) {
+    function callVisitor(key, node, visitor, path47) {
       if (typeof visitor === "function")
-        return visitor(key, node, path43);
+        return visitor(key, node, path47);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path43);
+        return visitor.Map?.(key, node, path47);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path43);
+        return visitor.Seq?.(key, node, path47);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path43);
+        return visitor.Pair?.(key, node, path47);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path43);
+        return visitor.Scalar?.(key, node, path47);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path43);
+        return visitor.Alias?.(key, node, path47);
       return void 0;
     }
-    function replaceNode(key, path43, node) {
-      const parent = path43[path43.length - 1];
+    function replaceNode(key, path47, node) {
+      const parent = path47[path47.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, path43, value) {
+    function collectionFromPath(schema, path47, value) {
       let v = value;
-      for (let i = path43.length - 1; i >= 0; --i) {
-        const k = path43[i];
+      for (let i = path47.length - 1; i >= 0; --i) {
+        const k = path47[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 = (path43) => path43 == null || typeof path43 === "object" && !!path43[Symbol.iterator]().next().done;
+    var isEmptyPath = (path47) => path47 == null || typeof path47 === "object" && !!path47[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(path43, value) {
-        if (isEmptyPath(path43))
+      addIn(path47, value) {
+        if (isEmptyPath(path47))
           this.add(value);
         else {
-          const [key, ...rest] = path43;
+          const [key, ...rest] = path47;
           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(path43) {
-        const [key, ...rest] = path43;
+      deleteIn(path47) {
+        const [key, ...rest] = path47;
         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(path43, keepScalar) {
-        const [key, ...rest] = path43;
+      getIn(path47, keepScalar) {
+        const [key, ...rest] = path47;
         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(path43) {
-        const [key, ...rest] = path43;
+      hasIn(path47) {
+        const [key, ...rest] = path47;
         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(path43, value) {
-        const [key, ...rest] = path43;
+      setIn(path47, value) {
+        const [key, ...rest] = path47;
         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(path43, value) {
+      addIn(path47, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path43, value);
+          this.contents.addIn(path47, 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(path43) {
-        if (Collection.isEmptyPath(path43)) {
+      deleteIn(path47) {
+        if (Collection.isEmptyPath(path47)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path43) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path47) : 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(path43, keepScalar) {
-        if (Collection.isEmptyPath(path43))
+      getIn(path47, keepScalar) {
+        if (Collection.isEmptyPath(path47))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path43, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path47, 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(path43) {
-        if (Collection.isEmptyPath(path43))
+      hasIn(path47) {
+        if (Collection.isEmptyPath(path47))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path43) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path47) : 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(path43, value) {
-        if (Collection.isEmptyPath(path43)) {
+      setIn(path47, value) {
+        if (Collection.isEmptyPath(path47)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path43), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path47), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path43, value);
+          this.contents.setIn(path47, value);
         }
       }
       /**
@@ -5570,9 +5570,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path43) => {
+    visit.itemAtPath = (cst, path47) => {
       let item = cst;
-      for (const [field, index] of path43) {
+      for (const [field, index] of path47) {
         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, path43) => {
-      const parent = visit.itemAtPath(cst, path43.slice(0, -1));
-      const field = path43[path43.length - 1][0];
+    visit.parentCollection = (cst, path47) => {
+      const parent = visit.itemAtPath(cst, path47.slice(0, -1));
+      const field = path47[path47.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path43, item, visitor) {
-      let ctrl = visitor(item, path43);
+    function _visit(path47, item, visitor) {
+      let ctrl = visitor(item, path47);
       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(path43.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path47.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, path43);
+            ctrl = ctrl(item, path47);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path43) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path47) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6913,14 +6913,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs42 = this.flowScalar(this.type);
+              const fs46 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs42, sep: [] });
+                map.items.push({ start, key: fs46, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs42);
+                this.stack.push(fs46);
               } else {
-                Object.assign(it, { key: fs42, sep: [] });
+                Object.assign(it, { key: fs46, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7048,13 +7048,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs42 = this.flowScalar(this.type);
+              const fs46 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs42, sep: [] });
+                fc.items.push({ start: [], key: fs46, sep: [] });
               else if (it.sep)
-                this.stack.push(fs42);
+                this.stack.push(fs46);
               else
-                Object.assign(it, { key: fs42, sep: [] });
+                Object.assign(it, { key: fs46, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7363,15 +7363,15 @@ var require_dist = __commonJS({
 });
 
 // src/scripts/hooks/dispatch_entry.ts
-import * as path42 from "node:path";
-import { fileURLToPath as fileURLToPath32 } from "node:url";
+import * as path46 from "node:path";
+import { fileURLToPath as fileURLToPath36 } from "node:url";
 
 // src/scripts/hooks/dispatch_hook.ts
 var import_yaml6 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync5 } from "node:child_process";
-import fs41 from "node:fs";
-import path41 from "node:path";
-import { fileURLToPath as fileURLToPath31, pathToFileURL as pathToFileURL26 } from "node:url";
+import fs45 from "node:fs";
+import path45 from "node:path";
+import { fileURLToPath as fileURLToPath35, pathToFileURL as pathToFileURL30 } from "node:url";
 
 // src/scripts/_lib/spawn_env.ts
 var DENY_EXACT = /* @__PURE__ */ new Set([
@@ -15061,6 +15061,8 @@ function _empty_state2() {
     verifications_this_session: 0,
     last_stop_at: null,
     verified_this_turn: false,
+    ci_saw_pending: false,
+    nonevidence_this_turn: 0,
     checked_at: _now2()
   };
 }
@@ -15107,13 +15109,60 @@ function _extract_command(payload) {
   return [tool, null];
 }
 function _is_verification(command) {
-  return _VERIFICATION_RE.test(command);
+  return _VERIFICATION_RE.test(command) || isCiPoll(command);
+}
+var _VACUOUS_PATTERNS = [
+  // gh pr checks / gh run — no checks registered at all.
+  /\b0\s+(?:checks?|runs?)\b/i,
+  // Test runners reporting an empty run.
+  /\bno tests? (?:ran|found|to run|were run)\b/i,
+  /\bNo test files found\b/i,
+  /\b0\s+pass(?:ed|ing)?\b[\s,|·]*\b0\s+fail(?:ed|ing|ures)?\b/i,
+  /\bTests?\s+0\s+passed\b/i,
+  /\bRan 0 tests?\b/i,
+  // Linters / scanners with an empty target set.
+  /\bno files? (?:matched|to (?:lint|check|scan)|found)\b/i,
+  /\b0\s+files?\s+(?:checked|scanned|linted)\b/i,
+  /\bnothing to check\b/i
+];
+function isVacuousOutput(output) {
+  const text = output.trim();
+  if (!text) {
+    return true;
+  }
+  return _VACUOUS_PATTERNS.some((re) => re.test(text));
+}
+var _CI_POLL_RE = /\bgh\s+(?:pr\s+checks|run\s+(?:watch|list|view))\b/i;
+function isCiPoll(command) {
+  return _CI_POLL_RE.test(command);
+}
+function pendingCount(output) {
+  const m = /(\d+)\s+(?:checks? )?pending\b/i.exec(output) ?? /\bpending[:=]\s*(\d+)/i.exec(output);
+  if (m?.[1] !== void 0) {
+    return Number(m[1]);
+  }
+  const rows = output.match(/^\S.*\b(pending|in_progress|queued)\b/gim);
+  return rows ? rows.length : null;
+}
+function _extract_output(payload) {
+  for (const key of ["tool_response", "toolResponse", "output", "stdout", "result"]) {
+    const v = payload[key];
+    if (typeof v === "string") {
+      return v;
+    }
+    if (v !== null && typeof v === "object") {
+      return JSON.stringify(v);
+    }
+  }
+  return null;
 }
 function _reset_turn(state, session_id) {
   state["session_id"] = session_id || state["session_id"] || "";
   state["turn_started_at"] = _now2();
   state["verifications_this_turn"] = 0;
   state["verified_this_turn"] = false;
+  state["ci_saw_pending"] = false;
+  state["nonevidence_this_turn"] = 0;
   return state;
 }
 function _asInt2(v) {
@@ -15143,15 +15192,35 @@ function _update2(state, event, envelope) {
   } else if (event === "post_tool_use") {
     const [tool, cmd] = _extract_command(pl);
     if (cmd && _is_verification(cmd)) {
+      const output = _extract_output(pl);
+      const vacuous = output !== null && isVacuousOutput(output);
+      let counts = !vacuous;
+      if (isCiPoll(cmd)) {
+        const pending = output === null ? null : pendingCount(output);
+        if (pending !== null && pending > 0) {
+          state["ci_saw_pending"] = true;
+          counts = false;
+        } else if (pending === 0) {
+          counts = !vacuous && state["ci_saw_pending"] === true;
+        } else {
+          counts = false;
+        }
+      }
       state["last_verification"] = {
         command: cmd.slice(0, 512),
         tool,
         at: _now2(),
-        platform: envelope["platform"] || ""
+        platform: envelope["platform"] || "",
+        vacuous,
+        counted: counts
       };
-      state["verifications_this_turn"] = _asInt2(state["verifications_this_turn"]) + 1;
-      state["verifications_this_session"] = _asInt2(state["verifications_this_session"]) + 1;
-      state["verified_this_turn"] = true;
+      if (counts) {
+        state["verifications_this_turn"] = _asInt2(state["verifications_this_turn"]) + 1;
+        state["verifications_this_session"] = _asInt2(state["verifications_this_session"]) + 1;
+        state["verified_this_turn"] = true;
+      } else {
+        state["nonevidence_this_turn"] = _asInt2(state["nonevidence_this_turn"]) + 1;
+      }
     }
   } else if (event === "stop") {
     state["last_stop_at"] = _now2();
@@ -17398,11 +17467,636 @@ if (_isCliEntry18()) {
   process.exit(main22());
 }
 
-// src/scripts/hooks/block_no_verify.ts
-import * as fs33 from "node:fs";
+// src/scripts/language_mirror_hook.ts
+import fs33 from "node:fs";
+import path33 from "node:path";
 import { fileURLToPath as fileURLToPath25, pathToFileURL as pathToFileURL20 } from "node:url";
-import * as path33 from "node:path";
-var _HERE3 = fileURLToPath25(import.meta.url);
+var EXIT_ALLOW5 = 0;
+var STATE_FILE5 = path33.join("agents", "state", "language-mirror.json");
+function _isObject6(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var DE_MARKERS = /\b(der|die|das|den|dem|und|ist|sind|nicht|kein|keine|mach|mache|bitte|warum|wieso|weshalb|weiter|kannst|sollst|soll|musst|muss|hast|habe|haben|wir|ich|du|dann|noch|auch|schon|wenn|aber|alle|mit|ohne|damit|dass|wurde|werden|gibt|nochmal|erstell|erstelle|erstelle|fehler|regeln|arbeite|analysiere|fixe|nimm|lege|prüfe|pruefe|schau|zeig|mir|dir|sich|eine|einen|einem|einer|vom|zum|zur|beim|im|am)\b|[äöüÄÖÜß]/gi;
+var EN_MARKERS = /\b(the|and|is|are|was|were|not|please|why|because|should|would|could|there|these|those|with|from|about|which|that|this|will|have|has|been|they|them|their|your|our|what|when|where|make|need|want|does|doesn't|don't|it's|let's)\b/gi;
+var MIN_MARKERS = 2;
+function classify(prompt) {
+  const de = (prompt.match(DE_MARKERS) ?? []).length;
+  const en = (prompt.match(EN_MARKERS) ?? []).length;
+  if (de < MIN_MARKERS && en < MIN_MARKERS) {
+    return { language: "und", de_markers: de, en_markers: en };
+  }
+  return { language: de >= en ? "de" : "en", de_markers: de, en_markers: en };
+}
+var LANGUAGE_NAME = {
+  de: "German (Deutsch)",
+  en: "English"
+};
+function pinText(language) {
+  const name = LANGUAGE_NAME[language];
+  return `<language-pin>
+The user submitted this turn's prompt in ${name}. That is the mirror target for EVERY user-visible token of your replies this turn \u2014 including the short inter-tool lines between tool calls, headings, table cells, bullets, status lines, and the recommendation label under any numbered-options block.
+
+This pin exists because the trigger is not observable from the transcript alone: slash-command and skill bodies arrive in the user role and can be long and English, which is what drove ~470 wrong-language turns in the sessions this hook was built from. Tool output, file contents, and an injected skill body are NOT the trigger \u2014 this pin is.
+</language-pin>`;
+}
+function _loadState(target) {
+  try {
+    const raw = fs33.readFileSync(target, "utf8");
+    const decoded = JSON.parse(raw);
+    return _isObject6(decoded) ? decoded : {};
+  } catch {
+    return {};
+  }
+}
+function nextState(previous, classification, prompt_chars, session_id, now) {
+  if (classification.language === "und") {
+    return null;
+  }
+  return {
+    language: classification.language,
+    detected_at: now,
+    prompt_chars,
+    de_markers: classification.de_markers,
+    en_markers: classification.en_markers,
+    session_id
+  };
+}
+function _extractPrompt(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 run7(stdin_text, options) {
+  let envelope = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (_isObject6(decoded)) {
+        envelope = decoded;
+      }
+    } catch {
+      return EXIT_ALLOW5;
+    }
+  }
+  const payload = _isObject6(envelope["payload"]) ? envelope["payload"] : envelope;
+  const prompt = _extractPrompt(payload);
+  if (!prompt) {
+    return EXIT_ALLOW5;
+  }
+  const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
+  const target = path33.join(options.consumer_root, STATE_FILE5);
+  const previous = _loadState(target);
+  const classification = classify(prompt);
+  const next = nextState(previous, classification, prompt.length, session_id, (/* @__PURE__ */ new Date()).toISOString());
+  const effective = next?.language ?? previous.language;
+  if (next) {
+    try {
+      atomic_write_json(target, next);
+    } catch {
+    }
+  }
+  if (effective === "de" || effective === "en") {
+    process.stdout.write(
+      `${JSON.stringify({ decision: "warn", reason: `Reply language for this turn: ${LANGUAGE_NAME[effective]}.`, additional_context: pinText(effective) })}
+`
+    );
+  }
+  return EXIT_ALLOW5;
+}
+function main23(argv) {
+  const args = argv ?? process.argv.slice(2);
+  let consumer_root = process.cwd();
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--project-dir" && args[i + 1] !== void 0) {
+      consumer_root = args[i + 1];
+      i += 1;
+    } else if (a !== void 0 && a.startsWith("--project-dir=")) {
+      consumer_root = a.slice("--project-dir=".length);
+    }
+  }
+  return run7(readHookStdin(), { consumer_root });
+}
+function _isCliEntry19() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL20(path33.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs33.realpathSync(fileURLToPath25(import.meta.url));
+    const argv = fs33.realpathSync(path33.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry19()) {
+  process.exit(main23());
+}
+
+// src/scripts/git_authorization_hook.ts
+import fs34 from "node:fs";
+import path34 from "node:path";
+import { fileURLToPath as fileURLToPath26, pathToFileURL as pathToFileURL21 } from "node:url";
+var EXIT_ALLOW6 = 0;
+var STATE_FILE6 = path34.join("agents", "state", "git-authorization.json");
+function _isObject7(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var PHRASES = [
+  { op: "commit", re: /\b(commit(e|et|ten|ted|ting)?|committe|einchecken)\b/i },
+  { op: "push", re: /\b(push(e|en|ed|ing)?|hochladen|hochschieben|raufschieben)\b/i },
+  { op: "branch", re: /\b(branch(e|es)?|zweig|feature-branch|erstelle einen branch)\b/i },
+  { op: "pr-create", re: /\b(pull[- ]request|pr\b|mach(e|en)? (einen|nen) pr|erstelle .{0,20}pr)\b/i },
+  { op: "pr-merge", re: /\b(merge[nrd]?|mergen|zusammenführen|zusammenfuehren|reinmergen|gemerged)\b/i },
+  { op: "tag", re: /\b(tag(ge|gen|ged|ging)?|version(iere|ieren)?)\b/i },
+  { op: "release", re: /\b(release[nd]?|releasen|veröffentlich(e|en|ung)|veroeffentlich(e|en))\b/i },
+  { op: "publish", re: /\b(publish(e|en|ed|ing)?|npm publish|publiziere[n]?)\b/i }
+];
+var PASTED_COMMANDS = [
+  { op: "publish", re: /\bnpm\s+publish\b/i },
+  { op: "tag", re: /\bgit\s+push\s+[^\n]*--tags\b|\bgit\s+tag\s+-a\b/i },
+  { op: "release", re: /\bgh\s+release\s+create\b/i },
+  { op: "pr-merge", re: /\bgh\s+pr\s+merge\b/i },
+  { op: "pr-create", re: /\bgh\s+pr\s+create\b/i },
+  { op: "push", re: /\bgit\s+push\b/i },
+  { op: "commit", re: /\bgit\s+commit\b/i },
+  { op: "branch", re: /\bgit\s+(checkout\s+-b|switch\s+-c|branch)\b/i }
+];
+function splitFences(prompt) {
+  const fences = [];
+  const prose = prompt.replace(/```[^\n]*\n([\s\S]*?)```/g, (_m, body) => {
+    fences.push(body);
+    return " ";
+  });
+  return { prose, fences };
+}
+function _commandLines(fence) {
+  return fence.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).filter((l) => !/^(remote:|error:|hint:|fatal:|warning:|To |!\s|\s*\^)/i.test(l)).map((l) => l.replace(/^[$>#]\s*/, "")).filter((l) => /^(git|gh|npm|pnpm|yarn|task)\b/.test(l));
+}
+function classifyAuthorization(prompt) {
+  const { prose, fences } = splitFences(prompt);
+  const authorized = /* @__PURE__ */ new Set();
+  const evidence = {};
+  for (const { op, re } of PHRASES) {
+    const m = re.exec(prose);
+    if (m) {
+      authorized.add(op);
+      evidence[op] = `prose: "${m[0]}"`;
+    }
+  }
+  for (const fence of fences) {
+    for (const line of _commandLines(fence)) {
+      for (const { op, re } of PASTED_COMMANDS) {
+        if (re.test(line)) {
+          authorized.add(op);
+          evidence[op] = `pasted command: "${line.slice(0, 80)}"`;
+        }
+      }
+    }
+  }
+  return { authorized: [...authorized], evidence };
+}
+function run8(stdin_text, options) {
+  let envelope = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (_isObject7(decoded)) {
+        envelope = decoded;
+      }
+    } catch {
+      return EXIT_ALLOW6;
+    }
+  }
+  const payload = _isObject7(envelope["payload"]) ? envelope["payload"] : envelope;
+  let prompt = "";
+  for (const key of ["prompt", "userPrompt", "user_prompt", "message", "text"]) {
+    const v = payload[key];
+    if (typeof v === "string" && v.trim()) {
+      prompt = v;
+      break;
+    }
+  }
+  if (!prompt) {
+    return EXIT_ALLOW6;
+  }
+  const { authorized, evidence } = classifyAuthorization(prompt);
+  const ledger = {
+    session_id: typeof envelope["session_id"] === "string" ? envelope["session_id"] : "",
+    detected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    authorized,
+    evidence,
+    prompt_chars: prompt.length
+  };
+  try {
+    atomic_write_json(path34.join(options.consumer_root, STATE_FILE6), ledger);
+  } catch {
+  }
+  return EXIT_ALLOW6;
+}
+function main24(argv) {
+  const args = argv ?? process.argv.slice(2);
+  let consumer_root = process.cwd();
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--project-dir" && args[i + 1] !== void 0) {
+      consumer_root = args[i + 1];
+      i += 1;
+    } else if (a !== void 0 && a.startsWith("--project-dir=")) {
+      consumer_root = a.slice("--project-dir=".length);
+    }
+  }
+  return run8(readHookStdin(), { consumer_root });
+}
+function _isCliEntry20() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL21(path34.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs34.realpathSync(fileURLToPath26(import.meta.url));
+    const argv = fs34.realpathSync(path34.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry20()) {
+  process.exit(main24());
+}
+
+// src/scripts/hooks/block_unauthorized_git.ts
+import fs35 from "node:fs";
+import path35 from "node:path";
+import { fileURLToPath as fileURLToPath27, pathToFileURL as pathToFileURL22 } from "node:url";
+var EXIT_ALLOW7 = 0;
+var EXIT_BLOCK = 2;
+function _isObject8(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var BLOCK_OPS = /* @__PURE__ */ new Set([
+  "publish",
+  "tag",
+  "release",
+  "pr-merge"
+]);
+var WARN_OPS = /* @__PURE__ */ new Set([
+  "commit",
+  "push",
+  "pr-create",
+  "branch"
+]);
+var COMMAND_OPS = [
+  { op: "publish", re: /\b(npm|pnpm|yarn)\s+publish\b/i },
+  { op: "release", re: /\bgh\s+release\s+create\b/i },
+  { op: "tag", re: /\bgit\s+push\b[^\n;|&]*--tags\b|\bgit\s+push\b[^\n;|&]*\brefs\/tags\//i },
+  { op: "pr-merge", re: /\bgh\s+pr\s+merge\b/i },
+  { op: "pr-create", re: /\bgh\s+pr\s+create\b/i },
+  { op: "push", re: /\bgit\s+push\b/i },
+  { op: "commit", re: /\bgit\s+commit\b/i },
+  { op: "branch", re: /\bgit\s+(checkout\s+-b|switch\s+-c)\b/i }
+];
+var COMMAND_TOOLS3 = /* @__PURE__ */ new Set([
+  "launch-process",
+  "launch_process",
+  "Bash",
+  "BashTool",
+  "run-process",
+  "runProcess",
+  "shell",
+  "execute_shell",
+  "RunShellCommand"
+]);
+function extractCommand(envelope) {
+  const payload = _isObject8(envelope["payload"]) ? envelope["payload"] : envelope;
+  const toolRaw = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
+  const tool = typeof toolRaw === "string" ? toolRaw : null;
+  if (tool !== null && !COMMAND_TOOLS3.has(tool)) {
+    return null;
+  }
+  const input = _isObject8(payload["tool_input"]) ? payload["tool_input"] : _isObject8(payload["toolInput"]) ? payload["toolInput"] : payload;
+  for (const key of ["command", "cmd", "script"]) {
+    const v = input[key];
+    if (typeof v === "string" && v.trim()) {
+      return v;
+    }
+  }
+  return null;
+}
+function commandOp(command) {
+  for (const { op, re } of COMMAND_OPS) {
+    if (re.test(command)) {
+      return op;
+    }
+  }
+  return null;
+}
+function _loadLedger(consumer_root) {
+  try {
+    const raw = fs35.readFileSync(path35.join(consumer_root, STATE_FILE6), "utf8");
+    const decoded = JSON.parse(raw);
+    if (_isObject8(decoded) && Array.isArray(decoded["authorized"])) {
+      return {
+        authorized: new Set(decoded["authorized"].filter(Boolean)),
+        present: true
+      };
+    }
+  } catch {
+  }
+  return { authorized: /* @__PURE__ */ new Set(), present: false };
+}
+function decide(command, ledger) {
+  if (command === null) {
+    return { exit: EXIT_ALLOW7, stdout: "", stderr: "" };
+  }
+  const op = commandOp(command);
+  if (op === null || ledger.authorized.has(op)) {
+    return { exit: EXIT_ALLOW7, stdout: "", stderr: "" };
+  }
+  const shown = command.length > 120 ? `${command.slice(0, 117)}\u2026` : command;
+  if (BLOCK_OPS.has(op)) {
+    const reason = `Blocked: \`${op}\` with no authorization in this turn's prompt. This operation is irreversible and non-destructive-by-default already declares it never-autonomous. Command: ${shown}. Ask the user, in one numbered-options block, and run it only after they answer this turn.`;
+    return { exit: EXIT_BLOCK, stdout: "", stderr: `${reason}
+` };
+  }
+  if (WARN_OPS.has(op)) {
+    const reason = `No \`${op}\` authorization found in this turn's prompt (commit-policy: a one-shot authorization is spent on the operation it named). If the user did authorize it this turn, proceed; otherwise stop and ask. Command: ${shown}`;
+    return {
+      exit: EXIT_ALLOW7,
+      stdout: `${JSON.stringify({ decision: "warn", reason })}
+`,
+      stderr: ""
+    };
+  }
+  return { exit: EXIT_ALLOW7, stdout: "", stderr: "" };
+}
+function run9(stdin_text, options) {
+  let envelope = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (_isObject8(decoded)) {
+        envelope = decoded;
+      }
+    } catch {
+      return EXIT_ALLOW7;
+    }
+  }
+  const decision = decide(extractCommand(envelope), _loadLedger(options.consumer_root));
+  if (decision.stdout) {
+    process.stdout.write(decision.stdout);
+  }
+  if (decision.stderr) {
+    process.stderr.write(decision.stderr);
+  }
+  return decision.exit;
+}
+function main25(argv) {
+  const args = argv ?? process.argv.slice(2);
+  let consumer_root = process.cwd();
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--project-dir" && args[i + 1] !== void 0) {
+      consumer_root = args[i + 1];
+      i += 1;
+    } else if (a !== void 0 && a.startsWith("--project-dir=")) {
+      consumer_root = a.slice("--project-dir=".length);
+    }
+  }
+  return run9(readHookStdin(), { consumer_root });
+}
+function _isCliEntry21() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL22(path35.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs35.realpathSync(fileURLToPath27(import.meta.url));
+    const argv = fs35.realpathSync(path35.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry21()) {
+  process.exit(main25());
+}
+
+// src/scripts/hooks/evidence_independence.ts
+import crypto2 from "node:crypto";
+import fs36 from "node:fs";
+import path36 from "node:path";
+import { fileURLToPath as fileURLToPath28, pathToFileURL as pathToFileURL23 } from "node:url";
+var EXIT_ALLOW8 = 0;
+var EXIT_BLOCK2 = 2;
+var STATE_FILE7 = path36.join("agents", "state", "evidence-dispatch.json");
+function _isObject9(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var DISPATCH_TOOLS = /* @__PURE__ */ new Set([
+  "Agent",
+  "Task",
+  "task",
+  "dispatch_agent",
+  "dispatchAgent",
+  "launch_agent",
+  "run_subagent",
+  "Subagent"
+]);
+var EVALUATION_RE = /\b(review|reviewer|audit|auditor|judge|verdict|blind[- ]pass|blind review|adversarial|critique|assess(ment)?|verify (my|the) (work|change|diff|implementation)|find (any )?(bugs|issues|defects|problems) in (my|the))\b/i;
+var PRELOADED_VERDICT_RE = [
+  /\bno[- ]findings? (is|are) (expected|welcome|fine|acceptable|the likely)/i,
+  /\b(you )?(should|will|probably) find (nothing|no (issues|problems|bugs|findings))/i,
+  /\bconfirm (that )?there (are|is) no\b/i,
+  /\bi (believe|think|expect) (this|it) is (clean|correct|fine)\b/i,
+  /\bexpect(ed)? (to be )?(clean|green|no findings)\b/i,
+  /\bjust confirm\b/i,
+  /\bit('s| is) (probably|likely) fine\b/i
+];
+function isDispatchTool(tool) {
+  return tool !== null && DISPATCH_TOOLS.has(tool);
+}
+function isEvaluationPrompt(prompt) {
+  return EVALUATION_RE.test(prompt);
+}
+var SELF_SCOPE_RE = /\b(my (work|change|diff|implementation|code|fix|patch|branch|pr)|this (diff|change|branch|pr|delta|implementation|patch)|the delta|the change i|what i (wrote|built|changed|implemented)|i just (wrote|built|changed|implemented))\b/i;
+function isSelfScoped(prompt) {
+  return SELF_SCOPE_RE.test(prompt);
+}
+function preloadedVerdict(prompt) {
+  for (const re of PRELOADED_VERDICT_RE) {
+    const m = re.exec(prompt);
+    if (m) {
+      return m[0];
+    }
+  }
+  return null;
+}
+function extractDispatch(envelope) {
+  const payload = _isObject9(envelope["payload"]) ? envelope["payload"] : envelope;
+  const toolRaw = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
+  const tool = typeof toolRaw === "string" ? toolRaw : null;
+  const input = _isObject9(payload["tool_input"]) ? payload["tool_input"] : _isObject9(payload["toolInput"]) ? payload["toolInput"] : payload;
+  for (const key of ["prompt", "instructions", "task", "description"]) {
+    const v = input[key];
+    if (typeof v === "string" && v.trim()) {
+      return [tool, v];
+    }
+  }
+  return [tool, ""];
+}
+function _load(target) {
+  try {
+    const decoded = JSON.parse(fs36.readFileSync(target, "utf8"));
+    if (_isObject9(decoded) && Array.isArray(decoded["evaluations"])) {
+      return decoded;
+    }
+  } catch {
+  }
+  return { session_id: "", turn_started_at: "", evaluations: [] };
+}
+var WARN_TEXT = "First evaluation dispatch this turn. Two shapes fabricated a binding honest-null in the audited sessions \u2014 check your prompt for both before it goes out: (1) a verdict pre-loaded into the prompt, and (2) a scope narrowed to files you chose. A review you commissioned on your own work is admissible as gate evidence only when the prompt is recorded alongside the verdict.";
+function decide2(tool, prompt, priorEvaluations) {
+  if (!isDispatchTool(tool) || !isEvaluationPrompt(prompt)) {
+    return { exit: EXIT_ALLOW8, stdout: "", stderr: "", evaluations: priorEvaluations };
+  }
+  const preloaded = preloadedVerdict(prompt);
+  if (preloaded !== null) {
+    return {
+      exit: EXIT_BLOCK2,
+      stdout: "",
+      stderr: `Blocked: this evaluation prompt pre-loads its verdict ("${preloaded}"). That is the construct that produced a fabricated NO-FINDINGS committed as binding gate evidence, over a delta an unsteered pass then found a live critical in. Remove the expectation from the prompt and let the evaluator reach its own verdict.
+`,
+      evaluations: priorEvaluations
+    };
+  }
+  if (!isSelfScoped(prompt)) {
+    return { exit: EXIT_ALLOW8, stdout: "", stderr: "", evaluations: priorEvaluations };
+  }
+  if (priorEvaluations >= 1) {
+    return {
+      exit: EXIT_BLOCK2,
+      stdout: "",
+      stderr: `Blocked: second evaluation dispatch of your own work in this turn (verdict shopping). One evaluation has already run; commissioning another with a different prompt or scope selects the answer instead of measuring it. Report what the first pass returned, then re-plan.
+`,
+      evaluations: priorEvaluations
+    };
+  }
+  return {
+    exit: EXIT_ALLOW8,
+    stdout: `${JSON.stringify({ decision: "warn", reason: WARN_TEXT })}
+`,
+    stderr: "",
+    evaluations: priorEvaluations + 1
+  };
+}
+function run10(stdin_text, options) {
+  let envelope = {};
+  if (stdin_text.trim()) {
+    try {
+      const decoded = JSON.parse(stdin_text);
+      if (_isObject9(decoded)) {
+        envelope = decoded;
+      }
+    } catch {
+      return EXIT_ALLOW8;
+    }
+  }
+  const target = path36.join(options.consumer_root, STATE_FILE7);
+  const state = _load(target);
+  const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
+  const turnMarker = typeof envelope["turn_id"] === "string" ? envelope["turn_id"] : session_id;
+  if (state.session_id !== turnMarker) {
+    state.session_id = turnMarker;
+    state.turn_started_at = (/* @__PURE__ */ new Date()).toISOString();
+    state.evaluations = [];
+  }
+  const [tool, prompt] = extractDispatch(envelope);
+  const decision = decide2(tool, prompt, state.evaluations.length);
+  if (decision.evaluations > state.evaluations.length) {
+    state.evaluations.push({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      digest: crypto2.createHash("sha256").update(prompt).digest("hex").slice(0, 16),
+      prompt_chars: prompt.length
+    });
+    try {
+      atomic_write_json(target, state);
+    } catch {
+    }
+  }
+  if (decision.stdout) {
+    process.stdout.write(decision.stdout);
+  }
+  if (decision.stderr) {
+    process.stderr.write(decision.stderr);
+  }
+  return decision.exit;
+}
+function main26(argv) {
+  const args = argv ?? process.argv.slice(2);
+  let consumer_root = process.cwd();
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--project-dir" && args[i + 1] !== void 0) {
+      consumer_root = args[i + 1];
+      i += 1;
+    } else if (a !== void 0 && a.startsWith("--project-dir=")) {
+      consumer_root = a.slice("--project-dir=".length);
+    }
+  }
+  return run10(readHookStdin(), { consumer_root });
+}
+function _isCliEntry22() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL23(path36.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs36.realpathSync(fileURLToPath28(import.meta.url));
+    const argv = fs36.realpathSync(path36.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry22()) {
+  process.exit(main26());
+}
+
+// src/scripts/hooks/block_no_verify.ts
+import * as fs37 from "node:fs";
+import { fileURLToPath as fileURLToPath29, pathToFileURL as pathToFileURL24 } from "node:url";
+import * as path37 from "node:path";
+var _HERE3 = fileURLToPath29(import.meta.url);
 var _SHELL_SEPARATORS = /* @__PURE__ */ new Set(["&&", "||", ";", "|"]);
 var _NO_VERIFY_FLAGS = /* @__PURE__ */ new Set(["--no-verify"]);
 var _NO_VERIFY_SHORT = /* @__PURE__ */ new Set(["-n"]);
@@ -17725,7 +18419,7 @@ block_no_verify.py: error: unrecognized arguments: ${arg}
 function _readStdin11() {
   return readHookStdin();
 }
-function main23(argv) {
+function main27(argv) {
   const parsed = _parseArgs4(argv ?? process.argv.slice(2));
   if (parsed.exitCode !== void 0) {
     return parsed.exitCode;
@@ -17763,33 +18457,33 @@ function main23(argv) {
   }
   return 0;
 }
-function _isCliEntry19() {
+function _isCliEntry23() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL20(path33.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL24(path37.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs33.realpathSync(fileURLToPath25(import.meta.url));
-    const argv = fs33.realpathSync(path33.resolve(process.argv[1]));
+    const here = fs37.realpathSync(fileURLToPath29(import.meta.url));
+    const argv = fs37.realpathSync(path37.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry19() || false) {
-  process.exitCode = main23();
+if (_isCliEntry23() || false) {
+  process.exitCode = main27();
 }
 
 // src/scripts/hooks/block_kernel_rule_writes.ts
-import * as fs34 from "node:fs";
-import { fileURLToPath as fileURLToPath26, pathToFileURL as pathToFileURL21 } from "node:url";
-import * as path34 from "node:path";
+import * as fs38 from "node:fs";
+import { fileURLToPath as fileURLToPath30, pathToFileURL as pathToFileURL25 } from "node:url";
+import * as path38 from "node:path";
 
 // src/scripts/_lib/kernel_rules.ts
 var KERNEL_RULE_IDS = [
@@ -17813,8 +18507,8 @@ function is_kernel_rule(name) {
 }
 
 // src/scripts/hooks/block_kernel_rule_writes.ts
-var _HERE4 = fileURLToPath26(import.meta.url);
-function _isObject6(v) {
+var _HERE4 = fileURLToPath30(import.meta.url);
+function _isObject10(v) {
   return v !== null && v !== void 0 && typeof v === "object" && !Array.isArray(v);
 }
 var _PATH_KEYS = [
@@ -17826,10 +18520,10 @@ var _PATH_KEYS = [
   "notebook_path"
 ];
 function _extract(envelope) {
-  const payload = _isObject6(envelope["payload"]) ? envelope["payload"] : envelope;
+  const payload = _isObject10(envelope["payload"]) ? envelope["payload"] : envelope;
   const nameVal = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"] ?? envelope["tool_name"] ?? envelope["tool"];
   const tool = typeof nameVal === "string" ? nameVal : "";
-  const ti = _isObject6(payload["tool_input"]) ? payload["tool_input"] : _isObject6(envelope["tool_input"]) ? envelope["tool_input"] : null;
+  const ti = _isObject10(payload["tool_input"]) ? payload["tool_input"] : _isObject10(envelope["tool_input"]) ? envelope["tool_input"] : null;
   const paths = [];
   if (ti !== null) {
     for (const key of _PATH_KEYS) {
@@ -17905,7 +18599,7 @@ function _bash_targets_kernel_rule(command) {
       continue;
     }
     if (prevWasSeparator && !tok.startsWith("-")) {
-      verbs.add(path34.basename(tok));
+      verbs.add(path38.basename(tok));
       prevWasSeparator = false;
     }
   }
@@ -17960,8 +18654,8 @@ function check_envelope(envelope) {
   return [false, ""];
 }
 function _extract_command3(envelope) {
-  const payload = _isObject6(envelope["payload"]) ? envelope["payload"] : envelope;
-  const ti = _isObject6(payload["tool_input"]) ? payload["tool_input"] : _isObject6(envelope["tool_input"]) ? envelope["tool_input"] : null;
+  const payload = _isObject10(envelope["payload"]) ? envelope["payload"] : envelope;
+  const ti = _isObject10(payload["tool_input"]) ? payload["tool_input"] : _isObject10(envelope["tool_input"]) ? envelope["tool_input"] : null;
   for (const src of [ti, payload]) {
     if (src === null) {
       continue;
@@ -17974,12 +18668,12 @@ function _extract_command3(envelope) {
   return null;
 }
 function _asObject2(v) {
-  return _isObject6(v) ? v : null;
+  return _isObject10(v) ? v : null;
 }
 function _readStdin12() {
   return readHookStdin();
 }
-function main24() {
+function main28() {
   const raw = _readStdin12();
   let envelope = {};
   if (raw.trim()) {
@@ -18004,45 +18698,45 @@ function main24() {
   }
   return 0;
 }
-function _isCliEntry20() {
+function _isCliEntry24() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL21(path34.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL25(path38.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs34.realpathSync(fileURLToPath26(import.meta.url));
-    const argv = fs34.realpathSync(path34.resolve(process.argv[1]));
+    const here = fs38.realpathSync(fileURLToPath30(import.meta.url));
+    const argv = fs38.realpathSync(path38.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry20() || false) {
-  process.exitCode = main24();
+if (_isCliEntry24() || false) {
+  process.exitCode = main28();
 }
 
 // src/scripts/hooks/block_config_weakening.ts
-import * as fs35 from "node:fs";
-import * as path35 from "node:path";
-import { fileURLToPath as fileURLToPath27, pathToFileURL as pathToFileURL22 } from "node:url";
-var _HERE5 = fileURLToPath27(import.meta.url);
-var EXIT_ALLOW5 = 0;
-var EXIT_BLOCK = 1;
+import * as fs39 from "node:fs";
+import * as path39 from "node:path";
+import { fileURLToPath as fileURLToPath31, pathToFileURL as pathToFileURL26 } from "node:url";
+var _HERE5 = fileURLToPath31(import.meta.url);
+var EXIT_ALLOW9 = 0;
+var EXIT_BLOCK3 = 1;
 var EXIT_WARN3 = 2;
 var SESSION_ENTRY_CAP = 20;
 var SESSION_WARN_AT = 5;
-function _isObject7(v) {
+function _isObject11(v) {
   return v !== null && v !== void 0 && typeof v === "object" && !Array.isArray(v);
 }
 var _PATH_KEYS2 = ["file_path", "path", "target_file", "filePath", "notebook_path"];
 function classify_target(p) {
-  const posix = p.split(path35.sep).join("/");
+  const posix = p.split(path39.sep).join("/");
   const base = posix.split("/").pop() ?? "";
   if (/_allowlist\.(json|txt)$/.test(base) || /^allowlist[-_.]/.test(base)) {
     return "allowlist";
@@ -18090,7 +18784,7 @@ function added_entries(tool_input, on_disk) {
   }
   return 0;
 }
-function decide(kind, rel_path, session_total, added) {
+function decide3(kind, rel_path, session_total, added) {
   if (kind === null || added <= 0) {
     return { action: "allow", reason: "" };
   }
@@ -18116,13 +18810,13 @@ function decide(kind, rel_path, session_total, added) {
   return { action: "allow", reason: "" };
 }
 function _state_file(root) {
-  return path35.join(root, "agents", "runtime", "state", "config-weakening.json");
+  return path39.join(root, "agents", "runtime", "state", "config-weakening.json");
 }
 function bump_session(root, session, key, added) {
   const f = _state_file(root);
   let data = {};
   try {
-    data = JSON.parse(fs35.readFileSync(f, "utf-8"));
+    data = JSON.parse(fs39.readFileSync(f, "utf-8"));
   } catch {
     data = {};
   }
@@ -18131,18 +18825,18 @@ function bump_session(root, session, key, added) {
   bucket[key] = total;
   data[session] = bucket;
   try {
-    fs35.mkdirSync(path35.dirname(f), { recursive: true });
-    fs35.writeFileSync(f, `${JSON.stringify(data, null, 2)}
+    fs39.mkdirSync(path39.dirname(f), { recursive: true });
+    fs39.writeFileSync(f, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
   } catch {
   }
   return total;
 }
 function _extract2(envelope) {
-  const payload = _isObject7(envelope["payload"]) ? envelope["payload"] : envelope;
+  const payload = _isObject11(envelope["payload"]) ? envelope["payload"] : envelope;
   const nameVal = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"] ?? envelope["tool_name"] ?? envelope["tool"];
   const tool = typeof nameVal === "string" ? nameVal : "";
-  const ti = _isObject7(payload["tool_input"]) ? payload["tool_input"] : _isObject7(envelope["tool_input"]) ? envelope["tool_input"] : null;
+  const ti = _isObject11(payload["tool_input"]) ? payload["tool_input"] : _isObject11(envelope["tool_input"]) ? envelope["tool_input"] : null;
   const paths = [];
   if (ti !== null) {
     for (const key of _PATH_KEYS2) {
@@ -18154,20 +18848,20 @@ function _extract2(envelope) {
   }
   return { tool, paths, ti };
 }
-function main25() {
+function main29() {
   let envelope;
   try {
     const raw = readHookStdin();
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW5;
+    return EXIT_ALLOW9;
   }
-  if (!_isObject7(envelope)) {
-    return EXIT_ALLOW5;
+  if (!_isObject11(envelope)) {
+    return EXIT_ALLOW9;
   }
   const { tool, paths, ti } = _extract2(envelope);
   if (!tool || !EDIT_TOOLS.has(tool) || ti === null) {
-    return EXIT_ALLOW5;
+    return EXIT_ALLOW9;
   }
   const cwd = envelope["cwd"];
   const pr = envelope["workspace_root"] ?? envelope["project_root"];
@@ -18179,10 +18873,10 @@ function main25() {
     if (kind === null) {
       continue;
     }
-    const abs = path35.isAbsolute(p) ? p : path35.join(root, p);
+    const abs = path39.isAbsolute(p) ? p : path39.join(root, p);
     let on_disk = null;
     try {
-      on_disk = fs35.readFileSync(abs, "utf-8");
+      on_disk = fs39.readFileSync(abs, "utf-8");
     } catch {
       on_disk = null;
     }
@@ -18190,13 +18884,13 @@ function main25() {
     if (added <= 0) {
       continue;
     }
-    const rel = path35.relative(root, abs) || p;
+    const rel = path39.relative(root, abs) || p;
     const total = kind === "allowlist" ? bump_session(root, session, rel, added) : added;
-    const d = decide(kind, rel, total, added);
+    const d = decide3(kind, rel, total, added);
     if (d.action === "block") {
       process.stderr.write(`block-config-weakening: BLOCKED \u2014 ${d.reason}
 `);
-      return EXIT_BLOCK;
+      return EXIT_BLOCK3;
     }
     if (d.action === "warn") {
       process.stdout.write(`${JSON.stringify({ decision: "warn", reason: d.reason })}
@@ -18204,33 +18898,33 @@ function main25() {
       return EXIT_WARN3;
     }
   }
-  return EXIT_ALLOW5;
+  return EXIT_ALLOW9;
 }
-function _isCliEntry21() {
+function _isCliEntry25() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL22(path35.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL26(path39.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    return fs35.realpathSync(fileURLToPath27(import.meta.url)) === fs35.realpathSync(path35.resolve(process.argv[1]));
+    return fs39.realpathSync(fileURLToPath31(import.meta.url)) === fs39.realpathSync(path39.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry21() || process.argv[1] === _HERE5) {
-  process.exit(main25());
+if (_isCliEntry25() || process.argv[1] === _HERE5) {
+  process.exit(main29());
 }
 
 // src/scripts/hooks/rtk_wrap_hook.ts
-import fs36 from "node:fs";
-import path36 from "node:path";
-import { fileURLToPath as fileURLToPath28, pathToFileURL as pathToFileURL23 } from "node:url";
+import fs40 from "node:fs";
+import path40 from "node:path";
+import { fileURLToPath as fileURLToPath32, pathToFileURL as pathToFileURL27 } from "node:url";
 
 // src/install/rtkDetection.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
@@ -18342,7 +19036,7 @@ function detectRtkCached(options = {}) {
 
 // src/scripts/hooks/rtk_wrap_hook.ts
 var SETTINGS_FILE6 = ".agent-settings.yml";
-var EXIT_ALLOW6 = 0;
+var EXIT_ALLOW10 = 0;
 var EXIT_WARN4 = 2;
 var _RTK_PROGRAMS = /* @__PURE__ */ new Set([
   "git",
@@ -18368,19 +19062,19 @@ var _RTK_PROGRAMS = /* @__PURE__ */ new Set([
   "kubectl",
   "terraform"
 ]);
-function _isObject8(v) {
+function _isObject12(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function _enabled2(root) {
-  const f = path36.join(root, SETTINGS_FILE6);
+  const f = path40.join(root, SETTINGS_FILE6);
   try {
-    if (!fs36.statSync(f).isFile()) return false;
+    if (!fs40.statSync(f).isFile()) return false;
   } catch {
     return false;
   }
   let text;
   try {
-    text = fs36.readFileSync(f, "utf-8");
+    text = fs40.readFileSync(f, "utf-8");
   } catch {
     return false;
   }
@@ -18410,13 +19104,13 @@ function _enabled2(root) {
 function rtk_available(env = process.env) {
   const pathVar = env.PATH ?? env.Path ?? "";
   if (!pathVar) return false;
-  const dirs = pathVar.split(path36.delimiter).filter(Boolean);
+  const dirs = pathVar.split(path40.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
   for (const dir of dirs) {
     for (const ext of exts) {
-      const candidate = path36.join(dir, `rtk${ext}`);
+      const candidate = path40.join(dir, `rtk${ext}`);
       try {
-        const st = fs36.statSync(candidate);
+        const st = fs40.statSync(candidate);
         if (st.isFile()) {
           if (process.platform === "win32" || (st.mode & 73) !== 0) return true;
         }
@@ -18427,14 +19121,14 @@ function rtk_available(env = process.env) {
   return false;
 }
 function _extract_command4(envelope) {
-  const payload = _isObject8(envelope["payload"]) ? envelope["payload"] : {};
-  const tool_input = _isObject8(payload["tool_input"]) ? payload["tool_input"] : {};
+  const payload = _isObject12(envelope["payload"]) ? envelope["payload"] : {};
+  const tool_input = _isObject12(payload["tool_input"]) ? payload["tool_input"] : {};
   for (const src of [tool_input["command"], payload["command"], envelope["command"]]) {
     if (typeof src === "string") return src;
   }
   return null;
 }
-function classify(command) {
+function classify2(command) {
   const cmd = command.trim();
   if (!cmd) return { eligible: false, reason_skip: "empty" };
   let tokens;
@@ -18464,61 +19158,61 @@ function _readStdin13() {
 function _jsonReason(reason) {
   return JSON.stringify({ decision: "warn", reason });
 }
-function main26() {
+function main30() {
   let envelope;
   try {
     const raw = _readStdin13();
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW6;
+    return EXIT_ALLOW10;
   }
-  if (!_isObject8(envelope)) return EXIT_ALLOW6;
+  if (!_isObject12(envelope)) return EXIT_ALLOW10;
   const cwd = envelope["cwd"];
   const projectRoot = envelope["workspace_root"] ?? envelope["project_root"];
   const root = typeof cwd === "string" && cwd ? cwd : typeof projectRoot === "string" && projectRoot ? projectRoot : ".";
-  if (!_enabled2(root)) return EXIT_ALLOW6;
-  if (!rtk_available()) return EXIT_ALLOW6;
-  if (detectRtkCached().identity !== "token-killer") return EXIT_ALLOW6;
+  if (!_enabled2(root)) return EXIT_ALLOW10;
+  if (!rtk_available()) return EXIT_ALLOW10;
+  if (detectRtkCached().identity !== "token-killer") return EXIT_ALLOW10;
   const command = _extract_command4(envelope);
-  if (!command) return EXIT_ALLOW6;
-  const verdict = classify(command);
-  if (!verdict.eligible) return EXIT_ALLOW6;
+  if (!command) return EXIT_ALLOW10;
+  const verdict = classify2(command);
+  if (!verdict.eligible) return EXIT_ALLOW10;
   const reason = `rtk is installed and wraps verbose CLI output (upstream reports 60\u201390% fewer output tokens). Re-run wrapped: \`rtk ${command.trim()}\`. (Skip for completeness-critical output like \`git diff\`.)`;
   process.stdout.write(`${_jsonReason(reason)}
 `);
   return EXIT_WARN4;
 }
-function _isCliEntry22() {
+function _isCliEntry26() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL23(path36.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL27(path40.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs36.realpathSync(fileURLToPath28(import.meta.url));
-    const argv = fs36.realpathSync(path36.resolve(process.argv[1]));
+    const here = fs40.realpathSync(fileURLToPath32(import.meta.url));
+    const argv = fs40.realpathSync(path40.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry22()) {
-  process.exit(main26());
+if (_isCliEntry26()) {
+  process.exit(main30());
 }
 
 // src/scripts/hooks/design_slop_hook.ts
-import fs38 from "node:fs";
-import path38 from "node:path";
-import { fileURLToPath as fileURLToPath29, pathToFileURL as pathToFileURL24 } from "node:url";
+import fs42 from "node:fs";
+import path42 from "node:path";
+import { fileURLToPath as fileURLToPath33, pathToFileURL as pathToFileURL28 } from "node:url";
 
 // src/scripts/lint_design_slop.ts
-import fs37 from "node:fs";
-import path37 from "node:path";
+import fs41 from "node:fs";
+import path41 from "node:path";
 
 // src/scripts/design_slop_rules.ts
 function cssBlocks(content) {
@@ -18907,14 +19601,14 @@ var SLOP_RULES = [
     gated: (ctx) => ctx.has("brutalist", "uniform grid", "repetitive grid"),
     detect: ({ content }) => {
       const bodies = sectionBodies(content);
-      let run7 = 0;
+      let run11 = 0;
       let maxRun = 0;
       for (const b of bodies) {
         if (sectionSignature(b).mediaText) {
-          run7 += 1;
-          maxRun = Math.max(maxRun, run7);
+          run11 += 1;
+          maxRun = Math.max(maxRun, run11);
         } else {
-          run7 = 0;
+          run11 = 0;
         }
       }
       if (maxRun > 2) return [{ line: 1, snippet: `${maxRun} consecutive media+text sections` }];
@@ -18934,33 +19628,33 @@ function enginesForExt(ext) {
   return /* @__PURE__ */ new Set();
 }
 function* walkDir(dir, ext) {
-  if (!fs37.existsSync(dir)) return;
-  for (const entry of fs37.readdirSync(dir, { withFileTypes: true })) {
-    const full = path37.join(dir, entry.name);
+  if (!fs41.existsSync(dir)) return;
+  for (const entry of fs41.readdirSync(dir, { withFileTypes: true })) {
+    const full = path41.join(dir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
     if (entry.isDirectory()) yield* walkDir(full, ext);
     else if (ext.test(entry.name)) yield full;
   }
 }
 function loadConfig(dir) {
-  const p = path37.join(dir, ".design-quality.json");
-  if (!fs37.existsSync(p)) return {};
+  const p = path41.join(dir, ".design-quality.json");
+  if (!fs41.existsSync(p)) return {};
   try {
-    return JSON.parse(fs37.readFileSync(p, "utf-8"));
+    return JSON.parse(fs41.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function loadDesignContext(scanDir) {
   const candidates = [
-    path37.join(scanDir, "DESIGN.md"),
-    path37.join(process.cwd(), "DESIGN.md"),
-    path37.join(scanDir, "..", "DESIGN.md")
+    path41.join(scanDir, "DESIGN.md"),
+    path41.join(process.cwd(), "DESIGN.md"),
+    path41.join(scanDir, "..", "DESIGN.md")
   ];
   let raw = "";
   for (const c of candidates) {
-    if (fs37.existsSync(c)) {
-      raw = fs37.readFileSync(c, "utf-8").toLowerCase();
+    if (fs41.existsSync(c)) {
+      raw = fs41.readFileSync(c, "utf-8").toLowerCase();
       break;
     }
   }
@@ -18991,7 +19685,7 @@ function parseIgnores(lines) {
 }
 function scanFile(content, relPath, ctx) {
   const lines = content.split("\n");
-  const ext = path37.extname(relPath).toLowerCase();
+  const ext = path41.extname(relPath).toLowerCase();
   const fileEngines = enginesForExt(ext);
   if (fileEngines.size === 0) return [];
   const ignores = parseIgnores(lines);
@@ -19021,15 +19715,15 @@ function scanFile(content, relPath, ctx) {
   }
   return out;
 }
-function main27() {
+function main31() {
   const args = process.argv.slice(2);
   const jsonMode = args.includes("--json");
   const quiet = args.includes("--quiet");
   const dirIdx = args.indexOf("--dir");
-  const scanDir = dirIdx >= 0 && args[dirIdx + 1] ? path37.resolve(args[dirIdx + 1]) : path37.resolve(process.cwd(), "src");
+  const scanDir = dirIdx >= 0 && args[dirIdx + 1] ? path41.resolve(args[dirIdx + 1]) : path41.resolve(process.cwd(), "src");
   const failIdx = args.indexOf("--fail-on");
   const failOn = failIdx >= 0 ? args[failIdx + 1] : void 0;
-  if (!fs37.existsSync(scanDir)) {
+  if (!fs41.existsSync(scanDir)) {
     if (!quiet) {
       process.stderr.write(`[lint_design_slop] scan directory not found: ${scanDir}
 `);
@@ -19063,9 +19757,9 @@ function main27() {
   }
   const findings = [];
   for (const fp of files) {
-    const rel = path37.relative(process.cwd(), fp);
+    const rel = path41.relative(process.cwd(), fp);
     try {
-      const fileFindings = scanFile(fs37.readFileSync(fp, "utf-8"), rel, ctx).filter(
+      const fileFindings = scanFile(fs41.readFileSync(fp, "utf-8"), rel, ctx).filter(
         (f) => !ignoreRules.has(f.rule.toLowerCase())
       );
       findings.push(...fileFindings);
@@ -19098,11 +19792,11 @@ lint_design_slop: ${findings.length} tell(s) flagged (rebuttable \u2014 declare
   process.exit(overThreshold.length > 0 ? 2 : 0);
 }
 var invokedDirectly = process.argv[1] !== void 0 && /lint_design_slop\.ts$/.test(process.argv[1]);
-if (invokedDirectly) main27();
+if (invokedDirectly) main31();
 
 // src/scripts/hooks/design_slop_hook.ts
 var SETTINGS_FILE7 = ".agent-settings.yml";
-var EXIT_ALLOW7 = 0;
+var EXIT_ALLOW11 = 0;
 var EXIT_WARN5 = 2;
 var DEGRADE_AFTER = 3;
 var UI_EXT = /\.(html|htm|css|scss|sass|less|vue|svelte|astro|jsx|tsx)$/i;
@@ -19110,11 +19804,11 @@ function isObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function enabled2(root) {
-  const f = path38.join(root, SETTINGS_FILE7);
+  const f = path42.join(root, SETTINGS_FILE7);
   let text;
   try {
-    if (!fs38.statSync(f).isFile()) return false;
-    text = fs38.readFileSync(f, "utf-8");
+    if (!fs42.statSync(f).isFile()) return false;
+    text = fs42.readFileSync(f, "utf-8");
   } catch {
     return false;
   }
@@ -19151,11 +19845,11 @@ function extract(envelope) {
   return null;
 }
 function stateFile(root) {
-  return path38.join(root, "agents", "runtime", "state", "design-slop-hook.json");
+  return path42.join(root, "agents", "runtime", "state", "design-slop-hook.json");
 }
 function readState(root) {
   try {
-    const t = fs38.readFileSync(stateFile(root), "utf-8");
+    const t = fs42.readFileSync(stateFile(root), "utf-8");
     const parsed = JSON.parse(t);
     return isObject(parsed) ? parsed : {};
   } catch {
@@ -19165,31 +19859,31 @@ function readState(root) {
 function writeState(root, state) {
   try {
     const sf = stateFile(root);
-    fs38.mkdirSync(path38.dirname(sf), { recursive: true });
-    fs38.writeFileSync(sf, JSON.stringify(state, null, 2) + "\n");
+    fs42.mkdirSync(path42.dirname(sf), { recursive: true });
+    fs42.writeFileSync(sf, JSON.stringify(state, null, 2) + "\n");
   } catch {
   }
 }
 function readStdin() {
   return readHookStdin();
 }
-function main28() {
+function main32() {
   let envelope;
   try {
     const raw = readStdin();
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW7;
+    return EXIT_ALLOW11;
   }
-  if (!isObject(envelope)) return EXIT_ALLOW7;
+  if (!isObject(envelope)) return EXIT_ALLOW11;
   const rootVal = envelope["cwd"] ?? envelope["project_root"] ?? ".";
   const root = typeof rootVal === "string" && rootVal ? rootVal : ".";
-  if (!enabled2(root)) return EXIT_ALLOW7;
+  if (!enabled2(root)) return EXIT_ALLOW11;
   const ex = extract(envelope);
-  if (!ex || !ex.file || !UI_EXT.test(ex.file)) return EXIT_ALLOW7;
+  if (!ex || !ex.file || !UI_EXT.test(ex.file)) return EXIT_ALLOW11;
   let ctx;
   try {
-    ctx = loadDesignContext(path38.dirname(path38.resolve(root, ex.file)));
+    ctx = loadDesignContext(path42.dirname(path42.resolve(root, ex.file)));
   } catch {
     ctx = { raw: "", has: () => false };
   }
@@ -19199,9 +19893,9 @@ function main28() {
       (f) => f.severity === "P0" || f.severity === "P1"
     );
   } catch {
-    return EXIT_ALLOW7;
+    return EXIT_ALLOW11;
   }
-  if (findings.length === 0) return EXIT_ALLOW7;
+  if (findings.length === 0) return EXIT_ALLOW11;
   const state = readState(root);
   const surfaced = findings.filter((f) => {
     const sig = `${ex.file}::${f.rule}`;
@@ -19211,43 +19905,43 @@ function main28() {
     return true;
   });
   writeState(root, state);
-  if (surfaced.length === 0) return EXIT_ALLOW7;
+  if (surfaced.length === 0) return EXIT_ALLOW11;
   const lines = surfaced.map((f) => `${f.catalogId} (${f.rule}) ${f.file}:${f.line} \u2014 ${f.message}`).join("; ");
   const reason = "\u26A0\uFE0F Anti-slop: high-severity aesthetic tell(s) in the proposed UI \u2014 " + lines + ". Rebuttable: declare intent in DESIGN.md, add design-slop-disable-next-line, or proceed if deliberate (this is a flag, not a block).";
   process.stdout.write(JSON.stringify({ decision: "warn", reason }) + "\n");
   return EXIT_WARN5;
 }
-function _isCliEntry23() {
+function _isCliEntry27() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL24(path38.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL28(path42.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs38.realpathSync(fileURLToPath29(import.meta.url));
-    const argv = fs38.realpathSync(path38.resolve(process.argv[1]));
+    const here = fs42.realpathSync(fileURLToPath33(import.meta.url));
+    const argv = fs42.realpathSync(path42.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var isCliEntry9 = _isCliEntry23();
-if (isCliEntry9) process.exit(main28());
+var isCliEntry9 = _isCliEntry27();
+if (isCliEntry9) process.exit(main32());
 
 // src/scripts/hooks/code_graph_nudge_hook.ts
-import fs40 from "node:fs";
-import path40 from "node:path";
-import { fileURLToPath as fileURLToPath30, pathToFileURL as pathToFileURL25 } from "node:url";
+import fs44 from "node:fs";
+import path44 from "node:path";
+import { fileURLToPath as fileURLToPath34, pathToFileURL as pathToFileURL29 } from "node:url";
 
 // src/scripts/code_graph/detect.ts
 import { execFileSync } from "node:child_process";
-import * as fs39 from "node:fs";
-import * as path39 from "node:path";
+import * as fs43 from "node:fs";
+import * as path43 from "node:path";
 
 // src/scripts/code_graph/validate.ts
 var RELATIONS = /* @__PURE__ */ new Set(["calls", "imports", "uses", "inherits", "member"]);
@@ -19328,7 +20022,7 @@ function freshness(root, file, embeddedSha) {
   const last = gitLastCommitEpoch(root);
   if (last === null) return {};
   try {
-    const mtime = Math.floor(fs39.statSync(file).mtimeMs / 1e3);
+    const mtime = Math.floor(fs43.statSync(file).mtimeMs / 1e3);
     return { stale: mtime < last };
   } catch {
     return {};
@@ -19336,7 +20030,7 @@ function freshness(root, file, embeddedSha) {
 }
 function looksLikeGraph(p) {
   try {
-    const raw = JSON.parse(fs39.readFileSync(p, "utf-8"));
+    const raw = JSON.parse(fs43.readFileSync(p, "utf-8"));
     if (validateGraph(raw).ok) return { ok: true, sha: raw["head_at_build"] ?? null };
     const nodes = raw["nodes"];
     const edges = raw["edges"] ?? raw["links"];
@@ -19347,23 +20041,23 @@ function looksLikeGraph(p) {
   }
 }
 function detectSources(root, nativeCache) {
-  const abs = path39.resolve(root);
+  const abs = path43.resolve(root);
   const out = [];
   for (const rel of CONSUMER_CANDIDATES) {
-    const p = path39.join(abs, rel);
-    if (fs39.existsSync(p)) {
+    const p = path43.join(abs, rel);
+    if (fs43.existsSync(p)) {
       const { ok, sha } = looksLikeGraph(p);
       if (ok) out.push({ kind: "consumer", path: p, present: true, ...freshness(abs, p, sha) });
     }
   }
-  const scipCandidates = [path39.join(abs, "index.scip")];
+  const scipCandidates = [path43.join(abs, "index.scip")];
   try {
-    for (const e of fs39.readdirSync(abs)) if (e.endsWith(".scip")) scipCandidates.push(path39.join(abs, e));
+    for (const e of fs43.readdirSync(abs)) if (e.endsWith(".scip")) scipCandidates.push(path43.join(abs, e));
   } catch {
   }
-  const scip = scipCandidates.find((p) => fs39.existsSync(p));
+  const scip = scipCandidates.find((p) => fs43.existsSync(p));
   if (scip) out.push({ kind: "scip", path: scip, present: true, note: "SCIP detected \u2014 peer tooling required (no owned reader)" });
-  if (fs39.existsSync(nativeCache)) out.push({ kind: "native", path: nativeCache, present: true, ...freshness(abs, nativeCache, null) });
+  if (fs43.existsSync(nativeCache)) out.push({ kind: "native", path: nativeCache, present: true, ...freshness(abs, nativeCache, null) });
   return out;
 }
 function pickSource(verdicts) {
@@ -19376,18 +20070,18 @@ function pickSource(verdicts) {
 
 // src/scripts/hooks/code_graph_nudge_hook.ts
 var SETTINGS_FILE8 = ".agent-settings.yml";
-var EXIT_ALLOW8 = 0;
+var EXIT_ALLOW12 = 0;
 var EXIT_WARN6 = 2;
 var CODE_EXT = /\.(php|ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i;
 function isObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function enabled3(root) {
-  const f = path40.join(root, SETTINGS_FILE8);
+  const f = path44.join(root, SETTINGS_FILE8);
   let text;
   try {
-    if (!fs40.statSync(f).isFile()) return false;
-    text = fs40.readFileSync(f, "utf-8");
+    if (!fs44.statSync(f).isFile()) return false;
+    text = fs44.readFileSync(f, "utf-8");
   } catch {
     return false;
   }
@@ -19430,11 +20124,11 @@ function sessionId(envelope) {
   return typeof s === "string" && s ? s : "default";
 }
 function latchFile(root) {
-  return path40.join(root, "agents", "runtime", "state", "code-graph-nudge.json");
+  return path44.join(root, "agents", "runtime", "state", "code-graph-nudge.json");
 }
 function alreadyNudged(root, session) {
   try {
-    const state = JSON.parse(fs40.readFileSync(latchFile(root), "utf-8"));
+    const state = JSON.parse(fs44.readFileSync(latchFile(root), "utf-8"));
     return state[session] === true;
   } catch {
     return false;
@@ -19445,18 +20139,18 @@ function latch(root, session) {
     const p = latchFile(root);
     let state = {};
     try {
-      state = JSON.parse(fs40.readFileSync(p, "utf-8"));
+      state = JSON.parse(fs44.readFileSync(p, "utf-8"));
     } catch {
     }
     state[session] = true;
-    fs40.mkdirSync(path40.dirname(p), { recursive: true });
-    fs40.writeFileSync(p, JSON.stringify(state));
+    fs44.mkdirSync(path44.dirname(p), { recursive: true });
+    fs44.writeFileSync(p, JSON.stringify(state));
   } catch {
   }
 }
-var NATIVE_CACHE = path40.join("agents", "runtime", "state", "code-graph-v1.json");
+var NATIVE_CACHE = path44.join("agents", "runtime", "state", "code-graph-v1.json");
 function nudgeReason(root) {
-  const verdicts = detectSources(root, path40.join(root, NATIVE_CACHE));
+  const verdicts = detectSources(root, path44.join(root, NATIVE_CACHE));
   const picked = pickSource(verdicts);
   if (!picked) {
     return 'No code-graph found. For "who calls / where used / impact" run `agent-config code-graph refresh` once, then `agent-config code-graph query <symbol>` instead of grepping blind.';
@@ -19466,28 +20160,28 @@ function nudgeReason(root) {
   }
   return "A fresh code-graph is present \u2014 for structure questions run `agent-config code-graph query|affected <symbol>` first; grep is the fallback (say which answered).";
 }
-function main29() {
+function main33() {
   let envelope;
   try {
     const raw = readHookStdin();
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW8;
+    return EXIT_ALLOW12;
   }
-  if (!isObject2(envelope)) return EXIT_ALLOW8;
+  if (!isObject2(envelope)) return EXIT_ALLOW12;
   const cwd = envelope["cwd"];
   const pr = envelope["workspace_root"] ?? envelope["project_root"];
   const root = typeof cwd === "string" && cwd ? cwd : typeof pr === "string" && pr ? pr : ".";
-  if (!enabled3(root)) return EXIT_ALLOW8;
+  if (!enabled3(root)) return EXIT_ALLOW12;
   const { isSearch, isCodeRead } = classifyTool(envelope);
-  if (!isSearch && !isCodeRead) return EXIT_ALLOW8;
+  if (!isSearch && !isCodeRead) return EXIT_ALLOW12;
   const session = sessionId(envelope);
-  if (alreadyNudged(root, session)) return EXIT_ALLOW8;
+  if (alreadyNudged(root, session)) return EXIT_ALLOW12;
   let reason;
   try {
     reason = nudgeReason(root);
   } catch {
-    return EXIT_ALLOW8;
+    return EXIT_ALLOW12;
   }
   latch(root, session);
   process.stdout.write(`${JSON.stringify({ decision: "warn", reason })}
@@ -19499,15 +20193,15 @@ function isCliEntry10() {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL25(path40.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL29(path44.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs40.realpathSync(fileURLToPath30(import.meta.url)) === fs40.realpathSync(path40.resolve(process.argv[1]));
+    return fs44.realpathSync(fileURLToPath34(import.meta.url)) === fs44.realpathSync(path44.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (isCliEntry10()) process.exit(main29());
+if (isCliEntry10()) process.exit(main33());
 
 // src/scripts/hooks/concern_registry.ts
 var CONCERN_REGISTRY = {
@@ -19528,12 +20222,16 @@ var CONCERN_REGISTRY = {
   "src/scripts/team_review_gate_hook.ts": main20,
   "src/scripts/pr_url_reminder_hook.ts": main21,
   "src/scripts/session_canary_hook.ts": main22,
-  "src/scripts/hooks/block_no_verify.ts": main23,
-  "src/scripts/hooks/block_kernel_rule_writes.ts": main24,
-  "src/scripts/hooks/block_config_weakening.ts": main25,
-  "src/scripts/hooks/rtk_wrap_hook.ts": main26,
-  "src/scripts/hooks/design_slop_hook.ts": main28,
-  "src/scripts/hooks/code_graph_nudge_hook.ts": main29
+  "src/scripts/language_mirror_hook.ts": main23,
+  "src/scripts/git_authorization_hook.ts": main24,
+  "src/scripts/hooks/block_unauthorized_git.ts": main25,
+  "src/scripts/hooks/evidence_independence.ts": main26,
+  "src/scripts/hooks/block_no_verify.ts": main27,
+  "src/scripts/hooks/block_kernel_rule_writes.ts": main28,
+  "src/scripts/hooks/block_config_weakening.ts": main29,
+  "src/scripts/hooks/rtk_wrap_hook.ts": main30,
+  "src/scripts/hooks/design_slop_hook.ts": main32,
+  "src/scripts/hooks/code_graph_nudge_hook.ts": main33
 };
 
 // src/scripts/hooks/host_semantics.ts
@@ -19587,13 +20285,13 @@ function emitFor(platform, event, severity, reasons, legacyExit) {
 
 // src/scripts/hooks/dispatch_hook.ts
 var _IN_BUNDLE = true;
-var REPO_ROOT = path41.resolve(
-  path41.dirname(fileURLToPath31(import.meta.url)),
+var REPO_ROOT = path45.resolve(
+  path45.dirname(fileURLToPath35(import.meta.url)),
   ..._IN_BUNDLE ? ["..", ".."] : ["..", "..", ".."]
 );
-var MANIFEST_PATH = path41.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
-var EXIT_ALLOW9 = 0;
-var EXIT_BLOCK2 = 1;
+var MANIFEST_PATH = path45.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
+var EXIT_ALLOW13 = 0;
+var EXIT_BLOCK4 = 1;
 var EXIT_WARN7 = 2;
 var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "session_start",
@@ -19606,11 +20304,11 @@ var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "agent_error"
 ]);
 var _SEVERITY_BY_EXIT = {
-  [EXIT_ALLOW9]: "allow",
-  [EXIT_BLOCK2]: "block",
+  [EXIT_ALLOW13]: "allow",
+  [EXIT_BLOCK4]: "block",
   [EXIT_WARN7]: "warn"
 };
-function _isObject9(v) {
+function _isObject13(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function _severity_for(rc) {
@@ -19640,33 +20338,33 @@ function _parse_concern_stdout(stdout_text) {
   } catch {
     return { _raw_stdout: text.slice(0, 500) };
   }
-  return _isObject9(parsed) ? parsed : { _raw: parsed };
+  return _isObject13(parsed) ? parsed : { _raw: parsed };
 }
 function _load_yaml3(p) {
-  const text = fs41.readFileSync(p, "utf-8");
+  const text = fs45.readFileSync(p, "utf-8");
   const data = (0, import_yaml6.parse)(text, { version: "1.1" });
-  return _isObject9(data) ? data : {};
+  return _isObject13(data) ? data : {};
 }
 function _resolve_concerns(manifest, platform, event) {
   const platformsRaw = manifest["platforms"];
-  const platforms = _isObject9(platformsRaw) ? platformsRaw : {};
+  const platforms = _isObject13(platformsRaw) ? platformsRaw : {};
   const block = platforms[platform];
   if (!block) {
     return [];
   }
-  if (_isObject9(block) && block["fallback_only"]) {
+  if (_isObject13(block) && block["fallback_only"]) {
     return [];
   }
-  const names = _isObject9(block) ? block[event] : null;
+  const names = _isObject13(block) ? block[event] : null;
   if (!Array.isArray(names)) {
     return [];
   }
   const concernsRaw = manifest["concerns"];
-  const concerns_def = _isObject9(concernsRaw) ? concernsRaw : {};
+  const concerns_def = _isObject13(concernsRaw) ? concernsRaw : {};
   const out = [];
   for (const name of names) {
     const spec = typeof name === "string" ? concerns_def[name] : void 0;
-    if (!spec || !_isObject9(spec)) {
+    if (!spec || !_isObject13(spec)) {
       process.stderr.write(
         `dispatch_hook: unknown concern '${String(name)}' in manifest
 `
@@ -19756,7 +20454,7 @@ function _maybe_capture_payload(args, payload_text) {
   }
   try {
     const target = _expanduser2(capture_dir);
-    fs41.mkdirSync(target, { recursive: true });
+    fs45.mkdirSync(target, { recursive: true });
     let payload;
     try {
       payload = payload_text.trim() ? JSON.parse(payload_text) : {};
@@ -19773,8 +20471,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`;
-    fs41.writeFileSync(
-      path41.join(target, fname),
+    fs45.writeFileSync(
+      path45.join(target, fname),
       _py_json_dumps2(record, 2) + "\n",
       { encoding: "utf-8" }
     );
@@ -19785,7 +20483,7 @@ function _maybe_capture_payload(args, payload_text) {
 function _expanduser2(p) {
   if (p === "~" || p.startsWith("~/")) {
     const home = process.env["HOME"] || process.env["USERPROFILE"] || "";
-    return path41.join(home, p.slice(1));
+    return path45.join(home, p.slice(1));
   }
   return p;
 }
@@ -19793,7 +20491,7 @@ function _build_envelope(args, payload_text) {
   let payload;
   try {
     payload = payload_text.trim() ? JSON.parse(payload_text) : {};
-    if (!_isObject9(payload)) {
+    if (!_isObject13(payload)) {
       payload = { _raw: payload };
     }
   } catch {
@@ -19817,25 +20515,25 @@ function _resolve_tsx_invocation2(scriptPath, scriptArgs) {
   const walkUp = (start) => {
     let dir = start;
     for (; ; ) {
-      const candidate = path41.join(dir, "node_modules", ".bin", binName);
+      const candidate = path45.join(dir, "node_modules", ".bin", binName);
       if (_isFile7(candidate)) {
         return candidate;
       }
-      const parent = path41.dirname(dir);
+      const parent = path45.dirname(dir);
       if (parent === dir) {
         return null;
       }
       dir = parent;
     }
   };
-  const tsx = walkUp(path41.dirname(scriptPath)) ?? walkUp(path41.dirname(fileURLToPath31(import.meta.url)));
+  const tsx = walkUp(path45.dirname(scriptPath)) ?? walkUp(path45.dirname(fileURLToPath35(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 = path41.join(REPO_ROOT, String(concern["script"]));
+  const scriptAbs = path45.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());
@@ -19912,7 +20610,7 @@ function _run_concern(concern, envelope) {
       return _run_concern_inproc(inproc, concern, envelope);
     }
   }
-  const script = path41.join(REPO_ROOT, String(concern["script"]));
+  const script = path45.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"));
@@ -19969,7 +20667,7 @@ function _run_concern(concern, envelope) {
 }
 function _isFile7(p) {
   try {
-    return fs41.statSync(p).isFile();
+    return fs45.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -19978,23 +20676,23 @@ function _compactJsonDumps(value) {
   return JSON.stringify(value);
 }
 function _reduce(rcs) {
-  if (rcs.some((rc) => rc === EXIT_BLOCK2)) {
-    return EXIT_BLOCK2;
+  if (rcs.some((rc) => rc === EXIT_BLOCK4)) {
+    return EXIT_BLOCK4;
   }
   if (rcs.some((rc) => rc === EXIT_WARN7)) {
     return EXIT_WARN7;
   }
-  return EXIT_ALLOW9;
+  return EXIT_ALLOW13;
 }
 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 = path41.join(workspace, "agents", "runtime", "state");
+  const state_root = path45.join(workspace, "agents", "runtime", "state");
   const fb_dir = feedback_dir(state_root, session_id);
   try {
-    fs41.mkdirSync(fb_dir, { recursive: true });
+    fs45.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}
@@ -20002,7 +20700,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     return;
   }
   for (const entry of entries) {
-    const target = path41.join(fb_dir, `${entry["concern"]}.json`);
+    const target = path45.join(fb_dir, `${entry["concern"]}.json`);
     try {
       atomic_write_json(target, entry);
     } catch (exc) {
@@ -20042,7 +20740,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     })
   };
   try {
-    atomic_write_json(path41.join(fb_dir, "summary.json"), summary);
+    atomic_write_json(path45.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}
@@ -20052,17 +20750,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_BLOCK2 || e["exit_code"] === EXIT_WARN7
+    (e) => e["exit_code"] === EXIT_BLOCK4 || e["exit_code"] === EXIT_WARN7
   );
   if (tripped.length === 0) return;
   try {
     const workspace = String(envelope["workspace_root"] || process.cwd());
-    const state_dir = path41.join(workspace, "agents", "runtime", "state");
-    const target = path41.join(state_dir, "rule-trips.json");
-    fs41.mkdirSync(state_dir, { recursive: true });
+    const state_dir = path45.join(workspace, "agents", "runtime", "state");
+    const target = path45.join(state_dir, "rule-trips.json");
+    fs45.mkdirSync(state_dir, { recursive: true });
     let doc = { schema_version: 1, concerns: {} };
     try {
-      const parsed = JSON.parse(fs41.readFileSync(target, "utf-8"));
+      const parsed = JSON.parse(fs45.readFileSync(target, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) doc = parsed;
     } catch {
     }
@@ -20072,7 +20770,7 @@ function _record_rule_trips(envelope, entries) {
       const name = String(e["concern"]);
       const prev = concerns[name] ?? { block: 0, warn: 0 };
       concerns[name] = {
-        block: (Number(prev["block"]) || 0) + (e["exit_code"] === EXIT_BLOCK2 ? 1 : 0),
+        block: (Number(prev["block"]) || 0) + (e["exit_code"] === EXIT_BLOCK4 ? 1 : 0),
         warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN7 ? 1 : 0),
         last_trip: today
       };
@@ -20161,7 +20859,7 @@ function _parse_args(argv) {
   }
   return args;
 }
-function main30(argv) {
+function main34(argv) {
   const args = _parse_args(argv ?? process.argv.slice(2));
   if (args.project_dir) {
     const project_dir = _expanduser2(args.project_dir);
@@ -20179,13 +20877,13 @@ function main30(argv) {
       `dispatch_hook: unknown event '${args.event}'; allowed: ${_sortedRepr(EVENT_VOCABULARY)}
 `
     );
-    return EXIT_ALLOW9;
+    return EXIT_ALLOW13;
   }
   const manifest_path = args.manifest;
-  if (!fs41.existsSync(manifest_path)) {
+  if (!fs45.existsSync(manifest_path)) {
     process.stderr.write(`dispatch_hook: manifest missing at ${manifest_path}
 `);
-    return EXIT_ALLOW9;
+    return EXIT_ALLOW13;
   }
   const manifest = _load_yaml3(manifest_path);
   if (args.min_version) {
@@ -20207,10 +20905,10 @@ function main30(argv) {
       concerns: concerns.map((c) => c["name"])
     };
     process.stdout.write(_py_json_dumps2(plan, 2) + "\n");
-    return EXIT_ALLOW9;
+    return EXIT_ALLOW13;
   }
   if (concerns.length === 0) {
-    return EXIT_ALLOW9;
+    return EXIT_ALLOW13;
   }
   const envelope = _build_envelope(args, payload_text);
   const session_id = _resolve_session_id(envelope);
@@ -20226,15 +20924,15 @@ function main30(argv) {
     const raw_rc = rc;
     if (rc >= 3) {
       if (!concern["fail_closed"]) {
-        rc = EXIT_ALLOW9;
+        rc = EXIT_ALLOW13;
       } else {
-        rc = EXIT_BLOCK2;
+        rc = EXIT_BLOCK4;
       }
       if (stderr_text) {
         process.stderr.write(stderr_text);
       }
     }
-    if (rc === EXIT_BLOCK2 && _is_advisory(concern)) {
+    if (rc === EXIT_BLOCK4 && _is_advisory(concern)) {
       process.stderr.write(
         `dispatch_hook: concern '${String(concern["name"])}' is declared severity: advisory but returned BLOCK \u2014 downgraded to warn.
 `
@@ -20247,7 +20945,7 @@ function main30(argv) {
     if (stated) {
       concern_messages.push({ rc, text: stated });
     }
-    if (args.event === "session_start" && rc === EXIT_ALLOW9 && typeof reply["context"] === "string" && reply["context"].trim()) {
+    if (args.event === "session_start" && rc === EXIT_ALLOW13 && typeof reply["context"] === "string" && reply["context"].trim()) {
       context_blocks.push(reply["context"].trim());
     }
     feedback_entries.push({
@@ -20266,7 +20964,7 @@ function main30(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_ALLOW9) {
+  if (context_blocks.length > 0 && final_rc === EXIT_ALLOW13) {
     process.stdout.write(context_blocks.join("\n\n") + "\n");
   }
   const decidingReasons = concern_messages.filter((m) => m.rc === final_rc).map((m) => m.text);
@@ -20287,7 +20985,7 @@ function main30(argv) {
 }
 function _isDir4(p) {
   try {
-    return fs41.statSync(p).isDirectory();
+    return fs45.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -20298,41 +20996,41 @@ function _sortedRepr(s) {
 }
 function _readStdin14() {
   try {
-    return fs41.readFileSync(0, "utf-8");
+    return fs45.readFileSync(0, "utf-8");
   } catch {
     return "";
   }
 }
-function _isCliEntry24() {
+function _isCliEntry28() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL26(path41.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL30(path45.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs41.realpathSync(fileURLToPath31(import.meta.url));
-    const argv = fs41.realpathSync(path41.resolve(process.argv[1]));
+    const here = fs45.realpathSync(fileURLToPath35(import.meta.url));
+    const argv = fs45.realpathSync(path45.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var isCliEntry11 = _isCliEntry24();
+var isCliEntry11 = _isCliEntry28();
 if (isCliEntry11) {
-  process.exit(main30(process.argv.slice(2)));
+  process.exit(main34(process.argv.slice(2)));
 }
 
 // src/scripts/hooks/dispatch_entry.ts
-var _selfPath = fileURLToPath32(import.meta.url);
-var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path42.resolve(process.argv[1]) === path42.resolve(_selfPath);
+var _selfPath = fileURLToPath36(import.meta.url);
+var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path46.resolve(process.argv[1]) === path46.resolve(_selfPath);
 if (_invokedDirectly2) {
-  process.exitCode = main30(process.argv.slice(2));
+  process.exitCode = main34(process.argv.slice(2));
 }
 export {
-  main30 as main
+  main34 as main
 };