@event4u/agent-config 9.34.0 → 9.36.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, path67) {
-      const ctrl = callVisitor(key, node, visitor, path67);
+    function visit_(key, node, visitor, path69) {
+      const ctrl = callVisitor(key, node, visitor, path69);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path67, ctrl);
-        return visit_(key, ctrl, visitor, path67);
+        replaceNode(key, path69, ctrl);
+        return visit_(key, ctrl, visitor, path69);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path67 = Object.freeze(path67.concat(node));
+          path69 = Object.freeze(path69.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path67);
+            const ci = visit_(i, node.items[i], visitor, path69);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -133,13 +133,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path67 = Object.freeze(path67.concat(node));
-          const ck = visit_("key", node.key, visitor, path67);
+          path69 = Object.freeze(path69.concat(node));
+          const ck = visit_("key", node.key, visitor, path69);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path67);
+          const cv = visit_("value", node.value, visitor, path69);
           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, path67) {
-      const ctrl = await callVisitor(key, node, visitor, path67);
+    async function visitAsync_(key, node, visitor, path69) {
+      const ctrl = await callVisitor(key, node, visitor, path69);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path67, ctrl);
-        return visitAsync_(key, ctrl, visitor, path67);
+        replaceNode(key, path69, ctrl);
+        return visitAsync_(key, ctrl, visitor, path69);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path67 = Object.freeze(path67.concat(node));
+          path69 = Object.freeze(path69.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path67);
+            const ci = await visitAsync_(i, node.items[i], visitor, path69);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -181,13 +181,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path67 = Object.freeze(path67.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path67);
+          path69 = Object.freeze(path69.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path69);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path67);
+          const cv = await visitAsync_("value", node.value, visitor, path69);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -214,23 +214,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path67) {
+    function callVisitor(key, node, visitor, path69) {
       if (typeof visitor === "function")
-        return visitor(key, node, path67);
+        return visitor(key, node, path69);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path67);
+        return visitor.Map?.(key, node, path69);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path67);
+        return visitor.Seq?.(key, node, path69);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path67);
+        return visitor.Pair?.(key, node, path69);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path67);
+        return visitor.Scalar?.(key, node, path69);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path67);
+        return visitor.Alias?.(key, node, path69);
       return void 0;
     }
