@event4u/agent-config 9.24.0 → 9.26.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,70 @@ 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 false;
+  }
+  const lines = text.split("\n").filter((l) => l.trim());
+  return lines.every((l) => _VACUOUS_PATTERNS.some((re) => re.test(l)));
+}
+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);
+  if (rows) {
+    return rows.length;
+  }
+  if (/\bno checks reported\b/i.test(output)) {
+    return null;
+  }
+  if (/^\S+\s+(pass|fail|skipping|successful|failing)\b/im.test(output)) {
+    return 0;
+  }
+  return 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 +15202,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();
@@ -15765,15 +15844,53 @@ if (_isCliEntry11()) {
 import fs22 from "node:fs";
 import path21 from "node:path";
 import { fileURLToPath as fileURLToPath16, pathToFileURL as pathToFileURL12 } from "node:url";
+
+// src/shared/settingsClasses.ts
+function isConservativeDefault(value) {
+  if (value === null || value === false || value === "" || value === 0) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
+
+// src/shared/settingsConsent.ts
+var HUMAN_SOURCES = ["jit-answer", "gui", "manual"];
+function consentVerdict(query) {
+  if (query.cls !== "B") {
+    return "not-a-consent-key";
+  }
+  if (isConservativeDefault(query.value)) {
+    return "withheld-default";
+  }
+  if (query.handEdited === true) {
+    return "granted";
+  }
+  if (query.source === void 0) {
+    return "withheld-unrecorded";
+  }
+  if (!HUMAN_SOURCES.includes(query.source)) {
+    return "withheld-machine-inferred";
+  }
+  return "granted";
+}
+
+// src/scripts/memory_learn_hook.ts
 var SETTINGS_FILE4 = ".agent-settings.yml";
 var BUDGET_MS = 2e3;
-function enabled(root) {
+var LEARN_KEY_CLASS = "B";
+function readLearnValue(root) {
   const p = path21.join(root, SETTINGS_FILE4);
   let text;
   try {
     text = fs22.readFileSync(p, "utf8");
   } catch {
-    return false;
+    return void 0;
   }
   let inMemory = false;
   for (const rawLine of text.split("\n")) {
@@ -15791,7 +15908,17 @@ function enabled(root) {
       if (m) return m[1] === "true";
     }
   }
-  return false;
+  return void 0;
+}
+function learnConsent(root) {
+  return consentVerdict({
+    cls: LEARN_KEY_CLASS,
+    value: readLearnValue(root) ?? false,
+    handEdited: true
+  });
+}
+function enabled(root) {
+  return learnConsent(root) === "granted";
 }
 function runLearn(root, nowIso, budgetMs = BUDGET_MS) {
   const started = Date.now();
@@ -17130,6 +17257,10 @@ var _PR_URL = /https?:\/\/github\.com\/[^\s"'`<>]+\/pull\/\d+/i;
 function _isObject4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
+function _unwrap(envelope) {
+  const inner = envelope["payload"];
+  return _isObject4(inner) ? inner : envelope;
+}
 function _extractCommand(payload) {
   const toolRaw = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
   const tool = typeof toolRaw === "string" ? toolRaw : null;
@@ -17182,11 +17313,12 @@ function main21() {
   if (!_isObject4(envelope)) {
     return EXIT_ALLOW3;
   }
-  const [tool, command] = _extractCommand(envelope);
+  const inner = _unwrap(envelope);
+  const [tool, command] = _extractCommand(inner);
   if (!_isPrCreate(tool, command)) {
     return EXIT_ALLOW3;
   }
-  const match = _PR_URL.exec(_toolOutput(envelope));
+  const match = _PR_URL.exec(_toolOutput(inner));
   if (match === null) {
     return EXIT_ALLOW3;
   }
@@ -17398,194 +17530,1012 @@ 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 _SHELL_SEPARATORS = /* @__PURE__ */ new Set(["&&", "||", ";", "|"]);
-var _NO_VERIFY_FLAGS = /* @__PURE__ */ new Set(["--no-verify"]);
-var _NO_VERIFY_SHORT = /* @__PURE__ */ new Set(["-n"]);
-var _HOOKS_PATH_RE = /^core\.hooksPath\s*=/i;
-var _HOOKS_PATH_KEY_RE = /^core\.hooksPath$/i;
-var _GIT_GLOBAL_OPTS_WITH_VALUE = /* @__PURE__ */ new Set([
-  "-C",
-  "-c",
-  "--config",
-  "--git-dir",
-  "--work-tree",
-  "--namespace",
-  "--exec-path",
-  "--super-prefix"
-]);
-var _CONFIG_READ_OR_RESTORE = /* @__PURE__ */ new Set([
-  "--get",
-  "--get-all",
-  "--get-regexp",
-  "--get-urlmatch",
-  "--list",
-  "-l",
-  "--unset",
-  "--unset-all"
-]);
-var ShlexError = class extends Error {
-};
-function shlexSplit(s) {
-  const whitespace = " 	\r\n\f\v";
-  const quotes = `'"`;
-  const escape = "\\";
-  const escapedquotes = '"';
-  const tokens = [];
-  let token = null;
-  let i = 0;
-  const n = s.length;
-  let state = "ws";
-  const push = (ch) => {
-    token = (token ?? "") + ch;
-  };
-  while (i < n) {
-    const c = s[i];
-    if (state === "ws") {
-      if (whitespace.includes(c)) {
-        i += 1;
-        continue;
-      }
-      state = "word";
-      token = "";
-    }
-    if (whitespace.includes(c)) {
-      tokens.push(token);
-      token = null;
-      state = "ws";
-      i += 1;
+var EXIT_ALLOW5 = 0;
+var EXIT_WARN3 = 2;
+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)\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 instructionText(prompt) {
+  const OUTPUT_HEAD = /^\s*(To\s+\S+|remote:|error:|fatal:|hint:|warning:|npm ERR!|Error:|Traceback|Exception|[A-Za-z]*Error\b|at\s+\S+:\d+|\s{4,}\S|[-+]{3}\s|@@\s|\$\s|>\s|\||\d+\s*\|)/i;
+  const kept = [];
+  let inPaste = false;
+  for (const line of prompt.replace(/```[\s\S]*?```/g, "\n\n").split("\n")) {
+    if (!line.trim()) {
+      inPaste = false;
+      kept.push(line);
       continue;
     }
-    if (quotes.includes(c)) {
-      const quote = c;
-      i += 1;
-      let closed = false;
-      while (i < n) {
-        const qc = s[i];
-        if (qc === quote) {
-          closed = true;
-          i += 1;
-          break;
-        }
-        if (escape.includes(qc) && escapedquotes.includes(quote)) {
-          const nxt = i + 1 < n ? s[i + 1] : null;
-          if (nxt !== null && (nxt === escape || nxt === quote)) {
-            push(nxt);
-            i += 2;
-            continue;
-          }
-          push(qc);
-          i += 1;
-          continue;
-        }
-        push(qc);
-        i += 1;
-      }
-      if (!closed) {
-        throw new ShlexError("No closing quotation");
-      }
+    if (OUTPUT_HEAD.test(line)) {
+      inPaste = true;
       continue;
     }
-    if (escape.includes(c)) {
-      const nxt = i + 1 < n ? s[i + 1] : null;
-      if (nxt === null) {
-        throw new ShlexError("No escaped character");
-      }
-      push(nxt);
-      i += 2;
+    if (inPaste) {
       continue;
     }
-    push(c);
-    i += 1;
+    kept.push(line);
   }
-  if (token !== null) {
-    tokens.push(token);
-  }
-  return tokens;
+  return kept.join("\n");
 }
-function _is_env_assignment(token) {
-  return /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
+function classify(prompt) {
+  const text = instructionText(prompt);
+  const de = (text.match(DE_MARKERS) ?? []).length;
+  const en = (text.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 };
 }
-function _split_subcommands(tokens) {
-  const groups = [];
-  let current = [];
-  for (const tok of tokens) {
-    if (_SHELL_SEPARATORS.has(tok)) {
-      if (current.length) {
-        groups.push(current);
-      }
-      current = [];
-    } else {
-      current.push(tok);
+var LANGUAGE_NAME = {
+  de: "German (Deutsch)",
+  en: "English"
+};
+var LOCALE_ENV_KEYS = ["LC_ALL", "LC_MESSAGES", "LANG", "LANGUAGE"];
+function systemLocaleVerdict(env = process.env) {
+  for (const key of LOCALE_ENV_KEYS) {
+    const raw = (env[key] ?? "").trim();
+    if (!raw) {
+      continue;
     }
+    const first = raw.split(":")[0] ?? "";
+    const primary = (first.split(/[._@-]/)[0] ?? "").toLowerCase();
+    if (primary === "c" || primary === "posix" || !primary) {
+      continue;
+    }
+    if (primary === "de") {
+      return "de";
+    }
+    if (primary === "en") {
+      return "en";
+    }
+    return "und";
   }
-  if (current.length) {
-    groups.push(current);
+  return "und";
+}
+function noticeText(language, source) {
+  const name = LANGUAGE_NAME[language];
+  if (source === "system-locale") {
+    return `Reply language for this turn: ${name} \u2014 the prompt carried no language markers, so this fell back to the system locale. Write in another language and the next turn follows the prompt instead.`;
   }
-  return groups;
+  return `Reply language for this turn: ${name}.`;
 }
-function _git_base(tokens) {
-  let i = 0;
-  while (i < tokens.length && _is_env_assignment(tokens[i])) {
-    i += 1;
+function pinText(language, source = "prompt") {
+  const name = LANGUAGE_NAME[language];
+  if (source === "system-locale") {
+    return `<language-pin>
+No language markers were found in this turn's prompt and no language was pinned yet, so the mirror target falls back to the environment's locale: ${name}. Use it for EVERY user-visible token this turn.
+
+This is the WEAKER of the two provenances \u2014 it reflects the machine, not the user's own words. The first prompt that carries real markers replaces it. Do not treat it as a standing preference, and do not argue with the user about it if they write in something else.
+</language-pin>`;
   }
-  if (i < tokens.length && tokens[i] === "git") {
-    return tokens.slice(i);
+  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 {};
   }
-  return null;
 }
-function _is_config_hookspath_write(git_tokens) {
-  const rest = git_tokens.slice(1);
-  let subIdx = -1;
-  for (let k = 0; k < rest.length; k += 1) {
-    const tok = rest[k];
-    if (!tok.startsWith("-")) {
-      subIdx = k;
-      break;
+function nextState(previous, classification, prompt_chars, session_id, now, locale = "und") {
+  if (classification.language === "und") {
+    if (previous.language === "de" || previous.language === "en") {
+      return null;
     }
-    if (_GIT_GLOBAL_OPTS_WITH_VALUE.has(tok)) {
-      k += 1;
+    if (locale === "und") {
+      return null;
     }
+    return {
+      language: locale,
+      source: "system-locale",
+      detected_at: now,
+      prompt_chars,
+      de_markers: classification.de_markers,
+      en_markers: classification.en_markers,
+      session_id
+    };
   }
-  if (subIdx === -1 || rest[subIdx] !== "config") {
-    return [false, ""];
-  }
-  const args = rest.slice(subIdx + 1);
-  if (args.some((t) => _CONFIG_READ_OR_RESTORE.has(t))) {
-    return [false, ""];
-  }
-  for (let k = 0; k < args.length; k += 1) {
-    const tok = args[k];
-    if (_HOOKS_PATH_RE.test(tok)) {
-      return [
-        true,
-        `'git config ${tok}' disables git hooks via hooksPath (git-history-discipline)`
-      ];
-    }
-    if (!_HOOKS_PATH_KEY_RE.test(tok)) {
-      continue;
-    }
-    const next = args.slice(k + 1).find((t) => !t.startsWith("-"));
-    if (next !== void 0) {
-      return [
-        true,
-        `'git config ${tok} ${next}' disables git hooks via hooksPath (git-history-discipline)`
-      ];
+  return {
+    language: classification.language,
+    source: "prompt",
+    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 [false, ""];
   }
-  return [false, ""];
+  return "";
 }
-function _is_blocked(git_tokens) {
-  const [cfgBlocked, cfgReason] = _is_config_hookspath_write(git_tokens);
-  if (cfgBlocked) {
-    return [cfgBlocked, cfgReason];
+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;
+    }
   }
-  let i = 1;
+  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(),
+    // Injectable so the suite can pin a locale instead of inheriting the
+    // machine's — a test whose verdict depends on the developer's `LANG` is a
+    // test that passes here and fails in CI for reasons unrelated to the diff.
+    systemLocaleVerdict(options.env ?? process.env)
+  );
+  const effective = next?.language ?? previous.language;
+  const effectiveSource = next?.source ?? (previous.source === "system-locale" ? "system-locale" : "prompt");
+  if (next) {
+    try {
+      atomic_write_json(target, next);
+    } catch {
+    }
+  }
+  if (effective === "de" || effective === "en") {
+    process.stdout.write(
+      `${JSON.stringify({ decision: "warn", reason: noticeText(effective, effectiveSource), additional_context: pinText(effective, effectiveSource) })}
+`
+    );
+    return EXIT_WARN3;
+  }
+  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|te|ten)?|committe|einchecken)\b/i },
+  { op: "push", re: /\b(push(e|en|t)?|hochladen|hochschieben|raufschieben)\b/i },
+  { op: "branch", re: /\b(branch|feature-branch|zweig)\b/i },
+  // A creation verb is required — "schau dir den PR an" is not "open a PR".
+  {
+    op: "pr-create",
+    re: /\b(erstell(e|en)?|mach(e|en)?|leg(e|en)?\s+an|(er)?(ö|oe)ffne|open|create|raise|aufmachen)\b[^.\n]{0,30}\b(pr|pull[- ]request)\b|\b(pr|pull[- ]request)\b[^.\n]{0,20}\b(erstellen|aufmachen|anlegen|(er)?(ö|oe)ffnen)\b/i
+  },
+  // `merge` as an ACTION, never as the noun in "merge conflict" / "merge commit".
+  { op: "pr-merge", re: /\b(merge|merg(e|en|st|t)|zusammenf(ü|ue)hren|reinmergen)\b(?!\s*[- ]?(conflict|konflikt|commit|base|queue|state|status))/i },
+  // A tag is an ACTION here — bare "Tag" is the German word for day, and
+  // "Version" is an ordinary noun. Both authorized a BLOCK op before this.
+  { op: "tag", re: /\b(tagge(n|st)?|tag\s+(setzen|anlegen|erstellen)|git\s+tag|--tags|--follow-tags)\b/i },
+  // "die release notes sind falsch" is a noun phrase, not an authorization.
+  {
+    op: "release",
+    re: /\b(releasen?|ver(ö|oe)ffentlich(e|en))\b(?!\s*[- ]?(notes?|branch|candidate|pr\b|datum|date|zweig))/i
+  },
+  { op: "publish", re: /\b(publish(e|en)?|publiziere[n]?)\b/i }
+];
+var OUTPUT_LINE = /^\s*(To\s+\S+|remote:|error:|fatal:|hint:|warning:|!\s|\?\?\s|\s*\^|[-+]{3}\s|@@\s|\$\s|>\s|\d+\s+(pass|fail)|npm ERR!|Error:|Traceback|at\s+\S+:\d+)/i;
+function isInterrogative(prose) {
+  const t = prose.trim();
+  if (!t) {
+    return false;
+  }
+  const hasImperative = /\b(mach|mache|bitte|leg|lege|erstell|erstelle|f(ü|ue)hr|f(ü|ue)hre|setz|setze|starte|los|jetzt|go ahead|do it|ja[,.]?\s|ok[,.]?\s)\b/i.test(
+    t
+  );
+  if (hasImperative) {
+    return false;
+  }
+  return /\?\s*$/.test(t) || /^(was|wie|warum|wieso|weshalb|wann|wer|welche[rs]?|wo|ist|sind|kann|kannst|k(ö|oe)nnen|soll|sollen|darf|d(ü|ue)rfen|why|what|how|when|which|who|is|are|can|could|should|does|do)\b/i.test(
+    t
+  );
+}
+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 = {};
+  const instruction = prose.split("\n").filter((l) => !OUTPUT_LINE.test(l)).join("\n");
+  for (const { op, re } of isInterrogative(instruction) ? [] : PHRASES) {
+    const m = re.exec(instruction);
+    if (m) {
+      authorized.add(op);
+      evidence[op] = `prose: "${m[0]}"`;
+    }
+  }
+  for (const fence of fences) {
+    if (fence.split("\n").some((l) => OUTPUT_LINE.test(l))) {
+      continue;
+    }
+    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 = 1;
+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 G = "(?:-[A-Za-z-]+(?:=\\S+)?(?:\\s+\\S+)?\\s+)*";
+var COMMAND_OPS = [
+  { op: "publish", re: new RegExp(`\\b(npm|pnpm|yarn)\\s+${G}publish\\b`, "i") },
+  { op: "release", re: /\bgh\s+release\s+create\b|\bgh\s+api\b[^\n]*\/releases\b/i },
+  {
+    op: "tag",
+    re: new RegExp(
+      `\\bgit\\s+${G}push\\b[^\\n;|&]*(--tags|--follow-tags|refs\\/tags\\/)`,
+      "i"
+    )
+  },
+  { op: "pr-merge", re: /\bgh\s+pr\s+merge\b|\bgh\s+api\b[^\n]*\/pulls\/\d+\/merge\b/i },
+  { op: "pr-create", re: /\bgh\s+pr\s+create\b|\bgh\s+api\b[^\n]*-X\s+POST[^\n]*\/pulls\b/i },
+  { op: "push", re: new RegExp(`\\bgit\\s+${G}push\\b`, "i") },
+  { op: "commit", re: new RegExp(`\\bgit\\s+${G}commit\\b`, "i") },
+  { op: "branch", re: new RegExp(`\\bgit\\s+${G}(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 invokedSegments(command, depth = 0) {
+  if (depth > 3) {
+    return [];
+  }
+  const out = [];
+  const withoutHeredocs = command.replace(
+    /<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1[\s\S]*?^\s*\2\s*$/gm,
+    "<<HEREDOC"
+  );
+  for (const raw of withoutHeredocs.split(/\n|;|&&|\|\||\||&/)) {
+    let seg = raw.trim();
+    if (!seg) {
+      continue;
+    }
+    seg = seg.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S*)\s+)+/, "");
+    const wrapped = /^(?:\S*\/)?(?:ba|z|k)?sh\s+-[a-z]*c\s+(?:"([^"]*)"|'([^']*)'|(\S+))/.exec(seg);
+    if (wrapped) {
+      out.push(...invokedSegments(wrapped[1] ?? wrapped[2] ?? wrapped[3] ?? "", depth + 1));
+      continue;
+    }
+    out.push(seg);
+  }
+  return out;
+}
+function commandOp(command) {
+  let found = null;
+  for (const seg of invokedSegments(command)) {
+    if (!/^(?:\S*\/)?(git|gh|npm|pnpm|yarn)\b/.test(seg)) {
+      continue;
+    }
+    for (const { op, re } of COMMAND_OPS) {
+      if (re.test(seg)) {
+        if (BLOCK_OPS.has(op)) {
+          return op;
+        }
+        found ??= op;
+        break;
+      }
+    }
+  }
+  return found;
+}
+var LEDGER_MAX_AGE_MS = 30 * 60 * 1e3;
+function _loadLedger(consumer_root, session_id, now) {
+  try {
+    const raw = fs35.readFileSync(path35.join(consumer_root, STATE_FILE6), "utf8");
+    const decoded = JSON.parse(raw);
+    if (_isObject8(decoded) && Array.isArray(decoded["authorized"])) {
+      const ledgerSession = typeof decoded["session_id"] === "string" ? decoded["session_id"] : "";
+      if (session_id && ledgerSession && ledgerSession !== session_id) {
+        return { authorized: /* @__PURE__ */ new Set(), present: false };
+      }
+      const at = Date.parse(String(decoded["detected_at"] ?? ""));
+      if (Number.isFinite(at) && now - at > LEDGER_MAX_AGE_MS) {
+        return { authorized: /* @__PURE__ */ new Set(), present: false };
+      }
+      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 session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
+  const decision = decide(
+    extractCommand(envelope),
+    _loadLedger(options.consumer_root, session_id, Date.now())
+  );
+  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 = 1;
+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)|pr(ü|ue)f(e|ung)?|begutachte|gutachten|bewerte|(gegen)?check(e)?|durchsicht|review(e|iere))\b/i;
+var PRELOADED_VERDICT_RE = [
+  // German — the operator writes German, and an English-only list meant no
+  // German dispatch was ever screened at all.
+  /\bich erwarte (hier )?(keine|nichts)\b/i,
+  /\b(du )?(wirst|solltest) (hier )?nichts finden\b/i,
+  /\bbest(ä|ae)tige (nur|kurz)\b/i,
+  /\b(ist|sollte) (wahrscheinlich|vermutlich|sicher) (sauber|korrekt|in ordnung|fine)\b/i,
+  /\bkeine findings? (erwartet|zu erwarten)\b/i,
+  // English paraphrases of the audited construct.
+  /\bi am confident there is nothing\b/i,
+  /\ba clean pass is the likely\b/i,
+  /\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 _ledgerStamp(consumer_root) {
+  try {
+    const raw = fs36.readFileSync(
+      path36.join(consumer_root, "agents", "state", "git-authorization.json"),
+      "utf8"
+    );
+    const d = JSON.parse(raw);
+    return typeof d["detected_at"] === "string" ? d["detected_at"] : "";
+  } catch {
+    return "";
+  }
+}
+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 = `${session_id}:${_ledgerStamp(options.consumer_root)}`;
+  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"]);
+var _HOOKS_PATH_RE = /^core\.hooksPath\s*=/i;
+var _HOOKS_PATH_KEY_RE = /^core\.hooksPath$/i;
+var _GIT_GLOBAL_OPTS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-C",
+  "-c",
+  "--config",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--exec-path",
+  "--super-prefix"
+]);
+var _CONFIG_READ_OR_RESTORE = /* @__PURE__ */ new Set([
+  "--get",
+  "--get-all",
+  "--get-regexp",
+  "--get-urlmatch",
+  "--list",
+  "-l",
+  "--unset",
+  "--unset-all"
+]);
+var ShlexError = class extends Error {
+};
+function shlexSplit(s) {
+  const whitespace = " 	\r\n\f\v";
+  const quotes = `'"`;
+  const escape = "\\";
+  const escapedquotes = '"';
+  const tokens = [];
+  let token = null;
+  let i = 0;
+  const n = s.length;
+  let state = "ws";
+  const push = (ch) => {
+    token = (token ?? "") + ch;
+  };
+  while (i < n) {
+    const c = s[i];
+    if (state === "ws") {
+      if (whitespace.includes(c)) {
+        i += 1;
+        continue;
+      }
+      state = "word";
+      token = "";
+    }
+    if (whitespace.includes(c)) {
+      tokens.push(token);
+      token = null;
+      state = "ws";
+      i += 1;
+      continue;
+    }
+    if (quotes.includes(c)) {
+      const quote = c;
+      i += 1;
+      let closed = false;
+      while (i < n) {
+        const qc = s[i];
+        if (qc === quote) {
+          closed = true;
+          i += 1;
+          break;
+        }
+        if (escape.includes(qc) && escapedquotes.includes(quote)) {
+          const nxt = i + 1 < n ? s[i + 1] : null;
+          if (nxt !== null && (nxt === escape || nxt === quote)) {
+            push(nxt);
+            i += 2;
+            continue;
+          }
+          push(qc);
+          i += 1;
+          continue;
+        }
+        push(qc);
+        i += 1;
+      }
+      if (!closed) {
+        throw new ShlexError("No closing quotation");
+      }
+      continue;
+    }
+    if (escape.includes(c)) {
+      const nxt = i + 1 < n ? s[i + 1] : null;
+      if (nxt === null) {
+        throw new ShlexError("No escaped character");
+      }
+      push(nxt);
+      i += 2;
+      continue;
+    }
+    push(c);
+    i += 1;
+  }
+  if (token !== null) {
+    tokens.push(token);
+  }
+  return tokens;
+}
+function _is_env_assignment(token) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
+}
+function _split_subcommands(tokens) {
+  const groups = [];
+  let current = [];
+  for (const tok of tokens) {
+    if (_SHELL_SEPARATORS.has(tok)) {
+      if (current.length) {
+        groups.push(current);
+      }
+      current = [];
+    } else {
+      current.push(tok);
+    }
+  }
+  if (current.length) {
+    groups.push(current);
+  }
+  return groups;
+}
+function _git_base(tokens) {
+  let i = 0;
+  while (i < tokens.length && _is_env_assignment(tokens[i])) {
+    i += 1;
+  }
+  if (i < tokens.length && tokens[i] === "git") {
+    return tokens.slice(i);
+  }
+  return null;
+}
+function _is_config_hookspath_write(git_tokens) {
+  const rest = git_tokens.slice(1);
+  let subIdx = -1;
+  for (let k = 0; k < rest.length; k += 1) {
+    const tok = rest[k];
+    if (!tok.startsWith("-")) {
+      subIdx = k;
+      break;
+    }
+    if (_GIT_GLOBAL_OPTS_WITH_VALUE.has(tok)) {
+      k += 1;
+    }
+  }
+  if (subIdx === -1 || rest[subIdx] !== "config") {
+    return [false, ""];
+  }
+  const args = rest.slice(subIdx + 1);
+  if (args.some((t) => _CONFIG_READ_OR_RESTORE.has(t))) {
+    return [false, ""];
+  }
+  for (let k = 0; k < args.length; k += 1) {
+    const tok = args[k];
+    if (_HOOKS_PATH_RE.test(tok)) {
+      return [
+        true,
+        `'git config ${tok}' disables git hooks via hooksPath (git-history-discipline)`
+      ];
+    }
+    if (!_HOOKS_PATH_KEY_RE.test(tok)) {
+      continue;
+    }
+    const next = args.slice(k + 1).find((t) => !t.startsWith("-"));
+    if (next !== void 0) {
+      return [
+        true,
+        `'git config ${tok} ${next}' disables git hooks via hooksPath (git-history-discipline)`
+      ];
+    }
+    return [false, ""];
+  }
+  return [false, ""];
+}
+function _is_blocked(git_tokens) {
+  const [cfgBlocked, cfgReason] = _is_config_hookspath_write(git_tokens);
+  if (cfgBlocked) {
+    return [cfgBlocked, cfgReason];
+  }
+  let i = 1;
   while (i < git_tokens.length) {
     const tok = git_tokens[i];
     if (_NO_VERIFY_FLAGS.has(tok)) {
@@ -17641,7 +18591,7 @@ function _check_command(cmd) {
       if (/\bgit\b/.test(cmd)) {
         return [
           true,
-          "command parse failed (shlex) on a git-containing command \u2014 fail-closed (git-history-discipline)"
+          "command parse failed (shlex) on a git-containing command \u2014 fail-closed (git-history-discipline). \nMost common cause: an apostrophe or backtick inside a heredoc commit message in the SAME compound command as `git`. \nFix: write the message to a file and use `git commit -F <file>` \u2014 do not retry the heredoc."
         ];
       }
       return [false, ""];
@@ -17725,7 +18675,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 +18713,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 +18763,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 +18776,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 +18855,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 +18910,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 +18924,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 +18954,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;
-var EXIT_WARN3 = 2;
+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_WARN4 = 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 +19040,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 +19066,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 +19081,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 +19104,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 +19129,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,47 +19140,47 @@ 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 })}
 `);
-      return EXIT_WARN3;
+      return EXIT_WARN4;
     }
   }
-  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,8 +19292,8 @@ function detectRtkCached(options = {}) {
 
 // src/scripts/hooks/rtk_wrap_hook.ts
 var SETTINGS_FILE6 = ".agent-settings.yml";
-var EXIT_ALLOW6 = 0;
-var EXIT_WARN4 = 2;
+var EXIT_ALLOW10 = 0;
+var EXIT_WARN5 = 2;
 var _RTK_PROGRAMS = /* @__PURE__ */ new Set([
   "git",
   "phpstan",
@@ -18368,19 +19318,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 +19360,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 +19377,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 +19414,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;
+  return EXIT_WARN5;
 }
-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 +19857,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 +19884,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 +19941,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 +19971,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 +20013,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,23 +20048,23 @@ 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_WARN5 = 2;
+var EXIT_ALLOW11 = 0;
+var EXIT_WARN6 = 2;
 var DEGRADE_AFTER = 3;
 var UI_EXT = /\.(html|htm|css|scss|sass|less|vue|svelte|astro|jsx|tsx)$/i;
 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;
   }
@@ -19139,7 +20089,12 @@ function enabled2(root) {
   }
   return false;
 }
-function extract(envelope) {
+function _unwrap2(envelope) {
+  const inner = envelope["payload"];
+  return isObject(inner) ? inner : envelope;
+}
+function extract(outer) {
+  const envelope = _unwrap2(outer);
   const ti = envelope["tool_input"] ?? envelope["toolInput"] ?? envelope["input"];
   if (!isObject(ti)) return null;
   const fileVal = ti["file_path"] ?? ti["path"] ?? ti["filePath"];
@@ -19151,11 +20106,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 +20120,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 +20154,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 +20166,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;
+  return EXIT_WARN6;
 }
-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 +20283,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 +20291,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 +20302,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 +20331,18 @@ function pickSource(verdicts) {
 
 // src/scripts/hooks/code_graph_nudge_hook.ts
 var SETTINGS_FILE8 = ".agent-settings.yml";
-var EXIT_ALLOW8 = 0;
-var EXIT_WARN6 = 2;
+var EXIT_ALLOW12 = 0;
+var EXIT_WARN7 = 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 +20385,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 +20400,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,48 +20421,48 @@ 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 })}
 `);
-  return EXIT_WARN6;
+  return EXIT_WARN7;
 }
 function isCliEntry10() {
   if (true) {
     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 +20483,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,14 +20546,14 @@ 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 EXIT_WARN7 = 2;
+var MANIFEST_PATH = path45.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
+var EXIT_ALLOW13 = 0;
+var EXIT_BLOCK4 = 1;
+var EXIT_WARN8 = 2;
 var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "session_start",
   "session_end",
@@ -19606,11 +20565,11 @@ var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "agent_error"
 ]);
 var _SEVERITY_BY_EXIT = {
-  [EXIT_ALLOW9]: "allow",
-  [EXIT_BLOCK2]: "block",
-  [EXIT_WARN7]: "warn"
+  [EXIT_ALLOW13]: "allow",
+  [EXIT_BLOCK4]: "block",
+  [EXIT_WARN8]: "warn"
 };
-function _isObject9(v) {
+function _isObject13(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function _severity_for(rc) {
@@ -19640,33 +20599,58 @@ 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 _payload_tool_name(envelope) {
+  const payload = envelope["payload"];
+  if (!_isObject13(payload)) {
+    return "";
+  }
+  const raw = payload["tool_name"];
+  return typeof raw === "string" ? raw : "";
+}
+function _concern_matches_tool(concern, tool_name) {
+  const raw = concern["tools"];
+  if (raw === void 0 || raw === null) {
+    return true;
+  }
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return true;
+  }
+  const names = raw.filter((t) => typeof t === "string");
+  if (names.length === 0 || names.includes("*")) {
+    return true;
+  }
+  if (tool_name === "") {
+    return true;
+  }
+  return names.includes(tool_name);
 }
 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 +20740,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 +20757,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 +20769,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 +20777,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 +20801,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 +20896,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 +20953,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 +20962,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;
+  if (rcs.some((rc) => rc === EXIT_WARN8)) {
+    return EXIT_WARN8;
   }
-  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 +20986,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 +21026,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 +21036,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_WARN8
   );
   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,8 +21056,8 @@ 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),
-        warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN7 ? 1 : 0),
+        block: (Number(prev["block"]) || 0) + (e["exit_code"] === EXIT_BLOCK4 ? 1 : 0),
+        warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN8 ? 1 : 0),
         last_trip: today
       };
     }
@@ -20161,7 +21145,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 +21163,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 +21191,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);
@@ -20219,35 +21203,41 @@ function main30(argv) {
   const feedback_entries = [];
   const context_blocks = [];
   const concern_messages = [];
+  const tool_name = _payload_tool_name(envelope);
   for (const concern of concerns) {
+    if (!_concern_matches_tool(concern, tool_name)) {
+      continue;
+    }
     const concern_started = _now_iso3();
     const { rc: rawRcResult, stderr: stderr_text, stdout: stdout_text, duration_ms } = _run_concern(concern, envelope);
     let rc = rawRcResult;
     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.
 `
       );
-      rc = EXIT_WARN7;
+      rc = EXIT_WARN8;
     }
     rcs.push(rc);
     const reply = _parse_concern_stdout(stdout_text);
     const stated = typeof reply["reason"] === "string" && reply["reason"].trim() ? reply["reason"].trim() : stderr_text.trim();
-    if (stated) {
-      concern_messages.push({ rc, text: stated });
+    const extra = typeof reply["additional_context"] === "string" && reply["additional_context"].trim() ? reply["additional_context"].trim() : "";
+    const message = [stated, extra].filter(Boolean).join("\n\n");
+    if (message) {
+      concern_messages.push({ rc, text: message });
     }
-    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 +21256,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 +21277,7 @@ function main30(argv) {
 }
 function _isDir4(p) {
   try {
-    return fs41.statSync(p).isDirectory();
+    return fs45.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -20298,41 +21288,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
 };