-    function replaceNode(key, path67, node) {
-      const parent = path67[path67.length - 1];
+    function replaceNode(key, path69, node) {
+      const parent = path69[path69.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, path67, value) {
+    function collectionFromPath(schema, path69, value) {
       let v = value;
-      for (let i = path67.length - 1; i >= 0; --i) {
-        const k = path67[i];
+      for (let i = path69.length - 1; i >= 0; --i) {
+        const k = path69[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 = (path67) => path67 == null || typeof path67 === "object" && !!path67[Symbol.iterator]().next().done;
+    var isEmptyPath = (path69) => path69 == null || typeof path69 === "object" && !!path69[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(path67, value) {
-        if (isEmptyPath(path67))
+      addIn(path69, value) {
+        if (isEmptyPath(path69))
           this.add(value);
         else {
-          const [key, ...rest] = path67;
+          const [key, ...rest] = path69;
           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(path67) {
-        const [key, ...rest] = path67;
+      deleteIn(path69) {
+        const [key, ...rest] = path69;
         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(path67, keepScalar) {
-        const [key, ...rest] = path67;
+      getIn(path69, keepScalar) {
+        const [key, ...rest] = path69;
         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(path67) {
-        const [key, ...rest] = path67;
+      hasIn(path69) {
+        const [key, ...rest] = path69;
         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(path67, value) {
-        const [key, ...rest] = path67;
+      setIn(path69, value) {
+        const [key, ...rest] = path69;
         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(path67, value) {
+      addIn(path69, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path67, value);
+          this.contents.addIn(path69, 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(path67) {
-        if (Collection.isEmptyPath(path67)) {
+      deleteIn(path69) {
+        if (Collection.isEmptyPath(path69)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path67) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path69) : 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(path67, keepScalar) {
-        if (Collection.isEmptyPath(path67))
+      getIn(path69, keepScalar) {
+        if (Collection.isEmptyPath(path69))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path67, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path69, 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(path67) {
-        if (Collection.isEmptyPath(path67))
+      hasIn(path69) {
+        if (Collection.isEmptyPath(path69))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path67) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path69) : 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(path67, value) {
-        if (Collection.isEmptyPath(path67)) {
+      setIn(path69, value) {
+        if (Collection.isEmptyPath(path69)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path67), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path69), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path67, value);
+          this.contents.setIn(path69, value);
         }
       }
       /**
@@ -3996,10 +3996,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep6, value } = collItem;
+        const { start, key, sep: sep7, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep6?.[0],
+          next: key ?? sep7?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -4013,7 +4013,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep6) {
+          if (!keyProps.anchor && !keyProps.tag && !sep7) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -4037,7 +4037,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep6 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep7 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -4053,7 +4053,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep6, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep7, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -4144,7 +4144,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep6 = "";
+        let sep7 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -4158,13 +4158,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep6 + cb;
-              sep6 = "";
+                comment += sep7 + cb;
+              sep7 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep6 += source;
+                sep7 += source;
               hasSpace = true;
               break;
             default:
@@ -4207,18 +4207,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep: sep6, value } = collItem;
+        const { start, key, sep: sep7, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep6?.[0],
+          next: key ?? sep7?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep6 && !value) {
+          if (!props.anchor && !props.tag && !sep7 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -4272,8 +4272,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep6 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep6, null, props, onError);
+        if (!isMap && !sep7 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep7, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -4285,7 +4285,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep6 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep7 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -4296,8 +4296,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep6)
-                for (const st of sep6) {
+              if (sep7)
+                for (const st of sep7) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -4314,7 +4314,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep6, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep7, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -4494,7 +4494,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep6 = "";
+      let sep7 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -4511,24 +4511,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep6 + indent.slice(trimIndent) + content;
-          sep6 = "\n";
+          value += sep7 + indent.slice(trimIndent) + content;
+          sep7 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep6 === " ")
-            sep6 = "\n";
-          else if (!prevMoreIndented && sep6 === "\n")
-            sep6 = "\n\n";
-          value += sep6 + indent.slice(trimIndent) + content;
-          sep6 = "\n";
+          if (sep7 === " ")
+            sep7 = "\n";
+          else if (!prevMoreIndented && sep7 === "\n")
+            sep7 = "\n\n";
+          value += sep7 + indent.slice(trimIndent) + content;
+          sep7 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep6 === "\n")
+          if (sep7 === "\n")
             value += "\n";
           else
-            sep6 = "\n";
+            sep7 = "\n";
         } else {
-          value += sep6 + content;
-          sep6 = " ";
+          value += sep7 + content;
+          sep7 = " ";
           prevMoreIndented = false;
         }
       }
@@ -4710,25 +4710,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep6 = " ";
+      let sep7 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep6 === "\n")
-            res += sep6;
+          if (sep7 === "\n")
+            res += sep7;
           else
-            sep6 = "\n";
+            sep7 = "\n";
         } else {
-          res += sep6 + match[1];
-          sep6 = " ";
+          res += sep7 + match[1];
+          sep7 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep6 + (match?.[1] ?? "");
+      return res + sep7 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -5538,14 +5538,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep6, value }) {
+    function stringifyItem({ start, key, sep: sep7, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep6)
-        for (const st of sep6)
+      if (sep7)
+        for (const st of sep7)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -5570,9 +5570,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path67) => {
+    visit.itemAtPath = (cst, path69) => {
       let item = cst;
-      for (const [field, index] of path67) {
+      for (const [field, index] of path69) {
         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, path67) => {
-      const parent = visit.itemAtPath(cst, path67.slice(0, -1));
-      const field = path67[path67.length - 1][0];
+    visit.parentCollection = (cst, path69) => {
+      const parent = visit.itemAtPath(cst, path69.slice(0, -1));
+      const field = path69[path69.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path67, item, visitor) {
-      let ctrl = visitor(item, path67);
+    function _visit(path69, item, visitor) {
+      let ctrl = visitor(item, path69);
       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(path67.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path69.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, path67);
+            ctrl = ctrl(item, path69);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path67) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path69) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6712,18 +6712,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep6;
+          let sep7;
           if (scalar.end) {
-            sep6 = scalar.end;
-            sep6.push(this.sourceToken);
+            sep7 = scalar.end;
+            sep7.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep6 = [this.sourceToken];
+            sep7 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep6 }]
+            items: [{ start, key: scalar, sep: sep7 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -6876,15 +6876,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep6 = it.sep;
-                  sep6.push(this.sourceToken);
+                  const sep7 = it.sep;
+                  sep7.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep: sep6 }]
+                    items: [{ start: start2, key, sep: sep7 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -6913,14 +6913,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs64 = this.flowScalar(this.type);
+              const fs66 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs64, sep: [] });
+                map.items.push({ start, key: fs66, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs64);
+                this.stack.push(fs66);
               } else {
-                Object.assign(it, { key: fs64, sep: [] });
+                Object.assign(it, { key: fs66, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7048,13 +7048,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs64 = this.flowScalar(this.type);
+              const fs66 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs64, sep: [] });
+                fc.items.push({ start: [], key: fs66, sep: [] });
               else if (it.sep)
-                this.stack.push(fs64);
+                this.stack.push(fs66);
               else
-                Object.assign(it, { key: fs64, sep: [] });
+                Object.assign(it, { key: fs66, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7078,13 +7078,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep6 = fc.end.splice(1, fc.end.length);
-            sep6.push(this.sourceToken);
+            const sep7 = fc.end.splice(1, fc.end.length);
+            sep7.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep6 }]
+              items: [{ start, key: fc, sep: sep7 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -7363,15 +7363,15 @@ var require_dist = __commonJS({
 });
 
 // src/scripts/hooks/dispatch_entry.ts
-import * as path66 from "node:path";
-import { fileURLToPath as fileURLToPath47 } from "node:url";
+import * as path68 from "node:path";
+import { fileURLToPath as fileURLToPath48 } from "node:url";
 
 // src/scripts/hooks/dispatch_hook.ts
 var import_yaml6 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync7 } from "node:child_process";
-import fs63 from "node:fs";
-import path65 from "node:path";
-import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL40 } from "node:url";
+import fs65 from "node:fs";
+import path67 from "node:path";
+import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL41 } from "node:url";
 
 // src/scripts/_lib/spawn_env.ts
 var DENY_EXACT = /* @__PURE__ */ new Set([
@@ -14036,6 +14036,11 @@ var import_yaml3 = __toESM(require_dist(), 1);
 import * as fs14 from "node:fs";
 import * as os2 from "node:os";
 import * as path13 from "node:path";
+
+// src/scripts/ai_council/quorum.ts
+var SOLO_FLOOR_MIN_PRESENT = 2;
+
+// src/scripts/ai_council/config.ts
 var _VALID_PROVIDERS = /* @__PURE__ */ new Set([
   "anthropic",
   "openai",
@@ -14342,6 +14347,9 @@ function _build_config(raw, source_path) {
     _asDict(_getOr(raw, "cli_call_budget", {}))
   );
   const quorum = _build_quorum(_get(raw, "quorum", "majority"));
+  const quorum_min_present = _build_quorum_min_present(
+    _get(raw, "quorum_min_present", SOLO_FLOOR_MIN_PRESENT)
+  );
   const necessity_classifier = _build_necessity_classifier(
     _asDict(_getOr(raw, "necessity_classifier", {}))
   );
@@ -14390,6 +14398,7 @@ function _build_config(raw, source_path) {
     consensus_scoring: consensus,
     cli_call_budget,
     quorum,
+    quorum_min_present,
     necessity_classifier,
     model_downgrade,
     debate,
@@ -15217,6 +15226,14 @@ function _build_quorum(raw) {
     `\`quorum\`=${_pyRepr3(raw)} must be 'majority' or an integer >= 1 (got ${_pyTypeName(raw)}).`
   );
 }
+function _build_quorum_min_present(raw) {
+  if (_isInt(raw) && raw >= 1) {
+    return raw;
+  }
+  throw new CouncilConfigError(
+    `\`quorum_min_present\`=${_pyRepr3(raw)} must be an integer >= 1 (got ${_pyTypeName(raw)}).`
+  );
+}
 function _build_advisor(name, cfg) {
   if (!_isDict(cfg)) {
     throw new CouncilConfigError(`advisors.${name}: must be a mapping.`);
@@ -20494,35 +20511,109 @@ function foreign_live_records(dir, session_id, options = {}) {
   const own = safe_stem(session_id);
   return read_live_records(dir, options).filter((r) => safe_stem(r.session_id) !== own);
 }
+function classify_collisions(others, here) {
+  const out = [];
+  for (const r of others) {
+    if (here.roadmap_slug !== null && r.roadmap_slug !== null && r.roadmap_slug === here.roadmap_slug) {
+      out.push({ kind: "roadmap", record: r });
+    }
+  }
+  for (const r of others) {
+    if (here.branch !== null && r.branch === here.branch) {
+      out.push({ kind: "branch", record: r });
+    }
+  }
+  return out;
+}
 
 // src/scripts/session_register_hook.ts
 var REPLAY_ENV_VAR6 = "AGENT_CONFIG_REPLAY";
-var ROADMAP_CLAIM_REL = path42.join("agents", "runtime", "state", "roadmap-claim.json");
+var _STATE_REL = path42.join("agents", "runtime", "state");
+var ROADMAP_CLAIM_REL = path42.join(_STATE_REL, "roadmap-claim.json");
+function roadmap_claim_rel(session_id) {
+  const id = String(session_id ?? "").trim();
+  if (id === "") {
+    return ROADMAP_CLAIM_REL;
+  }
+  const rel = path42.join(_STATE_REL, `roadmap-claim-${safe_stem(id)}.json`);
+  const norm = path42.normalize(rel);
+  if (!norm.startsWith(`${_STATE_REL}${path42.sep}`) || norm.includes("..")) {
+    return ROADMAP_CLAIM_REL;
+  }
+  return norm;
+}
 function _is_replay_mode4() {
   return String(process9.env[REPLAY_ENV_VAR6] ?? "").trim() !== "";
 }
-function read_claimed_slug(workspace_root) {
+function _read_claim_file(file) {
   try {
-    const raw = fs41.readFileSync(path42.join(workspace_root, ROADMAP_CLAIM_REL), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const slug = parsed["slug"];
-      if (typeof slug === "string" && slug.trim().length > 0) {
-        return slug.trim();
-      }
+    const parsed = JSON.parse(fs41.readFileSync(file, "utf-8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
     }
-    return null;
+    const rec = parsed;
+    const slug = rec["slug"];
+    if (typeof slug !== "string" || slug.trim().length === 0) {
+      return null;
+    }
+    const sid = rec["session_id"];
+    return {
+      slug: slug.trim(),
+      ...typeof sid === "string" && sid.trim() !== "" ? { session_id: sid.trim() } : {}
+    };
   } catch {
     return null;
   }
 }
+function read_claimed_slug(workspace_root, session_id) {
+  const own = roadmap_claim_rel(session_id);
+  if (own !== ROADMAP_CLAIM_REL) {
+    const mine = _read_claim_file(path42.join(workspace_root, own));
+    if (mine !== null) {
+      return mine.slug;
+    }
+  }
+  const legacy = _read_claim_file(path42.join(workspace_root, ROADMAP_CLAIM_REL));
+  if (legacy === null) {
+    return null;
+  }
+  const id = String(session_id ?? "").trim();
+  if (id !== "") {
+    return null;
+  }
+  return legacy.slug;
+}
+function claim_is_stale(workspace_root, slug, peer_worktree) {
+  if (slug === null || slug.trim() === "") {
+    return false;
+  }
+  const base = slug.trim().replace(/\.md$/, "");
+  const rel = path42.normalize(path42.join("agents", "roadmaps", `${base}.md`));
+  const inside = rel.startsWith(`agents${path42.sep}roadmaps${path42.sep}`) && !rel.includes("..");
+  if (!inside || path42.isAbsolute(base)) {
+    return true;
+  }
+  const roots = [peer_worktree, workspace_root].filter(
+    (r) => typeof r === "string" && r.trim() !== ""
+  );
+  for (const root of roots) {
+    try {
+      if (fs41.existsSync(path42.join(root, rel))) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
 function build_record(workspace_root, session_id, platform, started_at, now = /* @__PURE__ */ new Date()) {
   return {
     session_id,
     platform,
     worktree: workspace_root,
     branch: current_branch(workspace_root),
-    roadmap_slug: read_claimed_slug(workspace_root),
+    roadmap_slug: read_claimed_slug(workspace_root, session_id),
     started_at,
     last_seen: iso_now(now)
   };
@@ -20540,20 +20631,26 @@ function foreign_sessions_block(workspace_root, session_id, now = /* @__PURE__ *
   const others = foreign_live_records(dir, session_id, { prune: true, now });
   if (others.length === 0) return null;
   const here = current_branch(workspace_root);
+  const my_slug = read_claimed_slug(workspace_root, session_id);
   const lines = [];
-  let collision = null;
+  const live_others = [];
   for (const r of others) {
     const age_min = Math.max(0, Math.round((now.getTime() - Date.parse(r.last_seen)) / 6e4));
-    const slug = r.roadmap_slug === null ? "no roadmap claimed" : `roadmap: ${r.roadmap_slug}`;
+    const stale = claim_is_stale(workspace_root, r.roadmap_slug, r.worktree);
+    const slug = r.roadmap_slug === null ? "no roadmap claimed" : stale ? `roadmap: ${r.roadmap_slug} (STALE \u2014 no such open roadmap; treat as no claim)` : `roadmap: ${r.roadmap_slug}`;
     const ttl_note = ttl_is_measured(r.platform) ? "" : ` \xB7 unmeasured host, TTL falls back to ${Math.round(ttl_seconds_for(r.platform) / 3600)}h`;
     lines.push(
       `- ${r.platform} \xB7 branch \`${r.branch ?? "detached"}\` \xB7 ${slug} \xB7 last seen ${age_min} min ago${ttl_note}
   worktree: ${r.worktree}`
     );
-    if (collision === null && here !== null && r.branch === here) {
-      collision = r;
-    }
+    live_others.push(stale ? { ...r, roadmap_slug: null } : r);
   }
+  const collisions = classify_collisions(live_others, {
+    branch: here,
+    roadmap_slug: claim_is_stale(workspace_root, my_slug) ? null : my_slug
+  });
+  const roadmap_hits = collisions.filter((c) => c.kind === "roadmap");
+  const branch_hit = collisions.find((c) => c.kind === "branch") ?? null;
   const parts = [
     "<session-register>",
     "The following OTHER agent sessions are live on this repository right now.",
@@ -20561,7 +20658,23 @@ function foreign_sessions_block(workspace_root, session_id, now = /* @__PURE__ *
     "",
     ...lines
   ];
-  if (collision !== null) {
+  if (roadmap_hits.length > 0) {
+    parts.push(
+      "",
+      `DUPLICATE WORK: ${roadmap_hits.length} other live session(s) claim the SAME roadmap \`${my_slug}\`.`,
+      ...roadmap_hits.map(
+        (h) => `  \xB7 branch \`${h.record.branch ?? "detached"}\` in ${h.record.worktree}`
+      ),
+      "A different branch name does NOT make this a different task \u2014 measured twice,",
+      "two sessions built one roadmap phase under two branch names and one PR was wasted.",
+      "STOP before writing code. Ask the user ONCE, as numbered options:",
+      "  1. Take a different roadmap (`agent-config sessions:list` shows what is held)",
+      "  2. Split the roadmap explicitly \u2014 name which phases are yours",
+      "  3. Continue anyway, accepting that one of the two results is discarded",
+      "Never decide silently, in either direction."
+    );
+  }
+  if (branch_hit !== null) {
     parts.push(
       "",
       `COLLISION: another live session already holds branch \`${here}\`.`,
@@ -20602,6 +20715,10 @@ function main25() {
     if (event === "session_end" || event === "stop" && stop_means_session_end(platform)) {
       const dir = register_dir(root);
       if (dir !== null) delete_record(dir, session_id);
+      try {
+        fs41.unlinkSync(path42.join(root, roadmap_claim_rel(session_id)));
+      } catch {
+      }
       return 0;
     }
     if (event === "session_start" || event === "user_prompt_submit" || event === "stop") {
@@ -22528,7 +22645,7 @@ import { fileURLToPath as fileURLToPath36, pathToFileURL as pathToFileURL29 } fr
 
 // src/install/rtkDetection.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync8, statSync as statSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync8, mkdirSync as mkdirSync9 } from "node:fs";
+import { existsSync as existsSync9, statSync as statSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync8, mkdirSync as mkdirSync9 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { delimiter, join as join19, dirname as dirname9 } from "node:path";
 var TOKEN_KILLER_GAIN_SIGNATURE = /RTK Token Savings/;
@@ -22541,7 +22658,7 @@ function resolveBinaryOnPath(name, pathEnv) {
     if (dir.length === 0) continue;
     for (const suffix of suffixes) {
       const candidate = join19(dir, `${name}${suffix}`);
-      if (existsSync8(candidate)) return candidate;
+      if (existsSync9(candidate)) return candidate;
     }
   }
   return null;
@@ -22878,6 +22995,44 @@ import fs51 from "node:fs";
 import path52 from "node:path";
 import { fileURLToPath as fileURLToPath37, pathToFileURL as pathToFileURL30 } from "node:url";
 
+// src/scripts/_lib/ui_surface.ts
+var UI_EXTENSIONS = [
+  "html",
+  "htm",
+  "css",
+  "scss",
+  "sass",
+  "less",
+  "vue",
+  "svelte",
+  "astro",
+  "jsx",
+  "tsx"
+];
+var UI_COMPOUND_SUFFIXES = [".blade.php"];
+var UI_EXT = new RegExp(
+  `(\\.(${UI_EXTENSIONS.join("|")})|${UI_COMPOUND_SUFFIXES.map((s) => s.replace(/\./g, "\\.")).join("|")})$`,
+  "i"
+);
+function isUiPath(p) {
+  return UI_EXT.test(p);
+}
+var UI_PATH_FRAGMENTS = [
+  "resources/views/",
+  "resources/js/",
+  // `components/` already subsumes `src/components/` under substring
+  // matching — listing both here would be dead weight. The rules' own
+  // `path_prefix` list keeps both because matching there is anchored.
+  "components/",
+  "pages/"
+];
+var UI_TREE_EXCLUSIONS = ["pages/api/"];
+function isUiTreePath(p) {
+  const normalized = p.replace(/\\/g, "/").toLowerCase();
+  if (UI_TREE_EXCLUSIONS.some((fragment) => normalized.includes(fragment))) return false;
+  return UI_PATH_FRAGMENTS.some((fragment) => normalized.includes(fragment));
+}
+
 // src/scripts/lint_design_slop.ts
 import fs50 from "node:fs";
 import path51 from "node:path";
@@ -23467,7 +23622,6 @@ var SETTINGS_FILE7 = ".agent-settings.yml";
 var EXIT_ALLOW13 = 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 isObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -23876,11 +24030,180 @@ function isCliEntry11() {
 }
 if (isCliEntry11()) process.exit(main36());
 
-// src/scripts/hooks/orchestration_record_hook.ts
-import * as crypto4 from "node:crypto";
+// src/scripts/hooks/ui_route_nudge_hook.ts
 import * as fs55 from "node:fs";
 import * as path56 from "node:path";
-import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL33 } from "node:url";
+import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL32 } from "node:url";
+
+// src/scripts/_lib/hook_settings.ts
+import * as fs54 from "node:fs";
+import * as path55 from "node:path";
+var SETTINGS_FILE9 = ".agent-settings.yml";
+function hookSectionEnabled(root, section) {
+  const file = path55.join(root, SETTINGS_FILE9);
+  let text;
+  try {
+    if (!fs54.statSync(file).isFile()) return false;
+    text = fs54.readFileSync(file, "utf-8");
+  } catch {
+    return false;
+  }
+  const escaped = section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const sectionPattern = new RegExp(`^(\\s+)${escaped}\\s*:\\s*$`);
+  let inHooks = false;
+  let sectionIndent = null;
+  const indentOf = (line) => line.length - line.replace(/^\s+/, "").length;
+  for (const raw of text.split(/\r\n|\r|\n/)) {
+    const line = raw.replace(/\s+$/, "");
+    if (!line || line.replace(/^\s+/, "").startsWith("#")) continue;
+    if (!(line.startsWith(" ") || line.startsWith("	"))) {
+      inHooks = /^hooks\s*:\s*$/.test(line);
+      sectionIndent = null;
+      continue;
+    }
+    if (inHooks) {
+      const opened = sectionPattern.exec(line);
+      if (opened) {
+        sectionIndent = opened[1].length;
+        continue;
+      }
+      if (sectionIndent !== null && indentOf(line) <= sectionIndent) {
+        sectionIndent = null;
+      }
+    }
+    if (sectionIndent !== null && /^\s+enabled\s*:\s*true\b/.test(line)) return true;
+  }
+  return false;
+}
+
+// src/scripts/hooks/ui_route_nudge_hook.ts
+var EXIT_ALLOW15 = 0;
+var EXIT_WARN8 = 2;
+var MAX_NUDGES = 2;
+var DESIGN_SURFACES = [
+  "fe-design",
+  "existing-ui-audit",
+  "design-review",
+  "design-intelligence"
+];
+function isObject4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function unwrap2(envelope) {
+  const inner = envelope["payload"];
+  return isObject4(inner) ? inner : envelope;
+}
+function extractEvent(outer) {
+  const envelope = unwrap2(outer);
+  const ti = envelope["tool_input"] ?? envelope["toolInput"] ?? envelope["input"];
+  if (!isObject4(ti)) return null;
+  const fileVal = ti["file_path"] ?? ti["path"] ?? ti["filePath"];
+  const file = typeof fileVal === "string" ? fileVal : "";
+  let isWrite = false;
+  for (const key of ["content", "new_string", "new_str", "text", "newText"]) {
+    if (typeof ti[key] === "string" && ti[key].length > 0) isWrite = true;
+  }
+  return { file, isWrite };
+}
+function isConsultation(event) {
+  if (event.isWrite || !event.file) return false;
+  const normalized = event.file.replace(/\\/g, "/").toLowerCase();
+  return DESIGN_SURFACES.some((surface) => normalized.includes(`skills/${surface}/`));
+}
+function isUiWrite(event) {
+  if (!event.isWrite || !event.file) return false;
+  return isUiPath(event.file) || isUiTreePath(event.file);
+}
+function stateFile2(root) {
+  return path56.join(root, "agents", "runtime", "state", "ui-route-nudge.json");
+}
+function readState2(root, session) {
+  try {
+    const all = JSON.parse(fs55.readFileSync(stateFile2(root), "utf-8"));
+    const entry = all[session];
+    if (entry && typeof entry.consulted === "boolean" && typeof entry.nudges === "number") {
+      return entry;
+    }
+  } catch {
+  }
+  return { consulted: false, nudges: 0 };
+}
+var MAX_SESSIONS = 50;
+function pruneSessions(all, keep = MAX_SESSIONS) {
+  const keys = Object.keys(all);
+  if (keys.length <= keep) return all;
+  const survivors = keys.slice(keys.length - keep);
+  const pruned = {};
+  for (const key of survivors) pruned[key] = all[key];
+  return pruned;
+}
+function writeState2(root, session, state) {
+  try {
+    const file = stateFile2(root);
+    let all = {};
+    try {
+      all = JSON.parse(fs55.readFileSync(file, "utf-8"));
+    } catch {
+    }
+    if (typeof all !== "object" || all === null || Array.isArray(all)) all = {};
+    all[session] = state;
+    fs55.mkdirSync(path56.dirname(file), { recursive: true });
+    fs55.writeFileSync(file, JSON.stringify(pruneSessions(all)));
+  } catch {
+  }
+}
+function decide4(event, state) {
+  if (isConsultation(event)) {
+    return { state: { ...state, consulted: true }, warn: false };
+  }
+  if (!isUiWrite(event)) return { state, warn: false };
+  if (state.consulted) return { state, warn: false };
+  if (state.nudges >= MAX_NUDGES) return { state, warn: false };
+  return { state: { ...state, nudges: state.nudges + 1 }, warn: true };
+}
+function nudgeReason2(file) {
+  return `Non-trivial UI write to ${file} with no design consultation this session. Run \`existing-ui-audit\` first, then the fe-design loop (brief \u2192 build \u2192 review). Skip only if this is ui-trivial: <=1 file, <=5 lines, no new component, no new state, no new dependency.`;
+}
+function main37() {
+  let envelope;
+  try {
+    const raw = readHookStdin();
+    if (!raw.trim()) return EXIT_ALLOW15;
+    envelope = JSON.parse(raw);
+  } catch {
+    return EXIT_ALLOW15;
+  }
+  if (!isObject4(envelope)) return EXIT_ALLOW15;
+  const rootVal = envelope["workspace_root"];
+  const root = typeof rootVal === "string" && rootVal ? rootVal : process.cwd();
+  if (!hookSectionEnabled(root, "ui_route_nudge")) return EXIT_ALLOW15;
+  const sessionVal = envelope["session_id"];
+  const session = typeof sessionVal === "string" && sessionVal ? sessionVal : "unknown";
+  const event = extractEvent(envelope);
+  if (!event) return EXIT_ALLOW15;
+  const before = readState2(root, session);
+  const { state, warn } = decide4(event, before);
+  if (state.consulted !== before.consulted || state.nudges !== before.nudges) {
+    writeState2(root, session, state);
+  }
+  if (!warn) return EXIT_ALLOW15;
+  process.stdout.write(`${JSON.stringify({ reason: nudgeReason2(event.file) })}
+`);
+  return EXIT_WARN8;
+}
+function isCliEntry12() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  return pathToFileURL32(path56.resolve(entry)).href === import.meta.url;
+}
+if (isCliEntry12()) process.exit(main37());
+var _HOOK_FILE = fileURLToPath39(import.meta.url);
+
+// src/scripts/hooks/orchestration_record_hook.ts
+import * as crypto4 from "node:crypto";
+import * as fs57 from "node:fs";
+import * as path58 from "node:path";
+import { fileURLToPath as fileURLToPath40, pathToFileURL as pathToFileURL34 } from "node:url";
 
 // src/scripts/_lib/orchestration_record.ts
 var DISPATCH_OUTCOMES = ["DONE", "DONE_WITH_CONCERNS", "NEEDS_CONTEXT", "BLOCKED", "killed"];
@@ -24076,9 +24399,9 @@ function buildOrchestrationLine(input) {
 
 // src/scripts/orchestration_record.ts
 import * as crypto3 from "node:crypto";
-import * as fs54 from "node:fs";
-import * as path55 from "node:path";
-import { pathToFileURL as pathToFileURL32 } from "node:url";
+import * as fs56 from "node:fs";
+import * as path57 from "node:path";
+import { pathToFileURL as pathToFileURL33 } from "node:url";
 var DEFAULT_DIR = "agents/runtime/state/audit";
 function parseFlags(argv) {
   const flags = {};
@@ -24128,7 +24451,7 @@ function contentHashId(input) {
   });
   return crypto3.createHash("sha256").update(canonical).digest("hex").slice(0, 26).toUpperCase();
 }
-function main37(argv = process.argv.slice(2)) {
+function main38(argv = process.argv.slice(2)) {
   const flags = parseFlags(argv);
   const dir = str2(flags, "dir") ?? DEFAULT_DIR;
   const dryRun = flags["dry-run"] === true;
@@ -24189,27 +24512,27 @@ function main37(argv = process.argv.slice(2)) {
     process.stdout.write(serialized + "\n");
     return 0;
   }
-  fs54.mkdirSync(dir, { recursive: true });
-  const file = path55.join(dir, `${ts.slice(0, 7)}.jsonl`);
-  fs54.appendFileSync(file, serialized + "\n", "utf8");
+  fs56.mkdirSync(dir, { recursive: true });
+  const file = path57.join(dir, `${ts.slice(0, 7)}.jsonl`);
+  fs56.appendFileSync(file, serialized + "\n", "utf8");
   process.stdout.write(`orchestration telemetry recorded \u2192 ${file} (id ${line.id})
 `);
   return 0;
 }
 if (process.argv[1] !== void 0) {
-  const invokedUrl = pathToFileURL32(path55.resolve(process.argv[1])).href;
-  if (import.meta.url === invokedUrl) process.exit(main37());
+  const invokedUrl = pathToFileURL33(path57.resolve(process.argv[1])).href;
+  if (import.meta.url === invokedUrl) process.exit(main38());
 }
 
 // src/scripts/hooks/orchestration_record_hook.ts
-var EXIT_ALLOW15 = 0;
-function isObject4(v) {
+var EXIT_ALLOW16 = 0;
+function isObject5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var DISPATCH_TOOL_NAMES = /* @__PURE__ */ new Set(["Agent", "Task"]);
 function unwrapPayload(envelope) {
   const inner = envelope["payload"];
-  return isObject4(inner) ? inner : envelope;
+  return isObject5(inner) ? inner : envelope;
 }
 function extractToolName(payload) {
   const v = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
@@ -24217,12 +24540,12 @@ function extractToolName(payload) {
 }
 function extractToolInput(payload) {
   const v = payload["tool_input"] ?? payload["toolInput"];
-  return isObject4(v) ? v : null;
+  return isObject5(v) ? v : null;
 }
 function extractToolResult(payload) {
   for (const key of ["tool_response", "toolResponse", "tool_result", "toolUseResult"]) {
     const v = payload[key];
-    if (isObject4(v)) return v;
+    if (isObject5(v)) return v;
   }
   return null;
 }
@@ -24243,7 +24566,7 @@ function extractDispatchFacts(payload) {
   const result = extractToolResult(payload);
   const resolvedModel = result && typeof result["resolvedModel"] === "string" ? result["resolvedModel"] : null;
   let totalTokens = result ? numOrNull(result["totalTokens"]) : null;
-  if (totalTokens === null && result && isObject4(result["usage"])) {
+  if (totalTokens === null && result && isObject5(result["usage"])) {
     const usage = result["usage"];
     const inTok = numOrNull(usage["input_tokens"]);
     const outTok = numOrNull(usage["output_tokens"]);
@@ -24292,35 +24615,35 @@ function buildRecordInput(facts, ts, id) {
   return input;
 }
 function auditFileFor(consumerRoot, ts) {
-  return path56.join(consumerRoot, DEFAULT_DIR, `${ts.slice(0, 7)}.jsonl`);
+  return path58.join(consumerRoot, DEFAULT_DIR, `${ts.slice(0, 7)}.jsonl`);
 }
 function appendLine(consumerRoot, ts, line) {
   if (is_replay_mode()) return;
   const file = auditFileFor(consumerRoot, ts);
-  fs55.mkdirSync(path56.dirname(file), { recursive: true });
-  fs55.appendFileSync(file, `${JSON.stringify(line)}
+  fs57.mkdirSync(path58.dirname(file), { recursive: true });
+  fs57.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 function processEnvelope(envelope, consumer_root) {
   try {
-    if (!isObject4(envelope)) return EXIT_ALLOW15;
+    if (!isObject5(envelope)) return EXIT_ALLOW16;
     const payload = unwrapPayload(envelope);
     const toolName = extractToolName(payload);
-    if (toolName === null || !DISPATCH_TOOL_NAMES.has(toolName)) return EXIT_ALLOW15;
+    if (toolName === null || !DISPATCH_TOOL_NAMES.has(toolName)) return EXIT_ALLOW16;
     const facts = extractDispatchFacts(payload);
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     const id = crypto4.randomUUID();
     const input = buildRecordInput(facts, ts, id);
     const { line, errors } = buildOrchestrationLine(input);
-    if (errors.length || line === null) return EXIT_ALLOW15;
+    if (errors.length || line === null) return EXIT_ALLOW16;
     appendLine(consumer_root, ts, line);
   } catch {
-    return EXIT_ALLOW15;
+    return EXIT_ALLOW16;
   }
-  return EXIT_ALLOW15;
+  return EXIT_ALLOW16;
 }
 function _resolveRoot(envelope) {
-  if (isObject4(envelope)) {
+  if (isObject5(envelope)) {
     const cwd = envelope["cwd"];
     if (typeof cwd === "string" && cwd) return cwd;
     const pr = envelope["workspace_root"] ?? envelope["project_root"];
@@ -24328,13 +24651,13 @@ function _resolveRoot(envelope) {
   }
   return process.cwd();
 }
-function main38() {
+function main39() {
   const raw = readHookStdin();
   let envelope = {};
   try {
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW15;
+    return EXIT_ALLOW16;
   }
   return processEnvelope(envelope, _resolveRoot(envelope));
 }
@@ -24343,20 +24666,20 @@ function _isCliEntry29() {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL33(path56.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL34(path58.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs55.realpathSync(fileURLToPath39(import.meta.url)) === fs55.realpathSync(path56.resolve(process.argv[1]));
+    return fs57.realpathSync(fileURLToPath40(import.meta.url)) === fs57.realpathSync(path58.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry29()) process.exit(main38());
+if (_isCliEntry29()) process.exit(main39());
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-import fs56 from "node:fs";
-import path57 from "node:path";
-import { fileURLToPath as fileURLToPath40, pathToFileURL as pathToFileURL34 } from "node:url";
+import fs58 from "node:fs";
+import path59 from "node:path";
+import { fileURLToPath as fileURLToPath41, pathToFileURL as pathToFileURL35 } from "node:url";
 
 // src/scripts/_lib/host_capability.ts
 import process10 from "node:process";
@@ -24691,8 +25014,8 @@ function resolveSubagentRouting(inp) {
 }
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-var EXIT_ALLOW16 = 0;
-var EXIT_WARN8 = 2;
+var EXIT_ALLOW17 = 0;
+var EXIT_WARN9 = 2;
 function _isObject13(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -24849,34 +25172,34 @@ function _workspaceRoot3(envelope) {
   }
   return process.cwd();
 }
-function main39() {
+function main40() {
   let envelope = {};
   try {
     const raw = readHookStdin();
     envelope = raw.trim() ? JSON.parse(raw) : {};
   } catch {
-    return EXIT_ALLOW16;
+    return EXIT_ALLOW17;
   }
   const env = _isObject13(envelope) ? envelope : {};
   const event = env["event"];
   const slot = typeof event === "string" && event !== "" ? event : "user_prompt_submit";
   if (slot !== "user_prompt_submit") {
-    return EXIT_ALLOW16;
+    return EXIT_ALLOW17;
   }
   const payload = _isObject13(env["payload"]) ? env["payload"] : env;
   const prompt = _extractPrompt2(payload);
   if (!prompt) {
-    return EXIT_ALLOW16;
+    return EXIT_ALLOW17;
   }
   if (isSyntheticPrompt(prompt)) {
-    return EXIT_ALLOW16;
+    return EXIT_ALLOW17;
   }
   const root = _workspaceRoot3(env);
   const platform = env["platform"];
   const hostId = typeof platform === "string" && platform ? platform : null;
   const result = classifyPrompt(prompt, root, hostId);
   if (!result) {
-    return EXIT_ALLOW16;
+    return EXIT_ALLOW17;
   }
   process.stdout.write(
     `${JSON.stringify({
@@ -24886,7 +25209,7 @@ function main39() {
     })}
 `
   );
-  return EXIT_WARN8;
+  return EXIT_WARN9;
 }
 function _isCliEntry30() {
   if (true) {
@@ -24895,29 +25218,29 @@ function _isCliEntry30() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL34(path57.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL35(path59.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs56.realpathSync(fileURLToPath40(import.meta.url));
-    const argv = fs56.realpathSync(path57.resolve(process.argv[1]));
+    const here = fs58.realpathSync(fileURLToPath41(import.meta.url));
+    const argv = fs58.realpathSync(path59.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
 if (_isCliEntry30()) {
-  process.exit(main39());
+  process.exit(main40());
 }
 
 // src/scripts/hooks/end_review_nudge_hook.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
 import * as crypto5 from "node:crypto";
-import * as fs57 from "node:fs";
+import * as fs59 from "node:fs";
 import * as os6 from "node:os";
-import * as path58 from "node:path";
-import { fileURLToPath as fileURLToPath41, pathToFileURL as pathToFileURL35 } from "node:url";
+import * as path60 from "node:path";
+import { fileURLToPath as fileURLToPath42, pathToFileURL as pathToFileURL36 } from "node:url";
 
 // src/scripts/_lib/review_skipped_record.ts
 function isNonNegInt(n) {
@@ -24964,19 +25287,19 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   const homeDir = opts.homeDir ?? os6.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs57.realpathSync(homeDir);
-    const realPath = fs57.realpathSync(rawPath);
-    const relative9 = path58.relative(realHome, realPath);
-    if (relative9 === "" || relative9.startsWith("..") || path58.isAbsolute(relative9)) {
+    const realHome = fs59.realpathSync(homeDir);
+    const realPath = fs59.realpathSync(rawPath);
+    const relative9 = path60.relative(realHome, realPath);
+    if (relative9 === "" || relative9.startsWith("..") || path60.isAbsolute(relative9)) {
       return false;
     }
-    const { size } = fs57.statSync(realPath);
+    const { size } = fs59.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
   }
 }
-var EXIT_WARN9 = 2;
+var EXIT_WARN10 = 2;
 function parseNumstat(raw) {
   const rows = [];
   for (const line of raw.split("\n")) {
@@ -25049,7 +25372,7 @@ function totalNonDocMutatedLinesWithMeasure(cwd) {
   );
   return { lines: trackedLines + untrackedLines, measure: "exact" };
 }
-function isObject5(v) {
+function isObject6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function str3(v) {
@@ -25069,16 +25392,16 @@ function scanTranscriptForReviewer(transcriptText) {
     } catch {
       continue;
     }
-    if (!isObject5(obj) || obj["type"] !== "assistant") continue;
+    if (!isObject6(obj) || obj["type"] !== "assistant") continue;
     const msg = obj["message"];
-    if (!isObject5(msg)) continue;
+    if (!isObject6(msg)) continue;
     const content = msg["content"];
     if (!Array.isArray(content)) continue;
     for (const blk of content) {
-      if (!isObject5(blk) || blk["type"] !== "tool_use") continue;
+      if (!isObject6(blk) || blk["type"] !== "tool_use") continue;
       const name = str3(blk["name"]);
       const input = blk["input"];
-      const inputObj = isObject5(input) ? input : {};
+      const inputObj = isObject6(input) ? input : {};
       if (DISPATCH_TOOL_RE.test(name)) {
         const label = [
           str3(inputObj["description"]),
@@ -25113,19 +25436,19 @@ function appendReviewSkippedTelemetry(workspaceRoot2, diffLines, mutationMeasure
   });
   if (errors.length || line === null) return;
   try {
-    const dir = path58.join(workspaceRoot2, "agents", "runtime", "state", "audit");
-    fs57.mkdirSync(dir, { recursive: true });
-    const file = path58.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs57.appendFileSync(file, `${JSON.stringify(line)}
+    const dir = path60.join(workspaceRoot2, "agents", "runtime", "state", "audit");
+    fs59.mkdirSync(dir, { recursive: true });
+    const file = path60.join(dir, `${ts.slice(0, 7)}.jsonl`);
+    fs59.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
 }
 function sessionStateDir(workspaceRoot2) {
-  return path58.join(workspaceRoot2, "agents", "runtime", "state", "end-review-nudge");
+  return path60.join(workspaceRoot2, "agents", "runtime", "state", "end-review-nudge");
 }
 function sessionStateFile(workspaceRoot2, sessionKey) {
-  return path58.join(sessionStateDir(workspaceRoot2), `${sessionKey}.json`);
+  return path60.join(sessionStateDir(workspaceRoot2), `${sessionKey}.json`);
 }
 function deriveSessionKey(envelope, payload) {
   const raw = str3(envelope["session_id"]) || str3(payload["transcript_path"] ?? payload["transcriptPath"]);
@@ -25134,7 +25457,7 @@ function deriveSessionKey(envelope, payload) {
 }
 function hasFiredThisSession(workspaceRoot2, sessionKey) {
   try {
-    return fs57.existsSync(sessionStateFile(workspaceRoot2, sessionKey));
+    return fs59.existsSync(sessionStateFile(workspaceRoot2, sessionKey));
   } catch {
     return false;
   }
@@ -25148,7 +25471,7 @@ function markFiredThisSession(workspaceRoot2, sessionKey, ts) {
 function _read_stdin3() {
   return readHookStdin();
 }
-function main40() {
+function main41() {
   const [envelope, payload] = unwrap(_read_stdin3(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
@@ -25177,7 +25500,7 @@ function main40() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs57.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs59.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -25198,7 +25521,7 @@ function main40() {
     })}
 `
   );
-  return EXIT_WARN9;
+  return EXIT_WARN10;
 }
 function _isCliEntry31() {
   if (true) {
@@ -25207,29 +25530,29 @@ function _isCliEntry31() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL35(path58.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL36(path60.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs57.realpathSync(fileURLToPath41(import.meta.url));
-    const argv = fs57.realpathSync(path58.resolve(process.argv[1]));
+    const here = fs59.realpathSync(fileURLToPath42(import.meta.url));
+    const argv = fs59.realpathSync(path60.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
 if (_isCliEntry31()) {
-  process.exit(main40());
+  process.exit(main41());
 }
 
 // src/scripts/hooks/turn_end_gate_hook.ts
 import * as crypto6 from "node:crypto";
-import * as fs58 from "node:fs";
-import * as path59 from "node:path";
-import { fileURLToPath as fileURLToPath42, pathToFileURL as pathToFileURL36 } from "node:url";
+import * as fs60 from "node:fs";
+import * as path61 from "node:path";
+import { fileURLToPath as fileURLToPath43, pathToFileURL as pathToFileURL37 } from "node:url";
 var EXIT_BLOCK4 = 1;
-var EXIT_ALLOW17 = 0;
+var EXIT_ALLOW18 = 0;
 var TRANSCRIPT_READ_MAX_BYTES = 8 * 1024 * 1024;
 function stripFencedBlocks(text) {
   const out = [];
@@ -25333,7 +25656,7 @@ function detectPromissory(reply) {
 }
 function readLanguagePin(workspaceRoot2) {
   try {
-    const raw = fs58.readFileSync(path59.join(workspaceRoot2, STATE_FILE5), "utf-8");
+    const raw = fs60.readFileSync(path61.join(workspaceRoot2, STATE_FILE5), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       const lang = decoded["language"];
@@ -25355,18 +25678,44 @@ function detectLanguage(reply, pinned) {
     reason: `the pinned reply language is "${pinned}" but the reply classifies as "${verdict.language}" (${verdict.de_markers} de / ${verdict.en_markers} en markers; code, quotes, tables, URLs and paths excluded, then scored lead-first by the same classifier that sets the pin)`
   };
 }
+var _EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var _VERIFY_RE = /\b(test|tests|vitest|jest|pytest|phpunit|pest|tsc|eslint|ruff|mypy|pyright|clippy|typecheck|lint|build|ci|preflight|smoke[-_:a-z]*|check[-_:a-z]*|validate[-_:a-z]*)\b|\b(task|npm|pnpm|yarn|composer|cargo|go|make|php artisan|bun)\s+(run\s+)?\S*(test|check|lint|build|ci|typecheck)/i;
+function isVerificationCommand(command) {
+  return _VERIFY_RE.test(command);
+}
+function detectUnverifiedEdit(toolCalls) {
+  let lastEdit = -1;
+  for (let i = 0; i < toolCalls.length; i += 1) {
+    if (_EDIT_TOOLS.has(toolCalls[i].name)) lastEdit = i;
+  }
+  if (lastEdit === -1) return null;
+  for (let i = lastEdit + 1; i < toolCalls.length; i += 1) {
+    const c = toolCalls[i];
+    if (c.name === "Bash" && c.command !== void 0 && isVerificationCommand(c.command)) {
+      return null;
+    }
+  }
+  const edited = toolCalls[lastEdit].path;
+  return {
+    detector: "verification",
+    // The path, never the diff: the evidence span is quoted into a refusal,
+    // and `ToolCall` is shaped so a file body cannot reach it.
+    evidence: edited ?? toolCalls[lastEdit].name,
+    reason: "this turn changed a file and then ran no verification command \u2014 no test, type-check, lint or build call follows the last edit (verify-before-complete: a claim without a fresh run is unverified)"
+  };
+}
 function stateDir(workspaceRoot2) {
-  return path59.join(workspaceRoot2, "agents", "runtime", "state", "turn-end-gate");
+  return path61.join(workspaceRoot2, "agents", "runtime", "state", "turn-end-gate");
 }
 function sessionStateFile2(workspaceRoot2, sessionKey) {
-  return path59.join(stateDir(workspaceRoot2), `${sessionKey}.json`);
+  return path61.join(stateDir(workspaceRoot2), `${sessionKey}.json`);
 }
 function deriveSessionKey2(sessionId2) {
   return crypto6.createHash("sha256").update(sessionId2).digest("hex").slice(0, 32);
 }
 function alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal) {
   try {
-    const raw = fs58.readFileSync(sessionStateFile2(workspaceRoot2, sessionKey), "utf-8");
+    const raw = fs60.readFileSync(sessionStateFile2(workspaceRoot2, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -25387,19 +25736,20 @@ function markRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal, detector) {
   }
 }
 function readTranscriptTail(transcriptPath, opts = {}) {
-  const empty = { lastAssistant: "", turnOrdinal: 0 };
+  const empty = { lastAssistant: "", turnOrdinal: 0, toolCalls: [] };
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs58.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs60.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs58.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs60.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
   let lastAssistant = "";
   let turnOrdinal = 0;
+  let toolCalls = [];
   for (const rawLine of lines) {
     const line = rawLine.trim();
     if (!line) continue;
@@ -25416,15 +25766,42 @@ function readTranscriptTail(transcriptPath, opts = {}) {
     if (role !== "assistant" && role !== "user") continue;
     const msg = entry["message"];
     if (typeof msg !== "object" || msg === null || Array.isArray(msg)) continue;
-    const text = _messageText(msg["content"]);
+    const content = msg["content"];
+    if (role === "assistant") {
+      toolCalls.push(..._toolCalls(content));
+    }
+    const text = _messageText(content);
     if (text === null) continue;
     if (role === "assistant") {
       lastAssistant = text;
     } else if (!isSyntheticPrompt(text)) {
       turnOrdinal += 1;
+      toolCalls = [];
     }
   }
-  return { lastAssistant: lastAssistant.trim(), turnOrdinal };
+  return { lastAssistant: lastAssistant.trim(), turnOrdinal, toolCalls };
+}
+function _toolCalls(content) {
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const blk of content) {
+    if (typeof blk !== "object" || blk === null || Array.isArray(blk)) continue;
+    const b = blk;
+    if (b["type"] !== "tool_use") continue;
+    const name = b["name"];
+    if (typeof name !== "string") continue;
+    const input = b["input"];
+    const call = { name };
+    if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+      const inp = input;
+      const cmd = inp["command"];
+      if (typeof cmd === "string") call.command = cmd;
+      const p = inp["file_path"] ?? inp["path"] ?? inp["notebook_path"];
+      if (typeof p === "string") call.path = p;
+    }
+    out.push(call);
+  }
+  return out;
 }
 function _messageText(content) {
   if (typeof content === "string") return content;
@@ -25448,7 +25825,12 @@ function _isOn(v) {
   return null;
 }
 function readGateSettings(workspaceRoot2) {
-  const off = { enabled: false, promissory: true, language: true };
+  const off = {
+    enabled: false,
+    promissory: true,
+    language: true,
+    verification: true
+  };
   let settings;
   try {
     settings = load_agent_settings({ cwd: workspaceRoot2 });
@@ -25467,35 +25849,36 @@ function readGateSettings(workspaceRoot2) {
   return {
     enabled: flag("enabled", false),
     promissory: flag("promissory", true),
-    language: flag("language", true)
+    language: flag("language", true),
+    verification: flag("verification", true)
   };
 }
 function str4(v) {
   return typeof v === "string" ? v : "";
 }
-function main41() {
+function main42() {
   let envelope;
   let payload;
   try {
     [envelope, payload] = unwrap(readHookStdin(), "claude");
   } catch {
-    return EXIT_ALLOW17;
+    return EXIT_ALLOW18;
   }
-  if (payload["stop_hook_active"] === true) return EXIT_ALLOW17;
+  if (payload["stop_hook_active"] === true) return EXIT_ALLOW18;
   const workspaceRoot2 = str4(envelope["workspace_root"]) || process.cwd();
   const settings = readGateSettings(workspaceRoot2);
-  if (!settings.enabled) return EXIT_ALLOW17;
+  if (!settings.enabled) return EXIT_ALLOW18;
   const transcriptPath = str4(
     payload["transcript_path"] ?? payload["transcriptPath"]
   );
-  const { lastAssistant, turnOrdinal } = readTranscriptTail(transcriptPath, {
+  const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
     maxBytes: TRANSCRIPT_READ_MAX_BYTES
   });
-  if (!lastAssistant) return EXIT_ALLOW17;
+  if (!lastAssistant) return EXIT_ALLOW18;
   const sessionKey = deriveSessionKey2(
     str4(envelope["session_id"]) || "unknown-session"
   );
-  if (alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal)) return EXIT_ALLOW17;
+  if (alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal)) return EXIT_ALLOW18;
   const findings = [];
   if (settings.promissory) {
     const f = detectPromissory(lastAssistant);
@@ -25505,7 +25888,11 @@ function main41() {
     const f = detectLanguage(lastAssistant, readLanguagePin(workspaceRoot2));
     if (f) findings.push(f);
   }
-  if (findings.length === 0) return EXIT_ALLOW17;
+  if (settings.verification) {
+    const f = detectUnverifiedEdit(toolCalls);
+    if (f) findings.push(f);
+  }
+  if (findings.length === 0) return EXIT_ALLOW18;
   markRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal, findings[0].detector);
   const lines = findings.map(
     (f) => `  \xB7 ${f.detector}: ${f.reason}
@@ -25514,7 +25901,7 @@ function main41() {
   process.stderr.write(
     `turn-end-gate: REFUSED \u2014 this turn is not finished.
 ${lines.join("\n")}
-  Do the promised work now, or correct the language, then end the turn.
+  Do the promised work now, correct the language, or run the verification the edit needs, then end the turn.
   This turn will not be refused a second time.
   Disable: hooks.turn_end_gate.enabled: false in .agent-settings.yml
 `
@@ -25528,30 +25915,30 @@ function _isCliEntry32() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL36(path59.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL37(path61.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs58.realpathSync(fileURLToPath42(import.meta.url));
-    const argv = fs58.realpathSync(path59.resolve(process.argv[1]));
+    const here = fs60.realpathSync(fileURLToPath43(import.meta.url));
+    const argv = fs60.realpathSync(path61.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
 if (_isCliEntry32()) {
-  process.exit(main41());
+  process.exit(main42());
 }
 
 // src/scripts/hooks/edit_shape_hook.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
 import * as crypto7 from "node:crypto";
-import * as fs59 from "node:fs";
-import * as path60 from "node:path";
-import { fileURLToPath as fileURLToPath43, pathToFileURL as pathToFileURL37 } from "node:url";
-var EXIT_ALLOW18 = 0;
-var EXIT_WARN10 = 2;
+import * as fs61 from "node:fs";
+import * as path62 from "node:path";
+import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL38 } from "node:url";
+var EXIT_ALLOW19 = 0;
+var EXIT_WARN11 = 2;
 var MIN_FILE_LINES = 50;
 var MAX_DIFF_RATIO = 0.2;
 var EXEMPT_PATH_PATTERNS = [
@@ -25566,7 +25953,7 @@ var EXEMPT_PATH_PATTERNS = [
   /(^|\/)agents\/runtime\//i
   // agents/runtime/**
 ];
-function isObject6(v) {
+function isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function str5(v) {
@@ -25602,7 +25989,7 @@ function effectiveDiffLines(cwd, relPath) {
 }
 function fileLineCount(absPath) {
   try {
-    const text = fs59.readFileSync(absPath, "utf8");
+    const text = fs61.readFileSync(absPath, "utf8");
     if (text.length === 0) return 0;
     return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
   } catch {
@@ -25619,11 +26006,11 @@ function deriveSessionKey3(envelope, payload) {
   return crypto7.createHash("sha256").update(material).digest("hex");
 }
 function sessionStateFile3(workspaceRoot2, sessionKey) {
-  return path60.join(workspaceRoot2, "agents", "runtime", "state", "edit-shape", `${sessionKey}.json`);
+  return path62.join(workspaceRoot2, "agents", "runtime", "state", "edit-shape", `${sessionKey}.json`);
 }
 function hasFiredThisSession2(workspaceRoot2, sessionKey) {
   try {
-    return fs59.existsSync(sessionStateFile3(workspaceRoot2, sessionKey));
+    return fs61.existsSync(sessionStateFile3(workspaceRoot2, sessionKey));
   } catch {
     return false;
   }
@@ -25641,29 +26028,29 @@ function extractToolName2(payload) {
 }
 function extractFilePath(payload) {
   const ti = payload["tool_input"] ?? payload["toolInput"] ?? payload["input"];
-  if (!isObject6(ti)) return "";
+  if (!isObject7(ti)) return "";
   return str5(ti["file_path"] ?? ti["path"] ?? ti["filePath"]);
 }
-function main42() {
+function main43() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
     const event = str5(envelope["event"]);
-    if (event !== "" && event !== "post_tool_use") return EXIT_ALLOW18;
+    if (event !== "" && event !== "post_tool_use") return EXIT_ALLOW19;
     const toolName = extractToolName2(payload);
-    if (toolName !== "Write") return EXIT_ALLOW18;
+    if (toolName !== "Write") return EXIT_ALLOW19;
     const filePath = extractFilePath(payload);
-    if (!filePath) return EXIT_ALLOW18;
+    if (!filePath) return EXIT_ALLOW19;
     const workspaceRoot2 = str5(envelope["workspace_root"]).trim() || process.cwd();
-    const absPath = path60.isAbsolute(filePath) ? filePath : path60.resolve(workspaceRoot2, filePath);
-    const relPath = path60.relative(workspaceRoot2, absPath);
-    if (isExemptPath(relPath) || isExemptPath(absPath)) return EXIT_ALLOW18;
+    const absPath = path62.isAbsolute(filePath) ? filePath : path62.resolve(workspaceRoot2, filePath);
+    const relPath = path62.relative(workspaceRoot2, absPath);
+    if (isExemptPath(relPath) || isExemptPath(absPath)) return EXIT_ALLOW19;
     const fileLines = fileLineCount(absPath);
-    if (fileLines < MIN_FILE_LINES) return EXIT_ALLOW18;
+    if (fileLines < MIN_FILE_LINES) return EXIT_ALLOW19;
     const diffLines = effectiveDiffLines(workspaceRoot2, relPath.startsWith("..") ? absPath : relPath);
-    if (diffLines === 0) return EXIT_ALLOW18;
-    if (diffLines / fileLines > MAX_DIFF_RATIO) return EXIT_ALLOW18;
+    if (diffLines === 0) return EXIT_ALLOW19;
+    if (diffLines / fileLines > MAX_DIFF_RATIO) return EXIT_ALLOW19;
     const sessionKey = deriveSessionKey3(envelope, payload);
-    if (hasFiredThisSession2(workspaceRoot2, sessionKey)) return EXIT_ALLOW18;
+    if (hasFiredThisSession2(workspaceRoot2, sessionKey)) return EXIT_ALLOW19;
     markFiredThisSession2(workspaceRoot2, sessionKey);
     process.stdout.write(
       `${JSON.stringify({
@@ -25673,9 +26060,9 @@ function main42() {
       })}
 `
     );
-    return EXIT_WARN10;
+    return EXIT_WARN11;
   } catch {
-    return EXIT_ALLOW18;
+    return EXIT_ALLOW19;
   }
 }
 function _isCliEntry33() {
@@ -25685,29 +26072,29 @@ function _isCliEntry33() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL37(path60.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL38(path62.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs59.realpathSync(fileURLToPath43(import.meta.url));
-    const argv = fs59.realpathSync(path60.resolve(process.argv[1]));
+    const here = fs61.realpathSync(fileURLToPath44(import.meta.url));
+    const argv = fs61.realpathSync(path62.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
 if (_isCliEntry33()) {
-  process.exit(main42());
+  process.exit(main43());
 }
 
 // src/scripts/hooks/reread_guard_hook.ts
 import * as crypto8 from "node:crypto";
-import * as fs60 from "node:fs";
-import * as path61 from "node:path";
-import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL38 } from "node:url";
-var EXIT_ALLOW19 = 0;
-var EXIT_WARN11 = 2;
+import * as fs62 from "node:fs";
+import * as path63 from "node:path";
+import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL39 } from "node:url";
+var EXIT_ALLOW20 = 0;
+var EXIT_WARN12 = 2;
 var EXEMPT_PATH_PATTERNS2 = [
   /(^|\/)dist\//i,
   // dist/**
@@ -25722,7 +26109,7 @@ var EXEMPT_PATH_PATTERNS2 = [
 ];
 var READ_TOOLS = /* @__PURE__ */ new Set(["Read"]);
 var WRITE_TOOLS2 = /* @__PURE__ */ new Set(["Edit", "Write"]);
-function isObject7(v) {
+function isObject8(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function str6(v) {
@@ -25741,16 +26128,16 @@ function deriveSessionKey4(envelope, payload) {
   return crypto8.createHash("sha256").update(material).digest("hex");
 }
 function ledgerFile(workspaceRoot2, sessionKey) {
-  return path61.join(workspaceRoot2, "agents", "runtime", "state", "reread-guard", `${sessionKey}.json`);
+  return path63.join(workspaceRoot2, "agents", "runtime", "state", "reread-guard", `${sessionKey}.json`);
 }
 function readLedger(workspaceRoot2, sessionKey) {
   try {
-    const parsed = JSON.parse(fs60.readFileSync(ledgerFile(workspaceRoot2, sessionKey), "utf8"));
-    if (!isObject7(parsed)) return emptyLedger();
+    const parsed = JSON.parse(fs62.readFileSync(ledgerFile(workspaceRoot2, sessionKey), "utf8"));
+    if (!isObject8(parsed)) return emptyLedger();
     return {
-      reads: isObject7(parsed["reads"]) ? parsed["reads"] : {},
-      writes: isObject7(parsed["writes"]) ? parsed["writes"] : {},
-      fired: isObject7(parsed["fired"]) ? parsed["fired"] : {}
+      reads: isObject8(parsed["reads"]) ? parsed["reads"] : {},
+      writes: isObject8(parsed["writes"]) ? parsed["writes"] : {},
+      fired: isObject8(parsed["fired"]) ? parsed["fired"] : {}
     };
   } catch {
     return emptyLedger();
@@ -25767,7 +26154,7 @@ function extractToolName3(payload) {
 }
 function extractToolInput2(payload) {
   const ti = payload["tool_input"] ?? payload["toolInput"] ?? payload["input"];
-  return isObject7(ti) ? ti : {};
+  return isObject8(ti) ? ti : {};
 }
 function extractFilePath2(toolInput) {
   return str6(toolInput["file_path"] ?? toolInput["path"] ?? toolInput["filePath"]);
@@ -25786,41 +26173,41 @@ function buildDuplicateReadLine(relPath, earlierTs) {
 function buildPostEditReadLine(relPath) {
   return `re-read guard: this session just edited ${relPath} \u2014 a full-file re-read re-pays for content you already have; a ranged Read (offset/limit) over the edited hunk is enough to verify the change.`;
 }
-function main43() {
+function main44() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
     const event = str6(envelope["event"]);
-    if (event !== "" && event !== "pre_tool_use") return EXIT_ALLOW19;
+    if (event !== "" && event !== "pre_tool_use") return EXIT_ALLOW20;
     const toolName = extractToolName3(payload);
     const isRead = READ_TOOLS.has(toolName);
     const isWrite = WRITE_TOOLS2.has(toolName);
-    if (!isRead && !isWrite) return EXIT_ALLOW19;
+    if (!isRead && !isWrite) return EXIT_ALLOW20;
     const toolInput = extractToolInput2(payload);
     const filePath = extractFilePath2(toolInput);
-    if (!filePath) return EXIT_ALLOW19;
+    if (!filePath) return EXIT_ALLOW20;
     const workspaceRoot2 = str6(envelope["workspace_root"]).trim() || process.cwd();
-    const absPath = path61.isAbsolute(filePath) ? filePath : path61.resolve(workspaceRoot2, filePath);
-    const relPath = path61.relative(workspaceRoot2, absPath);
-    if (isExemptPath2(relPath) || isExemptPath2(absPath)) return EXIT_ALLOW19;
+    const absPath = path63.isAbsolute(filePath) ? filePath : path63.resolve(workspaceRoot2, filePath);
+    const relPath = path63.relative(workspaceRoot2, absPath);
+    if (isExemptPath2(relPath) || isExemptPath2(absPath)) return EXIT_ALLOW20;
     const sessionKey = deriveSessionKey4(envelope, payload);
     const ledger = readLedger(workspaceRoot2, sessionKey);
     const key = relPath.startsWith("..") ? absPath : relPath;
     if (isWrite) {
       ledger.writes[key] = Date.now();
       writeLedger(workspaceRoot2, sessionKey, ledger);
-      return EXIT_ALLOW19;
+      return EXIT_ALLOW20;
     }
     if (isRangedRead(toolInput)) {
-      return EXIT_ALLOW19;
+      return EXIT_ALLOW20;
     }
     let mtime;
     let size;
     try {
-      const st = fs60.statSync(absPath);
+      const st = fs62.statSync(absPath);
       mtime = st.mtimeMs;
       size = st.size;
     } catch {
-      return EXIT_ALLOW19;
+      return EXIT_ALLOW20;
     }
     const prior = ledger.reads[key];
     const ownWrite = ledger.writes[key];
@@ -25835,7 +26222,7 @@ function main43() {
     if (ownWrite !== void 0) delete ledger.writes[key];
     if (advisory !== null) ledger.fired[key] = true;
     writeLedger(workspaceRoot2, sessionKey, ledger);
-    if (advisory === null) return EXIT_ALLOW19;
+    if (advisory === null) return EXIT_ALLOW20;
     process.stdout.write(
       `${JSON.stringify({
         decision: "warn",
@@ -25844,9 +26231,9 @@ function main43() {
       })}
 `
     );
-    return EXIT_WARN11;
+    return EXIT_WARN12;
   } catch {
-    return EXIT_ALLOW19;
+    return EXIT_ALLOW20;
   }
 }
 function _isCliEntry34() {
@@ -25856,27 +26243,27 @@ function _isCliEntry34() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL38(path61.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL39(path63.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs60.realpathSync(fileURLToPath44(import.meta.url));
-    const argv = fs60.realpathSync(path61.resolve(process.argv[1]));
+    const here = fs62.realpathSync(fileURLToPath45(import.meta.url));
+    const argv = fs62.realpathSync(path63.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
 if (_isCliEntry34()) {
-  process.exit(main43());
+  process.exit(main44());
 }
 
 // src/scripts/hooks/session_eol_hook.ts
-import * as fs62 from "node:fs";
-import * as path64 from "node:path";
+import * as fs64 from "node:fs";
+import * as path66 from "node:path";
 import process11 from "node:process";
-import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL39 } from "node:url";
+import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL40 } from "node:url";
 
 // src/config/recycle-threshold-budget.json
 var recycle_threshold_budget_default = {
@@ -25894,13 +26281,13 @@ var recycle_threshold_budget_default = {
 
 // src/scripts/_lib/session_eol.ts
 import * as crypto9 from "node:crypto";
-import * as fs61 from "node:fs";
-import * as path63 from "node:path";
+import * as fs63 from "node:fs";
+import * as path65 from "node:path";
 
 // src/scripts/_lib/cc_transcript.ts
-import * as path62 from "node:path";
+import * as path64 from "node:path";
 import { homedir as homedir6 } from "node:os";
-var DEFAULT_PROJECTS_ROOT = path62.join(homedir6(), ".claude", "projects");
+var DEFAULT_PROJECTS_ROOT = path64.join(homedir6(), ".claude", "projects");
 function billableInputTokens(u) {
   return u.input_tokens + u.cache_read_input_tokens + u.cache_creation_input_tokens;
 }
@@ -26009,17 +26396,17 @@ function scanEolSlice(text, prior) {
   return next;
 }
 function eolStateDir(workspaceRoot2) {
-  return path63.join(workspaceRoot2, "agents", "runtime", "state", "session-eol");
+  return path65.join(workspaceRoot2, "agents", "runtime", "state", "session-eol");
 }
 function eolStateFile(workspaceRoot2, sessionKey) {
-  return path63.join(eolStateDir(workspaceRoot2), `${sessionKey}.json`);
+  return path65.join(eolStateDir(workspaceRoot2), `${sessionKey}.json`);
 }
 function eolSessionKey(raw) {
   return crypto9.createHash("sha256").update(raw || "unknown-session").digest("hex");
 }
 function readNewCompleteLines(filePath, fromByte) {
   try {
-    const { size } = fs61.statSync(filePath);
+    const { size } = fs63.statSync(filePath);
     if (size < fromByte) {
       return { text: "", nextOffset: 0, truncated: true };
     }
@@ -26028,11 +26415,11 @@ function readNewCompleteLines(filePath, fromByte) {
     }
     const length = size - fromByte;
     const buffer = Buffer.alloc(length);
-    const fd = fs61.openSync(filePath, "r");
+    const fd = fs63.openSync(filePath, "r");
     try {
-      fs61.readSync(fd, buffer, 0, length, fromByte);
+      fs63.readSync(fd, buffer, 0, length, fromByte);
     } finally {
-      fs61.closeSync(fd);
+      fs63.closeSync(fd);
     }
     const lastNewline = buffer.lastIndexOf(10);
     if (lastNewline === -1) {
@@ -26049,21 +26436,21 @@ function readNewCompleteLines(filePath, fromByte) {
 }
 
 // src/scripts/hooks/session_eol_hook.ts
-var EXIT_WARN12 = 2;
+var EXIT_WARN13 = 2;
 var THRESHOLD_OVERRIDE_ENV = "AGENT_RECYCLE_THRESHOLD_TOKENS";
-var CONTEXT_FILL_REL = path64.join("agents", "runtime", "state", "context-fill.json");
+var CONTEXT_FILL_REL = path66.join("agents", "runtime", "state", "context-fill.json");
 function str7(value) {
   return typeof value === "string" ? value : "";
 }
-var stateFile2 = eolStateFile;
+var stateFile3 = eolStateFile;
 function deriveSessionKey5(envelope, payload) {
   return eolSessionKey(
     str7(envelope["session_id"]) || str7(payload["transcript_path"] ?? payload["transcriptPath"])
   );
 }
-function readState2(file) {
+function readState3(file) {
   try {
-    const parsed = JSON.parse(fs62.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs64.readFileSync(file, "utf-8"));
     if (parsed && typeof parsed === "object" && parsed.schema_version === 1 && parsed.counters && typeof parsed.counters.scanned_bytes === "number") {
       return {
         schema_version: 1,
@@ -26095,7 +26482,7 @@ function buildAdvisoryLine3(tokens, threshold) {
 }
 function writeContextFill(workspaceRoot2, tokens, threshold, ts) {
   try {
-    atomic_write_json(path64.join(workspaceRoot2, CONTEXT_FILL_REL), {
+    atomic_write_json(path66.join(workspaceRoot2, CONTEXT_FILL_REL), {
       schema_version: 1,
       final_context_tokens: tokens,
       recycle_threshold_tokens: threshold,
@@ -26105,7 +26492,7 @@ function writeContextFill(workspaceRoot2, tokens, threshold, ts) {
   } catch {
   }
 }
-function main44() {
+function main45() {
   const [envelope, payload] = unwrap(readHookStdin(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
@@ -26122,8 +26509,8 @@ function main44() {
     return 0;
   }
   const sessionKey = deriveSessionKey5(envelope, payload);
-  const file = stateFile2(workspaceRoot2, sessionKey);
-  const state = readState2(file);
+  const file = stateFile3(workspaceRoot2, sessionKey);
+  const state = readState3(file);
   let counters = state.counters;
   const read = readNewCompleteLines(transcriptPath, counters.scanned_bytes);
   if (read.truncated) {
@@ -26160,7 +26547,7 @@ function main44() {
       })}
 `
     );
-    return EXIT_WARN12;
+    return EXIT_WARN13;
   }
   return 0;
 }
@@ -26171,20 +26558,20 @@ function _isCliEntry35() {
   if (process11.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL39(path64.resolve(process11.argv[1])).href;
+  const argvUrl = pathToFileURL40(path66.resolve(process11.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs62.realpathSync(fileURLToPath45(import.meta.url));
-    const argv = fs62.realpathSync(path64.resolve(process11.argv[1]));
+    const here = fs64.realpathSync(fileURLToPath46(import.meta.url));
+    const argv = fs64.realpathSync(path66.resolve(process11.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
 if (_isCliEntry35()) {
-  process11.exit(main44());
+  process11.exit(main45());
 }
 
 // src/scripts/hooks/concern_registry.ts
@@ -26219,13 +26606,14 @@ var CONCERN_REGISTRY = {
   "src/scripts/hooks/rtk_wrap_hook.ts": main33,
   "src/scripts/hooks/design_slop_hook.ts": main35,
   "src/scripts/hooks/code_graph_nudge_hook.ts": main36,
-  "src/scripts/hooks/orchestration_record_hook.ts": main38,
-  "src/scripts/hooks/delegation_nudge_hook.ts": main39,
-  "src/scripts/hooks/end_review_nudge_hook.ts": main40,
-  "src/scripts/hooks/turn_end_gate_hook.ts": main41,
-  "src/scripts/hooks/edit_shape_hook.ts": main42,
-  "src/scripts/hooks/reread_guard_hook.ts": main43,
-  "src/scripts/hooks/session_eol_hook.ts": main44
+  "src/scripts/hooks/ui_route_nudge_hook.ts": main37,
+  "src/scripts/hooks/orchestration_record_hook.ts": main39,
+  "src/scripts/hooks/delegation_nudge_hook.ts": main40,
+  "src/scripts/hooks/end_review_nudge_hook.ts": main41,
+  "src/scripts/hooks/turn_end_gate_hook.ts": main42,
+  "src/scripts/hooks/edit_shape_hook.ts": main43,
+  "src/scripts/hooks/reread_guard_hook.ts": main44,
+  "src/scripts/hooks/session_eol_hook.ts": main45
 };
 
 // src/scripts/hooks/host_semantics.ts
@@ -26279,14 +26667,14 @@ function emitFor(platform, event, severity, reasons, legacyExit) {
 
 // src/scripts/hooks/dispatch_hook.ts
 var _IN_BUNDLE = true;
-var REPO_ROOT = path65.resolve(
-  path65.dirname(fileURLToPath46(import.meta.url)),
+var REPO_ROOT = path67.resolve(
+  path67.dirname(fileURLToPath47(import.meta.url)),
   ..._IN_BUNDLE ? ["..", ".."] : ["..", "..", ".."]
 );
-var MANIFEST_PATH = path65.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
-var EXIT_ALLOW20 = 0;
+var MANIFEST_PATH = path67.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
+var EXIT_ALLOW21 = 0;
 var EXIT_BLOCK5 = 1;
-var EXIT_WARN13 = 2;
+var EXIT_WARN14 = 2;
 var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "session_start",
   "session_end",
@@ -26298,9 +26686,9 @@ var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "agent_error"
 ]);
 var _SEVERITY_BY_EXIT = {
-  [EXIT_ALLOW20]: "allow",
+  [EXIT_ALLOW21]: "allow",
   [EXIT_BLOCK5]: "block",
-  [EXIT_WARN13]: "warn"
+  [EXIT_WARN14]: "warn"
 };
 function _isObject14(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -26335,7 +26723,7 @@ function _parse_concern_stdout(stdout_text) {
   return _isObject14(parsed) ? parsed : { _raw: parsed };
 }
 function _load_yaml3(p) {
-  const text = fs63.readFileSync(p, "utf-8");
+  const text = fs65.readFileSync(p, "utf-8");
   const data = (0, import_yaml6.parse)(text, { version: "1.1" });
   return _isObject14(data) ? data : {};
 }
@@ -26492,7 +26880,7 @@ function _maybe_capture_payload(args, payload_text) {
   }
   try {
     const target = _expanduser3(capture_dir);
-    fs63.mkdirSync(target, { recursive: true });
+    fs65.mkdirSync(target, { recursive: true });
     let payload;
     try {
       payload = payload_text.trim() ? JSON.parse(payload_text) : {};
@@ -26509,8 +26897,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`;
-    fs63.writeFileSync(
-      path65.join(target, fname),
+    fs65.writeFileSync(
+      path67.join(target, fname),
       _py_json_dumps2(record, 2) + "\n",
       { encoding: "utf-8" }
     );
@@ -26521,7 +26909,7 @@ function _maybe_capture_payload(args, payload_text) {
 function _expanduser3(p) {
   if (p === "~" || p.startsWith("~/")) {
     const home = process.env["HOME"] || process.env["USERPROFILE"] || "";
-    return path65.join(home, p.slice(1));
+    return path67.join(home, p.slice(1));
   }
   return p;
 }
@@ -26553,25 +26941,25 @@ function _resolve_tsx_invocation2(scriptPath, scriptArgs) {
   const walkUp = (start) => {
     let dir = start;
     for (; ; ) {
-      const candidate = path65.join(dir, "node_modules", ".bin", binName);
+      const candidate = path67.join(dir, "node_modules", ".bin", binName);
       if (_isFile7(candidate)) {
         return candidate;
       }
-      const parent = path65.dirname(dir);
+      const parent = path67.dirname(dir);
       if (parent === dir) {
         return null;
       }
       dir = parent;
     }
   };
-  const tsx = walkUp(path65.dirname(scriptPath)) ?? walkUp(path65.dirname(fileURLToPath46(import.meta.url)));
+  const tsx = walkUp(path67.dirname(scriptPath)) ?? walkUp(path67.dirname(fileURLToPath47(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 = path65.join(REPO_ROOT, String(concern["script"]));
+  const scriptAbs = path67.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());
@@ -26648,7 +27036,7 @@ function _run_concern(concern, envelope) {
       return _run_concern_inproc(inproc, concern, envelope);
     }
   }
-  const script = path65.join(REPO_ROOT, String(concern["script"]));
+  const script = path67.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"));
@@ -26705,7 +27093,7 @@ function _run_concern(concern, envelope) {
 }
 function _isFile7(p) {
   try {
-    return fs63.statSync(p).isFile();
+    return fs65.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -26717,20 +27105,20 @@ function _reduce(rcs) {
   if (rcs.some((rc) => rc === EXIT_BLOCK5)) {
     return EXIT_BLOCK5;
   }
-  if (rcs.some((rc) => rc === EXIT_WARN13)) {
-    return EXIT_WARN13;
+  if (rcs.some((rc) => rc === EXIT_WARN14)) {
+    return EXIT_WARN14;
   }
-  return EXIT_ALLOW20;
+  return EXIT_ALLOW21;
 }
 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 = path65.join(workspace, "agents", "runtime", "state");
+  const state_root = path67.join(workspace, "agents", "runtime", "state");
   const fb_dir = feedback_dir(state_root, session_id);
   try {
-    fs63.mkdirSync(fb_dir, { recursive: true });
+    fs65.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}
@@ -26738,7 +27126,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     return;
   }
   for (const entry of entries) {
-    const target = path65.join(fb_dir, `${entry["concern"]}.json`);
+    const target = path67.join(fb_dir, `${entry["concern"]}.json`);
     try {
       atomic_write_json(target, entry);
     } catch (exc) {
@@ -26778,7 +27166,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     })
   };
   try {
-    atomic_write_json(path65.join(fb_dir, "summary.json"), summary);
+    atomic_write_json(path67.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}
@@ -26788,17 +27176,17 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
 function _record_rule_trips(envelope, entries) {
   if (is_replay_mode()) return;
   const tripped = entries.filter(
-    (e) => e["exit_code"] === EXIT_BLOCK5 || e["exit_code"] === EXIT_WARN13
+    (e) => e["exit_code"] === EXIT_BLOCK5 || e["exit_code"] === EXIT_WARN14
   );
   if (tripped.length === 0) return;
   try {
     const workspace = String(envelope["workspace_root"] || process.cwd());
-    const state_dir = path65.join(workspace, "agents", "runtime", "state");
-    const target = path65.join(state_dir, "rule-trips.json");
-    fs63.mkdirSync(state_dir, { recursive: true });
+    const state_dir = path67.join(workspace, "agents", "runtime", "state");
+    const target = path67.join(state_dir, "rule-trips.json");
+    fs65.mkdirSync(state_dir, { recursive: true });
     let doc = { schema_version: 1, concerns: {} };
     try {
-      const parsed = JSON.parse(fs63.readFileSync(target, "utf-8"));
+      const parsed = JSON.parse(fs65.readFileSync(target, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) doc = parsed;
     } catch {
     }
@@ -26809,7 +27197,7 @@ function _record_rule_trips(envelope, entries) {
       const prev = concerns[name] ?? { block: 0, warn: 0 };
       concerns[name] = {
         block: (Number(prev["block"]) || 0) + (e["exit_code"] === EXIT_BLOCK5 ? 1 : 0),
-        warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN13 ? 1 : 0),
+        warn: (Number(prev["warn"]) || 0) + (e["exit_code"] === EXIT_WARN14 ? 1 : 0),
         last_trip: today
       };
     }
@@ -26897,7 +27285,7 @@ function _parse_args(argv) {
   }
   return args;
 }
-function main45(argv) {
+function main46(argv) {
   const args = _parse_args(argv ?? process.argv.slice(2));
   if (args.project_dir) {
     const project_dir = _expanduser3(args.project_dir);
@@ -26915,13 +27303,13 @@ function main45(argv) {
       `dispatch_hook: unknown event '${args.event}'; allowed: ${_sortedRepr(EVENT_VOCABULARY)}
 `
     );
-    return EXIT_ALLOW20;
+    return EXIT_ALLOW21;
   }
   const manifest_path = args.manifest;
-  if (!fs63.existsSync(manifest_path)) {
+  if (!fs65.existsSync(manifest_path)) {
     process.stderr.write(`dispatch_hook: manifest missing at ${manifest_path}
 `);
-    return EXIT_ALLOW20;
+    return EXIT_ALLOW21;
   }
   const manifest = _load_yaml3(manifest_path);
   if (args.min_version) {
@@ -26945,10 +27333,10 @@ function main45(argv) {
       concerns: concerns.map((c) => c["name"])
     };
     process.stdout.write(_py_json_dumps2(plan, 2) + "\n");
-    return EXIT_ALLOW20;
+    return EXIT_ALLOW21;
   }
   if (concerns.length === 0) {
-    return EXIT_ALLOW20;
+    return EXIT_ALLOW21;
   }
   const envelope = _build_envelope(args, payload_text);
   const session_id = _resolve_session_id(envelope);
@@ -26968,7 +27356,7 @@ function main45(argv) {
     const raw_rc = rc;
     if (rc >= 3) {
       if (!concern["fail_closed"]) {
-        rc = EXIT_ALLOW20;
+        rc = EXIT_ALLOW21;
       } else {
         rc = EXIT_BLOCK5;
       }
@@ -26981,7 +27369,7 @@ function main45(argv) {
         `dispatch_hook: concern '${String(concern["name"])}' is declared severity: advisory but returned BLOCK \u2014 downgraded to warn.
 `
       );
-      rc = EXIT_WARN13;
+      rc = EXIT_WARN14;
     }
     rcs.push(rc);
     const reply = _parse_concern_stdout(stdout_text);
@@ -26991,7 +27379,7 @@ function main45(argv) {
     if (message) {
       concern_messages.push({ rc, text: message });
     }
-    if (args.event === "session_start" && rc === EXIT_ALLOW20 && typeof reply["context"] === "string" && reply["context"].trim()) {
+    if (args.event === "session_start" && rc === EXIT_ALLOW21 && typeof reply["context"] === "string" && reply["context"].trim()) {
       context_blocks.push(reply["context"].trim());
     }
     feedback_entries.push({
@@ -27010,7 +27398,7 @@ function main45(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_ALLOW20) {
+  if (context_blocks.length > 0 && final_rc === EXIT_ALLOW21) {
     process.stdout.write(context_blocks.join("\n\n") + "\n");
   }
   const decidingReasons = concern_messages.filter((m) => m.rc === final_rc).map((m) => m.text);
@@ -27031,7 +27419,7 @@ function main45(argv) {
 }
 function _isDir4(p) {
   try {
-    return fs63.statSync(p).isDirectory();
+    return fs65.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -27042,7 +27430,7 @@ function _sortedRepr(s) {
 }
 function _readStdin14() {
   try {
-    return fs63.readFileSync(0, "utf-8");
+    return fs65.readFileSync(0, "utf-8");
   } catch {
     return "";
   }
@@ -27054,29 +27442,29 @@ function _isCliEntry36() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL40(path65.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL41(path67.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs63.realpathSync(fileURLToPath46(import.meta.url));
-    const argv = fs63.realpathSync(path65.resolve(process.argv[1]));
+    const here = fs65.realpathSync(fileURLToPath47(import.meta.url));
+    const argv = fs65.realpathSync(path67.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var isCliEntry12 = _isCliEntry36();
-if (isCliEntry12) {
-  process.exit(main45(process.argv.slice(2)));
+var isCliEntry13 = _isCliEntry36();
+if (isCliEntry13) {
+  process.exit(main46(process.argv.slice(2)));
 }
 
 // src/scripts/hooks/dispatch_entry.ts
-var _selfPath = fileURLToPath47(import.meta.url);
-var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path66.resolve(process.argv[1]) === path66.resolve(_selfPath);
+var _selfPath = fileURLToPath48(import.meta.url);
+var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path68.resolve(process.argv[1]) === path68.resolve(_selfPath);
 if (_invokedDirectly2) {
-  process.exitCode = main45(process.argv.slice(2));
+  process.exitCode = main46(process.argv.slice(2));
 }
 export {
-  main45 as main
+  main46 as main
 };