@event4u/agent-config 15.0.0 → 16.0.0

package/dist/hooks/dispatch.js

@@ -112,17 +112,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path111) {
-      const ctrl = callVisitor(key, node, visitor, path111);
+    function visit_(key, node, visitor, path116) {
+      const ctrl = callVisitor(key, node, visitor, path116);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path111, ctrl);
-        return visit_(key, ctrl, visitor, path111);
+        replaceNode(key, path116, ctrl);
+        return visit_(key, ctrl, visitor, path116);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path111 = Object.freeze(path111.concat(node));
+          path116 = Object.freeze(path116.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path111);
+            const ci = visit_(i, node.items[i], visitor, path116);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -133,13 +133,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path111 = Object.freeze(path111.concat(node));
-          const ck = visit_("key", node.key, visitor, path111);
+          path116 = Object.freeze(path116.concat(node));
+          const ck = visit_("key", node.key, visitor, path116);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path111);
+          const cv = visit_("value", node.value, visitor, path116);
           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, path111) {
-      const ctrl = await callVisitor(key, node, visitor, path111);
+    async function visitAsync_(key, node, visitor, path116) {
+      const ctrl = await callVisitor(key, node, visitor, path116);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path111, ctrl);
-        return visitAsync_(key, ctrl, visitor, path111);
+        replaceNode(key, path116, ctrl);
+        return visitAsync_(key, ctrl, visitor, path116);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path111 = Object.freeze(path111.concat(node));
+          path116 = Object.freeze(path116.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path111);
+            const ci = await visitAsync_(i, node.items[i], visitor, path116);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -181,13 +181,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path111 = Object.freeze(path111.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path111);
+          path116 = Object.freeze(path116.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path116);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path111);
+          const cv = await visitAsync_("value", node.value, visitor, path116);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -214,23 +214,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path111) {
+    function callVisitor(key, node, visitor, path116) {
       if (typeof visitor === "function")
-        return visitor(key, node, path111);
+        return visitor(key, node, path116);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path111);
+        return visitor.Map?.(key, node, path116);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path111);
+        return visitor.Seq?.(key, node, path116);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path111);
+        return visitor.Pair?.(key, node, path116);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path111);
+        return visitor.Scalar?.(key, node, path116);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path111);
+        return visitor.Alias?.(key, node, path116);
       return void 0;
     }
-    function replaceNode(key, path111, node) {
-      const parent = path111[path111.length - 1];
+    function replaceNode(key, path116, node) {
+      const parent = path116[path116.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, path111, value) {
+    function collectionFromPath(schema, path116, value) {
       let v = value;
-      for (let i = path111.length - 1; i >= 0; --i) {
-        const k = path111[i];
+      for (let i = path116.length - 1; i >= 0; --i) {
+        const k = path116[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 = (path111) => path111 == null || typeof path111 === "object" && !!path111[Symbol.iterator]().next().done;
+    var isEmptyPath = (path116) => path116 == null || typeof path116 === "object" && !!path116[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(path111, value) {
-        if (isEmptyPath(path111))
+      addIn(path116, value) {
+        if (isEmptyPath(path116))
           this.add(value);
         else {
-          const [key, ...rest] = path111;
+          const [key, ...rest] = path116;
           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(path111) {
-        const [key, ...rest] = path111;
+      deleteIn(path116) {
+        const [key, ...rest] = path116;
         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(path111, keepScalar) {
-        const [key, ...rest] = path111;
+      getIn(path116, keepScalar) {
+        const [key, ...rest] = path116;
         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(path111) {
-        const [key, ...rest] = path111;
+      hasIn(path116) {
+        const [key, ...rest] = path116;
         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(path111, value) {
-        const [key, ...rest] = path111;
+      setIn(path116, value) {
+        const [key, ...rest] = path116;
         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(path111, value) {
+      addIn(path116, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path111, value);
+          this.contents.addIn(path116, 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(path111) {
-        if (Collection.isEmptyPath(path111)) {
+      deleteIn(path116) {
+        if (Collection.isEmptyPath(path116)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path111) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path116) : 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(path111, keepScalar) {
-        if (Collection.isEmptyPath(path111))
+      getIn(path116, keepScalar) {
+        if (Collection.isEmptyPath(path116))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path111, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path116, 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(path111) {
-        if (Collection.isEmptyPath(path111))
+      hasIn(path116) {
+        if (Collection.isEmptyPath(path116))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path111) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path116) : 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(path111, value) {
-        if (Collection.isEmptyPath(path111)) {
+      setIn(path116, value) {
+        if (Collection.isEmptyPath(path116)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path111), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path116), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path111, value);
+          this.contents.setIn(path116, 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: sep9, value } = collItem;
+        const { start, key, sep: sep12, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep9?.[0],
+          next: key ?? sep12?.[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 && !sep9) {
+          if (!keyProps.anchor && !keyProps.tag && !sep12) {
             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(sep9 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep12 ?? [], {
           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, sep9, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep12, 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 sep9 = "";
+        let sep12 = "";
         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 += sep9 + cb;
-              sep9 = "";
+                comment += sep12 + cb;
+              sep12 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep9 += source;
+                sep12 += 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: sep9, value } = collItem;
+        const { start, key, sep: sep12, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep9?.[0],
+          next: key ?? sep12?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep9 && !value) {
+          if (!props.anchor && !props.tag && !sep12 && !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 && !sep9 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep9, null, props, onError);
+        if (!isMap && !sep12 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep12, 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(sep9 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep12 ?? [], {
             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 (sep9)
-                for (const st of sep9) {
+              if (sep12)
+                for (const st of sep12) {
                   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, sep9, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep12, 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 sep9 = "";
+      let sep12 = "";
       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 += sep9 + indent.slice(trimIndent) + content;
-          sep9 = "\n";
+          value += sep12 + indent.slice(trimIndent) + content;
+          sep12 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep9 === " ")
-            sep9 = "\n";
-          else if (!prevMoreIndented && sep9 === "\n")
-            sep9 = "\n\n";
-          value += sep9 + indent.slice(trimIndent) + content;
-          sep9 = "\n";
+          if (sep12 === " ")
+            sep12 = "\n";
+          else if (!prevMoreIndented && sep12 === "\n")
+            sep12 = "\n\n";
+          value += sep12 + indent.slice(trimIndent) + content;
+          sep12 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep9 === "\n")
+          if (sep12 === "\n")
             value += "\n";
           else
-            sep9 = "\n";
+            sep12 = "\n";
         } else {
-          value += sep9 + content;
-          sep9 = " ";
+          value += sep12 + content;
+          sep12 = " ";
           prevMoreIndented = false;
         }
       }
@@ -4710,25 +4710,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep9 = " ";
+      let sep12 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep9 === "\n")
-            res += sep9;
+          if (sep12 === "\n")
+            res += sep12;
           else
-            sep9 = "\n";
+            sep12 = "\n";
         } else {
-          res += sep9 + match[1];
-          sep9 = " ";
+          res += sep12 + match[1];
+          sep12 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep9 + (match?.[1] ?? "");
+      return res + sep12 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -5538,14 +5538,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep9, value }) {
+    function stringifyItem({ start, key, sep: sep12, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep9)
-        for (const st of sep9)
+      if (sep12)
+        for (const st of sep12)
           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, path111) => {
+    visit.itemAtPath = (cst, path116) => {
       let item = cst;
-      for (const [field, index] of path111) {
+      for (const [field, index] of path116) {
         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, path111) => {
-      const parent = visit.itemAtPath(cst, path111.slice(0, -1));
-      const field = path111[path111.length - 1][0];
+    visit.parentCollection = (cst, path116) => {
+      const parent = visit.itemAtPath(cst, path116.slice(0, -1));
+      const field = path116[path116.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path111, item, visitor) {
-      let ctrl = visitor(item, path111);
+    function _visit(path116, item, visitor) {
+      let ctrl = visitor(item, path116);
       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(path111.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path116.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, path111);
+            ctrl = ctrl(item, path116);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path111) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path116) : 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 sep9;
+          let sep12;
           if (scalar.end) {
-            sep9 = scalar.end;
-            sep9.push(this.sourceToken);
+            sep12 = scalar.end;
+            sep12.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep9 = [this.sourceToken];
+            sep12 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep9 }]
+            items: [{ start, key: scalar, sep: sep12 }]
           };
           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 sep9 = it.sep;
-                  sep9.push(this.sourceToken);
+                  const sep12 = it.sep;
+                  sep12.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: sep9 }]
+                    items: [{ start: start2, key, sep: sep12 }]
                   });
                 } 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 fs107 = this.flowScalar(this.type);
+              const fs111 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs107, sep: [] });
+                map.items.push({ start, key: fs111, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs107);
+                this.stack.push(fs111);
               } else {
-                Object.assign(it, { key: fs107, sep: [] });
+                Object.assign(it, { key: fs111, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7048,13 +7048,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs107 = this.flowScalar(this.type);
+              const fs111 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs107, sep: [] });
+                fc.items.push({ start: [], key: fs111, sep: [] });
               else if (it.sep)
-                this.stack.push(fs107);
+                this.stack.push(fs111);
               else
-                Object.assign(it, { key: fs107, sep: [] });
+                Object.assign(it, { key: fs111, 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 sep9 = fc.end.splice(1, fc.end.length);
-            sep9.push(this.sourceToken);
+            const sep12 = fc.end.splice(1, fc.end.length);
+            sep12.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep9 }]
+              items: [{ start, key: fc, sep: sep12 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -7363,16 +7363,16 @@ var require_dist = __commonJS({
 });
 
 // src/scripts/hooks/dispatch_entry.ts
-import * as path110 from "node:path";
-import { fileURLToPath as fileURLToPath71 } from "node:url";
+import * as path115 from "node:path";
+import { fileURLToPath as fileURLToPath74 } from "node:url";
 
 // src/scripts/hooks/dispatch_hook.ts
 var import_yaml7 = __toESM(require_dist(), 1);
-import { spawnSync as spawnSync10 } from "node:child_process";
-import fs106 from "node:fs";
-import path109 from "node:path";
+import { spawnSync as spawnSync11 } from "node:child_process";
+import fs110 from "node:fs";
+import path114 from "node:path";
 import * as tty2 from "node:tty";
-import { fileURLToPath as fileURLToPath70, pathToFileURL as pathToFileURL61 } from "node:url";
+import { fileURLToPath as fileURLToPath73, pathToFileURL as pathToFileURL63 } from "node:url";
 
 // src/scripts/_lib/spawn_env.ts
 var DENY_EXACT = /* @__PURE__ */ new Set([
@@ -16091,8 +16091,8 @@ function lockfile_path(env) {
   }
   return write_target("installed.lock", { env: env ?? null });
 }
-function read_lockfile(path111) {
-  const target = path111 ?? lockfile_path();
+function read_lockfile(path116) {
+  const target = path116 ?? lockfile_path();
   let text;
   try {
     text = fs21.readFileSync(target, { encoding: "utf-8" });
@@ -16160,7 +16160,9 @@ var DETECTOR_IDS = [
   "promissory",
   "language",
   "verification",
-  "completion"
+  "completion",
+  "pending-decision",
+  "untested"
 ];
 var REFUSAL_STATE_REL = path22.join("agents", "runtime", "state", "turn-end-gate");
 function refusalStateDir(workspaceRoot3) {
@@ -16185,7 +16187,9 @@ function readSessionCounts(workspaceRoot3, sessionId3) {
   }
 }
 function emptyCounts() {
-  return { promissory: 0, language: 0, verification: 0, completion: 0 };
+  const out = {};
+  for (const id of DETECTOR_IDS) out[id] = 0;
+  return out;
 }
 function isDetector(v) {
   return typeof v === "string" && DETECTOR_IDS.includes(v);
@@ -16211,6 +16215,9 @@ function parseRecord(raw) {
   if (typeof o["agent_config_version"] === "string") {
     rec.agent_config_version = o["agent_config_version"];
   }
+  if (typeof o["refused_prompt_id"] === "string") {
+    rec.refused_prompt_id = o["refused_prompt_id"];
+  }
   const counts = o["counts"];
   if (typeof counts === "object" && counts !== null && !Array.isArray(counts)) {
     const parsed = {};
@@ -16254,6 +16261,9 @@ function foldRefusal(prev, input) {
   else if (prev?.agent_config_version !== void 0) {
     rec.agent_config_version = prev.agent_config_version;
   }
+  if (input.promptId !== void 0 && input.promptId !== "") {
+    rec.refused_prompt_id = input.promptId;
+  }
   return rec;
 }
 function readInstallBoundary() {
@@ -34016,14 +34026,92 @@ if (_isCliEntry37()) {
 }
 
 // src/scripts/hooks/end_review_nudge_hook.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import * as crypto9 from "node:crypto";
-import * as fs82 from "node:fs";
+import * as fs83 from "node:fs";
 import * as os11 from "node:os";
-import * as path83 from "node:path";
+import * as path84 from "node:path";
 import { fileURLToPath as fileURLToPath56, pathToFileURL as pathToFileURL48 } from "node:url";
 
+// src/scripts/_lib/review_baseline.ts
+import { spawnSync as spawnSync6 } from "node:child_process";
+import * as fs82 from "node:fs";
+import * as path83 from "node:path";
+function currentHeadSha(cwd) {
+  try {
+    const r = spawnSync6("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" });
+    if (r.status !== 0) return null;
+    const out = (r.stdout ?? "").trim();
+    return out === "" ? null : out;
+  } catch {
+    return null;
+  }
+}
+var BASELINE_STATE_REL = path83.join("agents", "runtime", "state", "review-baseline");
+function baselineStateDir(workspaceRoot3) {
+  return path83.join(workspaceRoot3, BASELINE_STATE_REL);
+}
+function baselineStateFile(workspaceRoot3, sessionKey) {
+  return path83.join(baselineStateDir(workspaceRoot3), `${sessionKey}.json`);
+}
+function parseBaseline(raw) {
+  let decoded;
+  try {
+    decoded = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+  const o = decoded;
+  const lines = o["baseline_lines"];
+  if (typeof lines !== "number" || !Number.isFinite(lines) || lines < 0) return null;
+  const written = o["written_at"];
+  if (typeof written !== "string") return null;
+  const head = o["head_sha"];
+  const measure = o["measure"];
+  return {
+    head_sha: typeof head === "string" && head !== "" ? head : null,
+    baseline_lines: lines,
+    ...measure === "exact" || measure === "capped_approximation" ? { measure } : {},
+    written_at: written
+  };
+}
+function readBaseline(workspaceRoot3, sessionKey) {
+  const file = baselineStateFile(workspaceRoot3, sessionKey);
+  let raw;
+  try {
+    raw = fs82.readFileSync(file, "utf-8");
+  } catch (exc) {
+    const code = exc?.code;
+    return code === "ENOENT" ? "absent" : "unreadable";
+  }
+  return parseBaseline(raw) ?? "unreadable";
+}
+function applyBaseline(measuredLines, baseline, headSha, measuredMeasure = "exact") {
+  if (baseline === "absent" || baseline === "unreadable") {
+    return { applied: false, fallback: baseline, lines: measuredLines };
+  }
+  if (baseline.measure !== "exact" || measuredMeasure !== "exact") {
+    return { applied: false, fallback: "mixed-measure", lines: measuredLines };
+  }
+  if (baseline.head_sha !== headSha()) {
+    return { applied: false, fallback: "head-moved", lines: measuredLines };
+  }
+  return {
+    applied: true,
+    baseline,
+    lines: Math.max(0, measuredLines - baseline.baseline_lines)
+  };
+}
+
 // src/scripts/_lib/review_skipped_record.ts
+var BASELINE_APPLICATIONS = [
+  "applied",
+  "absent",
+  "unreadable",
+  "head_moved",
+  "mixed_measure"
+];
 var PRODUCER_PRIVACY_CLASS2 = "ids-only";
 function isNonNegInt(n) {
   return typeof n === "number" && Number.isFinite(n) && Number.isInteger(n) && n >= 0;
@@ -34039,6 +34127,9 @@ function buildReviewSkippedLine(input) {
   }
   if (!input.ts) errors.push("ts (ISO-8601 UTC) is required");
   if (!input.id) errors.push("id (ULID, UUID, or content hash) is required");
+  if (input.baseline !== void 0 && !BASELINE_APPLICATIONS.includes(input.baseline)) {
+    errors.push(`baseline must be one of ${BASELINE_APPLICATIONS.join(", ")}`);
+  }
   if (errors.length) return { line: null, errors };
   const line = {
     schema_version: 1,
@@ -34065,7 +34156,14 @@ function buildReviewSkippedLine(input) {
     persona: null,
     input_kind: "prompt",
     type: "note",
-    review_skipped: { diff_lines: input.diff_lines, mutation_measure: input.mutation_measure }
+    review_skipped: {
+      diff_lines: input.diff_lines,
+      mutation_measure: input.mutation_measure,
+      // Omitted, not defaulted, when the producer recorded nothing —
+      // audit-log-v1's absent-versus-present split is the same one
+      // `skills_applied` uses above, for the same reason.
+      ...input.baseline === void 0 ? {} : { baseline: input.baseline }
+    }
   };
   return { line, errors: [] };
 }
@@ -34079,13 +34177,13 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   const homeDir = opts.homeDir ?? os11.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs82.realpathSync(homeDir);
-    const realPath = fs82.realpathSync(rawPath);
-    const relative13 = path83.relative(realHome, realPath);
-    if (relative13 === "" || relative13.startsWith("..") || path83.isAbsolute(relative13)) {
+    const realHome = fs83.realpathSync(homeDir);
+    const realPath = fs83.realpathSync(rawPath);
+    const relative16 = path84.relative(realHome, realPath);
+    if (relative16 === "" || relative16.startsWith("..") || path84.isAbsolute(relative16)) {
       return false;
     }
-    const { size } = fs82.statSync(realPath);
+    const { size } = fs83.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
@@ -34116,7 +34214,7 @@ function nonDocMutatedLines(rows) {
 }
 function gitNumstatRows(cwd) {
   try {
-    const r = spawnSync6("git", ["diff", "--numstat", "HEAD"], {
+    const r = spawnSync7("git", ["diff", "--numstat", "HEAD"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -34129,7 +34227,7 @@ function gitNumstatRows(cwd) {
 }
 function untrackedNonDocFiles(cwd) {
   try {
-    const r = spawnSync6("git", ["ls-files", "--others", "--exclude-standard"], {
+    const r = spawnSync7("git", ["ls-files", "--others", "--exclude-standard"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -34144,13 +34242,13 @@ var BINARY_PROBE_BYTES = 8e3;
 var UNTRACKED_FILE_READ_CAP_BYTES = 8 * 1024 * 1024;
 function untrackedFileLineCount(cwd, relPath) {
   try {
-    const abs = path83.resolve(cwd, relPath);
-    const size = fs82.statSync(abs).size;
+    const abs = path84.resolve(cwd, relPath);
+    const size = fs83.statSync(abs).size;
     if (size === 0) return 0;
     if (size > UNTRACKED_FILE_READ_CAP_BYTES) {
       return MUTATION_LINE_THRESHOLD + 1;
     }
-    const buf = fs82.readFileSync(abs);
+    const buf = fs83.readFileSync(abs);
     if (buf.length === 0) return 0;
     const probe = buf.subarray(0, Math.min(buf.length, BINARY_PROBE_BYTES));
     if (probe.includes(0)) return 0;
@@ -34229,30 +34327,31 @@ function scanTranscriptForReviewer(transcriptText) {
 function buildAdvisoryLine(diffLines) {
   return `this session mutated ${diffLines} lines without a neutral review; spawn a cross-model reviewer before claiming done (delegation-policy / verify-budget)`;
 }
-function appendReviewSkippedTelemetry(workspaceRoot3, diffLines, mutationMeasure) {
+function appendReviewSkippedTelemetry(workspaceRoot3, diffLines, mutationMeasure, baseline) {
   if (is_replay_mode()) return;
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   const { line, errors } = buildReviewSkippedLine({
     diff_lines: diffLines,
     mutation_measure: mutationMeasure,
     ts,
-    id: crypto9.randomUUID()
+    id: crypto9.randomUUID(),
+    baseline
   });
   if (errors.length || line === null) return;
   try {
-    const dir = path83.join(workspaceRoot3, "agents", "runtime", "state", "audit");
-    fs82.mkdirSync(dir, { recursive: true });
-    const file = path83.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs82.appendFileSync(file, `${JSON.stringify(line)}
+    const dir = path84.join(workspaceRoot3, "agents", "runtime", "state", "audit");
+    fs83.mkdirSync(dir, { recursive: true });
+    const file = path84.join(dir, `${ts.slice(0, 7)}.jsonl`);
+    fs83.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
 }
 function sessionStateDir(workspaceRoot3) {
-  return path83.join(workspaceRoot3, "agents", "runtime", "state", "end-review-nudge");
+  return path84.join(workspaceRoot3, "agents", "runtime", "state", "end-review-nudge");
 }
 function sessionStateFile(workspaceRoot3, sessionKey) {
-  return path83.join(sessionStateDir(workspaceRoot3), `${sessionKey}.json`);
+  return path84.join(sessionStateDir(workspaceRoot3), `${sessionKey}.json`);
 }
 function deriveSessionKey2(envelope, payload) {
   const raw = str6(envelope["session_id"]) || str6(payload["transcript_path"] ?? payload["transcriptPath"]);
@@ -34261,7 +34360,7 @@ function deriveSessionKey2(envelope, payload) {
 }
 function hasFiredThisSession(workspaceRoot3, sessionKey) {
   try {
-    return fs82.existsSync(sessionStateFile(workspaceRoot3, sessionKey));
+    return fs83.existsSync(sessionStateFile(workspaceRoot3, sessionKey));
   } catch {
     return false;
   }
@@ -34275,6 +34374,12 @@ function markFiredThisSession(workspaceRoot3, sessionKey, ts) {
 function _read_stdin3() {
   return readHookStdin();
 }
+var FALLBACK_TO_TELEMETRY = {
+  absent: "absent",
+  unreadable: "unreadable",
+  "head-moved": "head_moved",
+  "mixed-measure": "mixed_measure"
+};
 function main54() {
   const [envelope, payload] = unwrap(_read_stdin3(), "claude");
   const event = String(envelope["event"] ?? "");
@@ -34282,19 +34387,32 @@ function main54() {
     return 0;
   }
   const workspace_root = String(envelope["workspace_root"] ?? "").trim() || process.cwd();
-  let diffLines;
+  let measuredLines;
   let mutationMeasure;
   try {
     const measured = totalNonDocMutatedLinesWithMeasure(workspace_root);
-    diffLines = measured.lines;
+    measuredLines = measured.lines;
     mutationMeasure = measured.measure;
   } catch {
     return 0;
   }
+  const sessionKey = deriveSessionKey2(envelope, payload);
+  const baselineOutcome = applyBaseline(
+    measuredLines,
+    readBaseline(workspace_root, sessionKey),
+    // A THUNK, not a value: on the `absent` and `unreadable` branches the
+    // result is discarded, and those two are the steady state on every host
+    // without this nudge and on every session before its first baseline
+    // write. Passing the value eagerly spent an 11-14 ms `git rev-parse` on
+    // each of those stops for nothing.
+    () => currentHeadSha(workspace_root),
+    mutationMeasure
+  );
+  const diffLines = baselineOutcome.lines;
+  const baselineApplication = baselineOutcome.applied ? "applied" : FALLBACK_TO_TELEMETRY[baselineOutcome.fallback];
   if (diffLines <= MUTATION_LINE_THRESHOLD) {
     return 0;
   }
-  const sessionKey = deriveSessionKey2(envelope, payload);
   if (hasFiredThisSession(workspace_root, sessionKey)) {
     return 0;
   }
@@ -34304,7 +34422,7 @@ function main54() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs82.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs83.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -34314,7 +34432,12 @@ function main54() {
   }
   markFiredThisSession(workspace_root, sessionKey, (/* @__PURE__ */ new Date()).toISOString());
   try {
-    appendReviewSkippedTelemetry(workspace_root, diffLines, mutationMeasure);
+    appendReviewSkippedTelemetry(
+      workspace_root,
+      diffLines,
+      mutationMeasure,
+      baselineApplication
+    );
   } catch {
   }
   process.stdout.write(
@@ -34334,13 +34457,13 @@ function _isCliEntry38() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL48(path83.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL48(path84.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs82.realpathSync(fileURLToPath56(import.meta.url));
-    const argv = fs82.realpathSync(path83.resolve(process.argv[1]));
+    const here = fs83.realpathSync(fileURLToPath56(import.meta.url));
+    const argv = fs83.realpathSync(path84.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -34350,16 +34473,530 @@ if (_isCliEntry38()) {
   process.exit(main54());
 }
 
-// src/scripts/hooks/turn_end_gate_hook.ts
+// src/scripts/hooks/review_baseline_hook.ts
 import * as fs84 from "node:fs";
 import * as path85 from "node:path";
-import { fileURLToPath as fileURLToPath58, pathToFileURL as pathToFileURL50 } from "node:url";
+import { fileURLToPath as fileURLToPath57, pathToFileURL as pathToFileURL49 } from "node:url";
+var EXIT_OK2 = 0;
+function buildBaseline(workspaceRoot3, now = /* @__PURE__ */ new Date()) {
+  const measured = totalNonDocMutatedLinesWithMeasure(workspaceRoot3);
+  return {
+    head_sha: currentHeadSha(workspaceRoot3),
+    baseline_lines: measured.lines,
+    // Carried, not discarded. Past `UNTRACKED_FILE_CAP` the count is a
+    // synthetic `THRESHOLD + 1 + tracked` chosen to be over the bar rather
+    // than to be true, and subtracting that from a later exact count is
+    // arithmetic over two different quantities. The consumer refuses the
+    // subtraction when the two measures disagree; it can only do that if the
+    // writer says which one it took.
+    measure: measured.measure,
+    written_at: now.toISOString()
+  };
+}
+function main55() {
+  let envelope;
+  let payload;
+  try {
+    [envelope, payload] = unwrap(readHookStdin(), "claude");
+  } catch {
+    return EXIT_OK2;
+  }
+  const event = String(envelope["event"] ?? "");
+  if (event !== "" && event !== "session_start") return EXIT_OK2;
+  const workspaceRoot3 = String(envelope["workspace_root"] ?? "").trim() || process.cwd();
+  const sessionKey = deriveSessionKey2(envelope, payload);
+  const file = baselineStateFile(workspaceRoot3, sessionKey);
+  try {
+    if (fs84.existsSync(file)) return EXIT_OK2;
+  } catch {
+    return EXIT_OK2;
+  }
+  try {
+    atomic_write_json(file, buildBaseline(workspaceRoot3));
+  } catch {
+  }
+  return EXIT_OK2;
+}
+function _isCliEntry39() {
+  if (true) return false;
+  if (process.argv[1] === void 0) return false;
+  const argvUrl = pathToFileURL49(path85.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) return true;
+  try {
+    const here = fs84.realpathSync(fileURLToPath57(import.meta.url));
+    const argv = fs84.realpathSync(path85.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry39()) {
+  process.exit(main55());
+}
+
+// src/scripts/hooks/turn_end_gate_hook.ts
+import * as fs88 from "node:fs";
+import * as path90 from "node:path";
+import { fileURLToPath as fileURLToPath61, pathToFileURL as pathToFileURL52 } from "node:url";
+
+// src/scripts/check_reply_consistency.ts
+import * as fs86 from "node:fs";
+import * as path88 from "node:path";
+import { fileURLToPath as fileURLToPath59, pathToFileURL as pathToFileURL50 } from "node:url";
+
+// src/scripts/_lib/agent_src.ts
+import * as fs85 from "node:fs";
+import * as path87 from "node:path";
+import { fileURLToPath as fileURLToPath58 } from "node:url";
+
+// src/scripts/_lib/guidelines_lane.ts
+import * as path86 from "node:path";
+var GUIDELINES_SOURCE_REL = path86.join("docs", "guidelines");
+
+// src/scripts/_lib/agent_src.ts
+var _HERE11 = path87.dirname(fileURLToPath58(import.meta.url));
+var _DEFAULT_ROOT = path87.resolve(_HERE11, "..", "..", "..");
+function _deriveRoots(root) {
+  const packages = path87.join(root, "packages");
+  const src = path87.join(root, "src");
+  return {
+    ROOT: root,
+    LEGACY_SRC: path87.join(root, ".agent-src.uncondensed"),
+    PACKAGES: packages,
+    PACKAGE_CORE: path87.join(packages, "core"),
+    SRC: src,
+    SRC_SKILLS: path87.join(src, "skills"),
+    SRC_RULES: path87.join(src, "rules"),
+    SRC_AGENT: path87.join(src, "agent-src"),
+    SRC_DOMAINS: path87.join(src, "domains")
+  };
+}
+var _roots = _deriveRoots(_DEFAULT_ROOT);
+function _isDir4(p) {
+  try {
+    return fs85.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _exists5(p) {
+  try {
+    fs85.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _iterdirSorted2(p) {
+  let names;
+  try {
+    names = fs85.readdirSync(p);
+  } catch {
+    return [];
+  }
+  names.sort();
+  return names.map((name) => path87.join(p, name));
+}
+function artefact_roots() {
+  const roots = [];
+  if (_exists5(_roots.LEGACY_SRC)) {
+    roots.push(_roots.LEGACY_SRC);
+  }
+  if (_exists5(_roots.PACKAGES)) {
+    for (const pkg of _iterdirSorted2(_roots.PACKAGES)) {
+      const sub = path87.join(pkg, ".agent-src.uncondensed");
+      if (_isDir4(sub)) {
+        roots.push(sub);
+      }
+    }
+  }
+  if (_isDir4(_roots.SRC_AGENT)) {
+    roots.push(_roots.SRC_AGENT);
+  }
+  if (_isDir4(_roots.SRC_SKILLS) || _isDir4(_roots.SRC_RULES)) {
+    roots.push(_roots.SRC);
+  }
+  return roots;
+}
+
+// src/scripts/check_reply_consistency.ts
+var _HERE12 = fileURLToPath59(import.meta.url);
+var ROOT3 = path88.resolve(path88.dirname(_HERE12), "..", "..");
+var QUIET = process.argv.slice(2).includes("--quiet");
+var OPTION_LINE_RE = /^\s*>?\s*(\d+)\.\s+\S/;
+var REC_LINE_RE = /(?:Recommendation|Empfehlung)\s*:\s*(\d+)\b/i;
+var TAG_RE = /\((?:recommended|rec|empfohlen)\)/i;
+var CODESPAN_RE = /`[^`\n]*`/g;
+var HEADING_RE = /^#{1,6}\s/;
+var FENCE_RE = /^\s*(```|~~~)/;
+var REC_ADJACENCY_WINDOW = 2;
+function _strip_codespans(line) {
+  return line.replace(CODESPAN_RE, "``");
+}
+function splitAndMask(text) {
+  return mask_fences(_splitlines4(text));
+}
+function _splitlines4(text) {
+  if (text === "") return [];
+  const parts = text.split(/\r\n|\r|\n/);
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+function mask_fences(lines) {
+  const out = [];
+  let fence = null;
+  for (const raw of lines) {
+    const m = FENCE_RE.exec(raw);
+    if (m) {
+      const marker = m[1];
+      if (fence === null) {
+        fence = marker;
+      } else if (fence === marker) {
+        fence = null;
+      }
+      out.push("");
+      continue;
+    }
+    out.push(fence === null ? raw : "");
+  }
+  return out;
+}
+function find_option_blocks(text) {
+  const lines = mask_fences(_splitlines4(text));
+  const blocks = [];
+  let current = null;
+  for (let idx = 0; idx < lines.length; idx++) {
+    const m = OPTION_LINE_RE.exec(lines[idx]);
+    if (m) {
+      const num = parseInt(m[1], 10);
+      if (current === null) {
+        current = { startLine: idx + 1, endLine: idx + 1, numbers: [num] };
+      } else {
+        current.endLine = idx + 1;
+        current.numbers.push(num);
+      }
+    } else {
+      if (current !== null && current.numbers.length >= 2) {
+        blocks.push(current);
+      }
+      current = null;
+    }
+  }
+  if (current !== null && current.numbers.length >= 2) {
+    blocks.push(current);
+  }
+  return blocks;
+}
+function recommendationsUnder(text, block, maskedLines) {
+  const lines = maskedLines ?? mask_fences(_splitlines4(text));
+  const recs = [];
+  let inspected = 0;
+  for (let idx = block.endLine; idx < lines.length && inspected < REC_ADJACENCY_WINDOW; idx++) {
+    const line = lines[idx];
+    if (line.trim() === "") {
+      continue;
+    }
+    if (HEADING_RE.test(line) || OPTION_LINE_RE.test(line)) {
+      break;
+    }
+    inspected += 1;
+    const m = REC_LINE_RE.exec(line);
+    if (m) {
+      recs.push({ line: idx + 1, num: parseInt(m[1], 10) });
+    }
+  }
+  return recs;
+}
+function check_reply(text) {
+  const rawLines = _splitlines4(text);
+  const lines = mask_fences(rawLines);
+  const findings = [];
+  for (let idx = 0; idx < lines.length; idx++) {
+    const stripped = _strip_codespans(lines[idx]);
+    if (OPTION_LINE_RE.test(stripped) && TAG_RE.test(stripped)) {
+      findings.push({
+        line: idx + 1,
+        message: `inline tag on numbered option \u2014 ${rawLines[idx].trim()}`
+      });
+    }
+  }
+  const blocks = find_option_blocks(text);
+  for (const block of blocks) {
+    const recs = recommendationsUnder(text, block);
+    if (recs.length === 0) {
+      findings.push({
+        line: block.startLine,
+        message: "numbered options block without a Recommendation:/Empfehlung: line directly under it"
+      });
+      continue;
+    }
+    if (recs.length > 1) {
+      findings.push({
+        line: recs[1].line,
+        message: `multiple recommendation lines under one options block: [${recs.map((r) => r.num).join(", ")}]`
+      });
+      continue;
+    }
+    const rec = recs[0];
+    if (!block.numbers.includes(rec.num)) {
+      findings.push({
+        line: rec.line,
+        message: `recommendation ${String(rec.num)} not present in the options block above it (options: [${block.numbers.join(", ")}])`
+      });
+    }
+  }
+  findings.sort((a, b) => a.line - b.line);
+  return findings;
+}
+function _isDir5(p) {
+  try {
+    return fs86.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _rglobMdSorted(dir) {
+  const out = [];
+  const walk = (current) => {
+    let entries;
+    try {
+      entries = fs86.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path88.join(current, ent.name);
+      if (ent.isDirectory() || ent.isSymbolicLink() && _isDir5(full)) {
+        walk(full);
+      } else if (ent.name.endsWith(".md")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(dir);
+  out.sort();
+  return out;
+}
+function _relToPosixOrAbs(child, root) {
+  const rel = path88.relative(root, child);
+  if (rel === "" || rel.startsWith("..") || path88.isAbsolute(rel)) {
+    return child.split(path88.sep).join("/");
+  }
+  return rel.split(path88.sep).join("/");
+}
+function cmd_scan_dir(root) {
+  let roots;
+  if (!_isDir5(root)) {
+    const legacy = path88.join(ROOT3, ".agent-src.uncondensed");
+    if (path88.resolve(root) === path88.resolve(legacy)) {
+      roots = artefact_roots();
+      if (roots.length === 0) {
+        process.stderr.write("error: no artefact roots found (legacy or packages/*)\n");
+        return 1;
+      }
+    } else {
+      process.stderr.write(`error: not a directory: ${root}
+`);
+      return 1;
+    }
+  } else {
+    roots = [root];
+  }
+  const violations = [];
+  let scanned = 0;
+  for (const r of roots) {
+    for (const md of _rglobMdSorted(r)) {
+      scanned += 1;
+      const text = fs86.readFileSync(md, "utf-8");
+      const lines = _splitlines4(text);
+      for (let idx = 0; idx < lines.length; idx++) {
+        const raw = lines[idx];
+        const stripped = _strip_codespans(raw);
+        if (OPTION_LINE_RE.test(stripped) && TAG_RE.test(stripped)) {
+          violations.push([md, idx + 1, raw.trim()]);
+        }
+      }
+    }
+  }
+  try {
+    assertScanned({
+      gate: "check_reply_consistency",
+      scanned,
+      units: "markdown file(s)",
+      roots: roots.map((r) => _relToPosixOrAbs(r, ROOT3))
+    });
+  } catch (exc) {
+    if (exc instanceof DeadScopeError) {
+      process.stderr.write(`\u274C  ${exc.message}
+`);
+      return 1;
+    }
+    throw exc;
+  }
+  if (violations.length > 0) {
+    for (const [p, line, snippet] of violations) {
+      process.stderr.write(`  \u{1F534} ${p}:${String(line)} \u2014 inline-tag \u2014 ${snippet}
+`);
+    }
+    process.stderr.write(`
+\u274C  ${String(violations.length)} legacy-pattern violation(s)
+`);
+    return 2;
+  }
+  if (!QUIET) {
+    const scanned2 = roots.map((r) => _relToPosixOrAbs(r, ROOT3)).join(", ");
+    process.stdout.write(`\u2705  No legacy (recommended) tags found under ${scanned2}
+`);
+  }
+  return 0;
+}
+var USAGE = "usage: check_reply_consistency [-h] (--stdin | --file FILE | --scan-dir SCAN_DIR)\n                              [-v] [--quiet]\n";
+function _usage_error(message) {
+  process.stderr.write(USAGE);
+  process.stderr.write(`check_reply_consistency: error: ${message}
+`);
+  process.exit(1);
+}
+function _readStdin14() {
+  try {
+    return fs86.readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function parse_args9(argv) {
+  let stdin = false;
+  let file = null;
+  let scan_dir = null;
+  let verbose = false;
+  const groupSeen = [];
+  const need = (i, name) => {
+    const v = argv[i];
+    if (v === void 0) {
+      _usage_error(`argument ${name}: expected one argument`);
+    }
+    return v;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--stdin") {
+      stdin = true;
+      groupSeen.push("--stdin");
+    } else if (arg === "--file") {
+      file = need(++i, "--file");
+      groupSeen.push("--file");
+    } else if (arg.startsWith("--file=")) {
+      file = arg.slice("--file=".length);
+      groupSeen.push("--file");
+    } else if (arg === "--scan-dir") {
+      scan_dir = need(++i, "--scan-dir");
+      groupSeen.push("--scan-dir");
+    } else if (arg.startsWith("--scan-dir=")) {
+      scan_dir = arg.slice("--scan-dir=".length);
+      groupSeen.push("--scan-dir");
+    } else if (arg === "-v" || arg === "--verbose") {
+      verbose = true;
+    } else if (arg === "--quiet") {
+    } else if (arg === "-h" || arg === "--help") {
+      process.stdout.write(USAGE);
+      process.exit(0);
+    } else {
+      _usage_error(`unrecognized arguments: ${arg}`);
+    }
+  }
+  if (groupSeen.length === 0) {
+    _usage_error("one of the arguments --stdin --file --scan-dir is required");
+  }
+  if (groupSeen.length > 1) {
+    _usage_error(`argument ${groupSeen[1]}: not allowed with argument ${groupSeen[0]}`);
+  }
+  return { stdin, file, scan_dir, verbose };
+}
+function main56(argv = process.argv.slice(2)) {
+  const args = parse_args9(argv);
+  if (args.scan_dir !== null) {
+    return cmd_scan_dir(args.scan_dir);
+  }
+  let text;
+  try {
+    text = args.stdin ? _readStdin14() : fs86.readFileSync(args.file, "utf-8");
+  } catch (e) {
+    process.stderr.write(`error: ${String(e)}
+`);
+    return 1;
+  }
+  const findings = check_reply(text);
+  if (findings.length === 0) {
+    if (args.verbose && !QUIET) {
+      process.stdout.write("\u2705  reply consistent (every options block carries one adjacent recommendation)\n");
+    }
+    return 0;
+  }
+  for (const f of findings) {
+    process.stderr.write(`\u274C  line ${String(f.line)}: ${f.message}
+`);
+  }
+  return 2;
+}
+function _isCliEntry40() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL50(path88.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs86.realpathSync(fileURLToPath59(import.meta.url));
+    const argv = fs86.realpathSync(path88.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var _IN_BUNDLE2 = true;
+if (!_IN_BUNDLE2 && (_isCliEntry40() || process.argv[1] === _HERE12)) {
+  process.exit(main56());
+}
+
+// src/scripts/_lib/dropped_decision.ts
+function detectDroppedDecision(assistantTurnTexts, closingFromPayload = false) {
+  if (assistantTurnTexts.length < 2) return null;
+  const asksIn = (text) => {
+    const blocks = find_option_blocks(text);
+    if (blocks.length === 0) return blocks;
+    const masked = splitAndMask(text);
+    return blocks.filter((b) => recommendationsUnder(text, b, masked).length > 0);
+  };
+  const closing = assistantTurnTexts[assistantTurnTexts.length - 1];
+  if (asksIn(closing).length > 0) return null;
+  for (let i = assistantTurnTexts.length - 2; i >= 0; i -= 1) {
+    const earlier = assistantTurnTexts[i];
+    const blocks = asksIn(earlier);
+    if (blocks.length === 0) continue;
+    const block = blocks[blocks.length - 1];
+    return {
+      detector: "pending-decision",
+      // The option NUMBERS and the line span, never the option text: the
+      // evidence is quoted into a refusal that reaches the transcript, and
+      // an options block can carry anything the reply carried.
+      evidence: `options ${block.numbers.join("/")} at lines ${block.startLine}-${block.endLine} of an earlier reply this turn (closing reply read from ${closingFromPayload ? "the stop payload" : "the transcript"})`,
+      reason: "an earlier reply in THIS turn put numbered options to the user and no user answer followed \u2014 this closing reply carries no options block, so the decision disappeared without being answered, cancelled or superseded. A hook nudge, a reviewer result or a task notification may ADD to a turn; it may not displace a question already asked (user-interaction Iron Law 3: a decision handed to the user outlives the turn). Re-present the block and its recommendation line at the end of this reply"
+    };
+  }
+  return null;
+}
 
 // src/scripts/hooks/subagent_ledger_hook.ts
 import * as crypto10 from "node:crypto";
-import * as fs83 from "node:fs";
-import * as path84 from "node:path";
-import { fileURLToPath as fileURLToPath57, pathToFileURL as pathToFileURL49 } from "node:url";
+import * as fs87 from "node:fs";
+import * as path89 from "node:path";
+import { fileURLToPath as fileURLToPath60, pathToFileURL as pathToFileURL51 } from "node:url";
 
 // src/scripts/_lib/subagent_response.ts
 var MAX_SUMMARY_CHARS = 2e3;
@@ -34465,7 +35102,7 @@ var EXIT_ALLOW26 = 0;
 function isObject13(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var LEDGER_DIR = path84.join("agents", "runtime", "state", "subagent-ledger");
+var LEDGER_DIR = path89.join("agents", "runtime", "state", "subagent-ledger");
 var OPEN_SUBDIR = "open";
 var OPEN_RECORD_TTL_MS = 24 * 60 * 60 * 1e3;
 function refFor(agentId) {
@@ -34555,10 +35192,10 @@ function _jsonObjectCandidates(message) {
   return out;
 }
 function openDir(root) {
-  return path84.join(root, LEDGER_DIR, OPEN_SUBDIR);
+  return path89.join(root, LEDGER_DIR, OPEN_SUBDIR);
 }
 function openFile(root, ref) {
-  return path84.join(openDir(root), `${ref}.json`);
+  return path89.join(openDir(root), `${ref}.json`);
 }
 var DEPTH_BASES = /* @__PURE__ */ new Set(["observed", "asserted-parent", "assumed-root"]);
 function _asOpenRecord(value, expectedRef) {
@@ -34585,7 +35222,7 @@ function readOpenRecords(root) {
   const out = /* @__PURE__ */ new Map();
   let names;
   try {
-    names = fs83.readdirSync(openDir(root));
+    names = fs87.readdirSync(openDir(root));
   } catch {
     return out;
   }
@@ -34593,7 +35230,7 @@ function readOpenRecords(root) {
     if (!name.endsWith(".json")) continue;
     const expectedRef = name.slice(0, -".json".length);
     try {
-      const raw = fs83.readFileSync(path84.join(openDir(root), name), "utf8");
+      const raw = fs87.readFileSync(path89.join(openDir(root), name), "utf8");
       const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
       if (rec) out.set(rec.ref, rec);
     } catch {
@@ -34608,13 +35245,13 @@ function resolveDepth(parentRef, open) {
   return { depth: parent.depth + 1, depth_basis: "observed" };
 }
 function ledgerFileFor2(root, ts) {
-  return path84.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
+  return path89.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
 }
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
   const file = ledgerFileFor2(root, ts);
-  fs83.mkdirSync(path84.dirname(file), { recursive: true });
-  fs83.appendFileSync(file, `${JSON.stringify(line)}
+  fs87.mkdirSync(path89.dirname(file), { recursive: true });
+  fs87.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 var WALL_CLOCK_ARMS_MS = [
@@ -34628,7 +35265,7 @@ function armsExceeded(elapsedMs) {
   return WALL_CLOCK_ARMS_MS.filter((a) => elapsedMs >= a.ms).map((a) => a.label);
 }
 function openRecordStats(root, nowMs = Date.now()) {
-  const ledgerPresent = fs83.existsSync(path84.join(root, LEDGER_DIR));
+  const ledgerPresent = fs87.existsSync(path89.join(root, LEDGER_DIR));
   const open = readOpenRecords(root);
   let maxDepth = 0;
   let counted = 0;
@@ -34656,13 +35293,13 @@ function writeOpenRecord(root, rec) {
 function removeOpenRecord(root, ref) {
   if (is_replay_mode()) return;
   try {
-    fs83.unlinkSync(openFile(root, ref));
+    fs87.unlinkSync(openFile(root, ref));
   } catch {
   }
 }
 function countOpen(root) {
   try {
-    return fs83.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+    return fs87.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
   } catch {
     return 0;
   }
@@ -34813,7 +35450,7 @@ function resolveConsumerRoot(envelope) {
   }
   return process.cwd();
 }
-function main55() {
+function main57() {
   const raw = readHookStdin();
   let envelope = {};
   try {
@@ -34823,20 +35460,20 @@ function main55() {
   }
   return processEnvelope3(envelope, resolveConsumerRoot(envelope));
 }
-function _isCliEntry39() {
+function _isCliEntry41() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL49(path84.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL51(path89.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs83.realpathSync(fileURLToPath57(import.meta.url)) === fs83.realpathSync(path84.resolve(process.argv[1]));
+    return fs87.realpathSync(fileURLToPath60(import.meta.url)) === fs87.realpathSync(path89.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry39()) process.exit(main55());
+if (_isCliEntry41()) process.exit(main57());
 
 // src/scripts/hooks/turn_end_gate_hook.ts
 var EXIT_BLOCK3 = 1;
@@ -34945,7 +35582,7 @@ function detectPromissory(reply) {
 function readCiSettled(workspaceRoot3, session_id) {
   if (!hasStableSessionId(session_id)) return { seen: false, settled: false };
   try {
-    const raw = fs84.readFileSync(path85.join(workspaceRoot3, statePathFor(session_id)), "utf-8");
+    const raw = fs88.readFileSync(path90.join(workspaceRoot3, statePathFor(session_id)), "utf-8");
     const decoded = JSON.parse(raw);
     if (!owns_session_state(decoded, session_id)) return { seen: false, settled: false };
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
@@ -34981,8 +35618,8 @@ function detectCompletionClaim(reply, ci) {
 function readLanguagePin(workspaceRoot3, session_id) {
   if (!hasStableSessionId(session_id)) return "und";
   try {
-    const raw = fs84.readFileSync(
-      path85.join(workspaceRoot3, statePathFor2(session_id)),
+    const raw = fs88.readFileSync(
+      path90.join(workspaceRoot3, statePathFor2(session_id)),
       "utf-8"
     );
     const decoded = JSON.parse(raw);
@@ -35033,12 +35670,37 @@ function detectUnverifiedEdit(toolCalls) {
     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)"
   };
 }
+var _SOURCE_RE = /\.(?:ts|tsx|js|jsx|mjs|cjs|vue|svelte|php|py|rb|go|rs|java|kt|swift|cs|scala|ex|exs)$/i;
+var _TEST_PATH_RE = /(?:^|\/)(?:tests?|specs?|__tests__|__specs__|e2e|cypress|playwright|features)\//i;
+var _TEST_FILE_RE = /(?:\.(?:test|spec)\.[a-z]+$)|(?:_test\.[a-z]+$)|(?:(?:^|\/)test_[^/]+$)|(?:Test\.php$)|(?:Spec\.php$)|(?:\.feature$)/i;
+function _isTestPath(p) {
+  return _TEST_PATH_RE.test(p) || _TEST_FILE_RE.test(p);
+}
+function _isProductionSource(p) {
+  return _SOURCE_RE.test(p) && !_isTestPath(p);
+}
+function detectUntestedChange(reply, toolCalls) {
+  const edited = toolCalls.filter((c) => _EDIT_TOOLS.has(c.name) && c.path !== void 0).map((c) => c.path);
+  const source = edited.filter(_isProductionSource);
+  if (source.length === 0) return null;
+  if (edited.some(_isTestPath)) return null;
+  const prose = visibleProse(reply);
+  const m = _COMPLETION_RE.exec(prose);
+  if (!m) return null;
+  if (_NEGATED_CLAIM_RE.test(_lineAround(prose, m.index))) return null;
+  const shown = source.slice(0, 3).join(", ");
+  return {
+    detector: "untested",
+    evidence: shown + (source.length > 3 ? ` (+${String(source.length - 3)} more)` : ""),
+    reason: "a completion claim over production code this turn changed, with NO test file touched anywhere in the turn \u2014 running a linter is not evidence the change works. Write the test that would have caught the failure, and enumerate the states the change actually has (every view, every CRUD path, the empty and error states) rather than the happy one. If a test genuinely does not belong here, say which file carries the coverage instead"
+  };
+}
 function sessionStateFile2(workspaceRoot3, sessionKey) {
   return sessionRefusalFile(workspaceRoot3, sessionKey);
 }
 function alreadyRefusedTurn(workspaceRoot3, sessionKey, turnOrdinal) {
   try {
-    const raw = fs84.readFileSync(sessionStateFile2(workspaceRoot3, sessionKey), "utf-8");
+    const raw = fs88.readFileSync(sessionStateFile2(workspaceRoot3, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -35047,12 +35709,12 @@ function alreadyRefusedTurn(workspaceRoot3, sessionKey, turnOrdinal) {
   }
   return false;
 }
-function markRefusedTurn(workspaceRoot3, sessionKey, turnOrdinal, detectors) {
+function markRefusedTurn(workspaceRoot3, sessionKey, turnOrdinal, detectors, promptId) {
   if (is_replay_mode()) return;
   const file = sessionStateFile2(workspaceRoot3, sessionKey);
   let prev = null;
   try {
-    prev = parseRecord(fs84.readFileSync(file, "utf-8"));
+    prev = parseRecord(fs88.readFileSync(file, "utf-8"));
   } catch {
   }
   let version;
@@ -35068,27 +35730,34 @@ function markRefusedTurn(workspaceRoot3, sessionKey, turnOrdinal, detectors) {
         detectors,
         turnOrdinal,
         at: (/* @__PURE__ */ new Date()).toISOString(),
-        version
+        version,
+        promptId
       })
     );
   } catch {
   }
 }
 function readTranscriptTail(transcriptPath, opts = {}) {
-  const empty = { lastAssistant: "", turnOrdinal: 0, toolCalls: [] };
+  const empty = {
+    lastAssistant: "",
+    turnOrdinal: 0,
+    toolCalls: [],
+    assistantTurnTexts: []
+  };
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs84.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs88.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs84.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs88.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
   let lastAssistant = "";
   let turnOrdinal = 0;
   let toolCalls = [];
+  let assistantTurnTexts = [];
   for (const rawLine of lines) {
     const line = rawLine.trim();
     if (!line) continue;
@@ -35107,20 +35776,27 @@ function readTranscriptTail(transcriptPath, opts = {}) {
     if (typeof msg !== "object" || msg === null || Array.isArray(msg)) continue;
     const content = msg["content"];
     if (role === "assistant") {
-      toolCalls.push(..._toolCalls(content));
+      toolCalls.push(...extractToolCalls(content));
     }
     const text = _messageText(content);
     if (text === null) continue;
     if (role === "assistant") {
       lastAssistant = text;
+      assistantTurnTexts.push(text);
     } else if (!isSyntheticPrompt(text)) {
       turnOrdinal += 1;
       toolCalls = [];
+      assistantTurnTexts = [];
     }
   }
-  return { lastAssistant: lastAssistant.trim(), turnOrdinal, toolCalls };
+  return {
+    lastAssistant: lastAssistant.trim(),
+    turnOrdinal,
+    toolCalls,
+    assistantTurnTexts
+  };
 }
-function _toolCalls(content) {
+function extractToolCalls(content) {
   if (!Array.isArray(content)) return [];
   const out = [];
   for (const blk of content) {
@@ -35158,7 +35834,7 @@ function _messageText(content) {
 function str8(v) {
   return typeof v === "string" ? v : "";
 }
-function main56() {
+function main58() {
   let envelope;
   let payload;
   try {
@@ -35176,10 +35852,19 @@ function main56() {
   const transcriptPath = str8(
     payload["transcript_path"] ?? payload["transcriptPath"]
   );
-  const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
-    maxBytes: TRANSCRIPT_READ_MAX_BYTES
-  });
+  const { lastAssistant, turnOrdinal, toolCalls, assistantTurnTexts } = readTranscriptTail(
+    transcriptPath,
+    { maxBytes: TRANSCRIPT_READ_MAX_BYTES }
+  );
   if (!lastAssistant) return EXIT_ALLOW27;
+  const payloadClosing = str8(
+    payload["last_assistant_message"] ?? payload["lastAssistantMessage"]
+  );
+  const closingFromPayload = payloadClosing !== "" && !assistantTurnTexts.includes(payloadClosing);
+  const turnTexts = closingFromPayload ? [...assistantTurnTexts, payloadClosing] : assistantTurnTexts;
+  const promptId = str8(
+    payload["prompt_id"] ?? payload["promptId"]
+  );
   const rawSessionId = str8(envelope["session_id"]) || "";
   const sessionKey = deriveSessionKey(rawSessionId || "unknown-session");
   if (alreadyRefusedTurn(workspaceRoot3, sessionKey, turnOrdinal)) return EXIT_ALLOW27;
@@ -35201,7 +35886,23 @@ function main56() {
     // gating is where the comment above says gating belongs — inside the
     // detector: no CI observed, or a settled read, or no completion claim
     // ⇒ no finding.
-    dispatchOpen ? null : detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot3, rawSessionId))
+    dispatchOpen ? null : detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot3, rawSessionId)),
+    // Detector E is UNCONDITIONAL, and that is the opposite choice from A
+    // and D one line above rather than an oversight. An open dispatch
+    // excuses a promissory closing because the work is genuinely still
+    // running; it excuses nothing about a question the user was already
+    // asked. Worse: a dispatch — or the `end-review-nudge` stop concern
+    // that produced the measured failure — IS the continuation that drops
+    // the decision, so narrowing E the same way would silence it in exactly
+    // the case it exists for.
+    detectDroppedDecision(turnTexts, closingFromPayload),
+    // Detector F takes the OTHER side of that same question, and the two
+    // sitting adjacent is the clearest place to say why. E fires on a
+    // question already asked, which an open dispatch cannot excuse. F fires
+    // on a completion CLAIM, and a turn waiting on a subagent has not
+    // finished — so its closing is not the claim F is about. Same slot,
+    // opposite trigger, opposite treatment of `dispatchOpen`.
+    dispatchOpen ? null : detectUntestedChange(lastAssistant, toolCalls)
   ]) {
     if (f) findings.push(f);
   }
@@ -35210,7 +35911,8 @@ function main56() {
     workspaceRoot3,
     sessionKey,
     turnOrdinal,
-    findings.map((f) => f.detector)
+    findings.map((f) => f.detector),
+    promptId
   );
   const lines = findings.map(
     (f) => `  \xB7 ${f.detector}: ${f.reason}
@@ -35219,41 +35921,41 @@ function main56() {
   process.stderr.write(
     `turn-end-gate: REFUSED \u2014 this turn is not finished.
 ${lines.join("\n")}
-  Do the promised work now, correct the language, run the verification the edit needs, or read the CI verdict before claiming it \u2014 then end the turn.
+  Do the promised work now, correct the language, run the verification the edit needs, read the CI verdict before claiming it, or re-present the options block this turn dropped \u2014 then end the turn.
   This turn will not be refused a second time.
 `
   );
   return EXIT_BLOCK3;
 }
-function _isCliEntry40() {
+function _isCliEntry42() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL50(path85.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL52(path90.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs84.realpathSync(fileURLToPath58(import.meta.url));
-    const argv = fs84.realpathSync(path85.resolve(process.argv[1]));
+    const here = fs88.realpathSync(fileURLToPath61(import.meta.url));
+    const argv = fs88.realpathSync(path90.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry40()) {
-  process.exit(main56());
+if (_isCliEntry42()) {
+  process.exit(main58());
 }
 
 // src/scripts/hooks/edit_shape_hook.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 import * as crypto11 from "node:crypto";
-import * as fs85 from "node:fs";
-import * as path86 from "node:path";
-import { fileURLToPath as fileURLToPath59, pathToFileURL as pathToFileURL51 } from "node:url";
+import * as fs89 from "node:fs";
+import * as path91 from "node:path";
+import { fileURLToPath as fileURLToPath62, pathToFileURL as pathToFileURL53 } from "node:url";
 var EXIT_ALLOW28 = 0;
 var EXIT_WARN16 = 2;
 var MIN_FILE_LINES = 50;
@@ -35293,7 +35995,7 @@ function parseNumstatLines(raw) {
 }
 function effectiveDiffLines(cwd, relPath) {
   try {
-    const r = spawnSync7("git", ["diff", "HEAD", "--numstat", "--", relPath], {
+    const r = spawnSync8("git", ["diff", "HEAD", "--numstat", "--", relPath], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -35306,7 +36008,7 @@ function effectiveDiffLines(cwd, relPath) {
 }
 function fileLineCount(absPath) {
   try {
-    const text = fs85.readFileSync(absPath, "utf8");
+    const text = fs89.readFileSync(absPath, "utf8");
     if (text.length === 0) return 0;
     return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
   } catch {
@@ -35323,11 +36025,11 @@ function deriveSessionKey3(envelope, payload) {
   return crypto11.createHash("sha256").update(material).digest("hex");
 }
 function sessionStateFile3(workspaceRoot3, sessionKey) {
-  return path86.join(workspaceRoot3, "agents", "runtime", "state", "edit-shape", `${sessionKey}.json`);
+  return path91.join(workspaceRoot3, "agents", "runtime", "state", "edit-shape", `${sessionKey}.json`);
 }
 function hasFiredThisSession2(workspaceRoot3, sessionKey) {
   try {
-    return fs85.existsSync(sessionStateFile3(workspaceRoot3, sessionKey));
+    return fs89.existsSync(sessionStateFile3(workspaceRoot3, sessionKey));
   } catch {
     return false;
   }
@@ -35348,7 +36050,7 @@ function extractFilePath2(payload) {
   if (!isObject14(ti)) return "";
   return str9(ti["file_path"] ?? ti["path"] ?? ti["filePath"]);
 }
-function main57() {
+function main59() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
     const event = str9(envelope["event"]);
@@ -35358,8 +36060,8 @@ function main57() {
     const filePath = extractFilePath2(payload);
     if (!filePath) return EXIT_ALLOW28;
     const workspaceRoot3 = str9(envelope["workspace_root"]).trim() || process.cwd();
-    const absPath = path86.isAbsolute(filePath) ? filePath : path86.resolve(workspaceRoot3, filePath);
-    const relPath = path86.relative(workspaceRoot3, absPath);
+    const absPath = path91.isAbsolute(filePath) ? filePath : path91.resolve(workspaceRoot3, filePath);
+    const relPath = path91.relative(workspaceRoot3, absPath);
     if (isExemptPath(relPath) || isExemptPath(absPath)) return EXIT_ALLOW28;
     const fileLines = fileLineCount(absPath);
     if (fileLines < MIN_FILE_LINES) return EXIT_ALLOW28;
@@ -35382,54 +36084,54 @@ function main57() {
     return EXIT_ALLOW28;
   }
 }
-function _isCliEntry41() {
+function _isCliEntry43() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL51(path86.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL53(path91.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs85.realpathSync(fileURLToPath59(import.meta.url));
-    const argv = fs85.realpathSync(path86.resolve(process.argv[1]));
+    const here = fs89.realpathSync(fileURLToPath62(import.meta.url));
+    const argv = fs89.realpathSync(path91.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry41()) {
-  process.exit(main57());
+if (_isCliEntry43()) {
+  process.exit(main59());
 }
 
 // src/scripts/hooks/comment_discipline_hook.ts
-import * as fs87 from "node:fs";
-import * as path89 from "node:path";
-import { fileURLToPath as fileURLToPath61, pathToFileURL as pathToFileURL52 } from "node:url";
+import * as fs91 from "node:fs";
+import * as path94 from "node:path";
+import { fileURLToPath as fileURLToPath64, pathToFileURL as pathToFileURL54 } from "node:url";
 
 // src/scripts/lint_code_comments.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
-import * as fs86 from "node:fs";
+import { spawnSync as spawnSync10 } from "node:child_process";
+import * as fs90 from "node:fs";
 import * as os12 from "node:os";
-import * as path88 from "node:path";
+import * as path93 from "node:path";
 import process15 from "node:process";
-import { fileURLToPath as fileURLToPath60 } from "node:url";
+import { fileURLToPath as fileURLToPath63 } from "node:url";
 
 // src/scripts/_lib/gate_self_test.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
-import * as path87 from "node:path";
+import { spawnSync as spawnSync9 } from "node:child_process";
+import * as path92 from "node:path";
 import process14 from "node:process";
 function runGateCli(repoRoot, scriptRelPath, args, cwd) {
-  const tsx = path87.join(
+  const tsx = path92.join(
     repoRoot,
     "node_modules",
     ".bin",
     process14.platform === "win32" ? "tsx.cmd" : "tsx"
   );
-  const res = spawnSync8(tsx, [path87.join(repoRoot, scriptRelPath), ...args], {
+  const res = spawnSync9(tsx, [path92.join(repoRoot, scriptRelPath), ...args], {
     cwd,
     encoding: "utf-8",
     maxBuffer: 64 * 1024 * 1024,
@@ -35481,7 +36183,7 @@ ${opts.gate} --self-test: ${String(opts.cases.length - failed)}/${String(opts.ca
 }
 
 // src/scripts/lint_code_comments.ts
-var _HERE11 = fileURLToPath60(import.meta.url);
+var _HERE13 = fileURLToPath63(import.meta.url);
 var SCANNED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -35741,20 +36443,20 @@ function scanText2(file, text) {
 function isScannable(rel) {
   if (SKIP_SEGMENTS.some((s) => rel.includes(s))) return false;
   if (rel.endsWith(".d.ts")) return false;
-  return SCANNED_EXTENSIONS.has(path88.extname(rel));
+  return SCANNED_EXTENSIONS.has(path93.extname(rel));
 }
 function changedFiles(root, base) {
-  const r = spawnSync9("git", ["diff", "--name-only", "--diff-filter=ACMR", `${base}...HEAD`], {
+  const r = spawnSync10("git", ["diff", "--name-only", "--diff-filter=ACMR", `${base}...HEAD`], {
     cwd: root,
     encoding: "utf-8"
   });
   const tracked = r.status === 0 ? r.stdout.split("\n") : [];
-  const u = spawnSync9("git", ["ls-files", "--others", "--exclude-standard"], {
+  const u = spawnSync10("git", ["ls-files", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "utf-8"
   });
   const untracked = u.status === 0 ? u.stdout.split("\n") : [];
-  const m = spawnSync9("git", ["diff", "--name-only", "--diff-filter=ACMR"], {
+  const m = spawnSync10("git", ["diff", "--name-only", "--diff-filter=ACMR"], {
     cwd: root,
     encoding: "utf-8"
   });
@@ -35763,7 +36465,7 @@ function changedFiles(root, base) {
 }
 function addedLineMap(root, base) {
   const out = /* @__PURE__ */ new Map();
-  const u = spawnSync9("git", ["ls-files", "--others", "--exclude-standard"], {
+  const u = spawnSync10("git", ["ls-files", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "utf-8"
   });
@@ -35776,7 +36478,7 @@ function addedLineMap(root, base) {
     ["diff", "--unified=0", "--diff-filter=ACMR", `${base}...HEAD`],
     ["diff", "--unified=0", "--diff-filter=ACMR"]
   ]) {
-    const r = spawnSync9("git", argv, { cwd: root, encoding: "utf-8" });
+    const r = spawnSync10("git", argv, { cwd: root, encoding: "utf-8" });
     if (r.status !== 0) continue;
     mergeAddedLines(out, parseAddedLines(r.stdout));
   }
@@ -35919,11 +36621,11 @@ var COMMENT_CASES = [
   }
 ];
 function selfTest2() {
-  const repoRoot = path88.resolve(path88.dirname(_HERE11), "..", "..");
-  const dir = fs86.mkdtempSync(path88.join(os12.tmpdir(), "lcc-selftest-"));
+  const repoRoot = path93.resolve(path93.dirname(_HERE13), "..", "..");
+  const dir = fs90.mkdtempSync(path93.join(os12.tmpdir(), "lcc-selftest-"));
   const exercise = (testCase, index) => {
-    const file = path88.join(dir, `case-${String(index)}.ts`);
-    fs86.writeFileSync(file, testCase.source, "utf-8");
+    const file = path93.join(dir, `case-${String(index)}.ts`);
+    fs90.writeFileSync(file, testCase.source, "utf-8");
     return runGateCli(repoRoot, "src/scripts/lint_code_comments.ts", ["--paths", file], dir);
   };
   try {
@@ -35938,7 +36640,7 @@ function selfTest2() {
       }))
     });
   } finally {
-    fs86.rmSync(dir, { recursive: true, force: true });
+    fs90.rmSync(dir, { recursive: true, force: true });
   }
 }
 var HELP = `usage: lint_code_comments [--base <ref>] [--root <dir>] [--paths <f> \u2026] [--report]
@@ -35953,7 +36655,7 @@ Classes: de-comment \xB7 report-comment \xB7 provenance-comment
 Escape:  code-comment-allow <class|*> -- <reason>   (per line)
          code-comment-allow-file -- <reason>        (first 2000 chars)
 `;
-function main58(argv) {
+function main60(argv) {
   if (argv.includes("--help") || argv.includes("-h")) {
     process15.stdout.write(HELP);
     return 0;
@@ -35966,7 +36668,7 @@ function main58(argv) {
     return selfTest2();
   }
   let base = "origin/main";
-  let root = path88.resolve(path88.dirname(_HERE11), "..", "..");
+  let root = path93.resolve(path93.dirname(_HERE13), "..", "..");
   let reportOnly = false;
   const explicit = [];
   for (let i = 0; i < argv.length; i++) {
@@ -35977,7 +36679,7 @@ function main58(argv) {
     } else if (a === "--base") {
       base = argv[++i] ?? "";
     } else if (a === "--root") {
-      root = path88.resolve(argv[++i] ?? ".");
+      root = path93.resolve(argv[++i] ?? ".");
     } else if (a === "--report") {
       reportOnly = true;
     } else if (a === "--paths") {
@@ -35996,10 +36698,10 @@ ${HELP}`);
   const added = explicit.length > 0 ? null : addedLineMap(root, base);
   const findings = [];
   for (const rel of candidates) {
-    const abs = path88.isAbsolute(rel) ? rel : path88.join(root, rel);
+    const abs = path93.isAbsolute(rel) ? rel : path93.join(root, rel);
     let text;
     try {
-      text = fs86.readFileSync(abs, "utf-8");
+      text = fs90.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -36060,12 +36762,12 @@ var _isMain6 = (() => {
   const entry = process15.argv[1];
   if (!entry) return false;
   try {
-    return fs86.realpathSync(entry) === fs86.realpathSync(_HERE11);
+    return fs90.realpathSync(entry) === fs90.realpathSync(_HERE13);
   } catch {
     return false;
   }
 })();
-if (_isMain6) process15.exit(main58(process15.argv.slice(2)));
+if (_isMain6) process15.exit(main60(process15.argv.slice(2)));
 
 // src/scripts/hooks/comment_discipline_hook.ts
 var EXIT_ALLOW29 = 0;
@@ -36092,7 +36794,7 @@ function buildAdvisoryLine3(file, findings) {
   const more = findings.length > MAX_REPORTED ? `, +${findings.length - MAX_REPORTED} more` : "";
   return `comment-discipline: the text just written to ${file} carries ${summary} \u2014 ${named}${more}. A comment states a WHY or a constraint the code cannot show, in English; evidence for a roadmap step belongs in that roadmap, not in a second copy in the source. Rewrite or delete those lines now, before the next write \u2014 \`lint_code_comments\` refuses them at the gate.`;
 }
-function main59() {
+function main61() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
     const event = str10(envelope["event"]);
@@ -36108,9 +36810,9 @@ function main59() {
     const text = writtenText(toolName2, ti);
     if (!text) return EXIT_ALLOW29;
     const workspaceRoot3 = str10(envelope["workspace_root"]).trim() || process.cwd();
-    const abs = path89.isAbsolute(filePath) ? filePath : path89.resolve(workspaceRoot3, filePath);
-    const rel = path89.relative(workspaceRoot3, abs);
-    const shown = rel.startsWith("..") ? path89.basename(abs) : rel;
+    const abs = path94.isAbsolute(filePath) ? filePath : path94.resolve(workspaceRoot3, filePath);
+    const rel = path94.relative(workspaceRoot3, abs);
+    const shown = rel.startsWith("..") ? path94.basename(abs) : rel;
     const findings = scanText2(shown, text);
     if (findings.length === 0) return EXIT_ALLOW29;
     process.stdout.write(
@@ -36126,24 +36828,24 @@ function main59() {
     return EXIT_ALLOW29;
   }
 }
-function _isCliEntry42() {
+function _isCliEntry44() {
   if (true) return false;
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL52(path89.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL54(path94.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs87.realpathSync(fileURLToPath61(import.meta.url)) === fs87.realpathSync(path89.resolve(process.argv[1]));
+    return fs91.realpathSync(fileURLToPath64(import.meta.url)) === fs91.realpathSync(path94.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry42()) process.exit(main59());
+if (_isCliEntry44()) process.exit(main61());
 
 // src/scripts/hooks/reread_guard_hook.ts
 import * as crypto12 from "node:crypto";
-import * as fs88 from "node:fs";
-import * as path90 from "node:path";
-import { fileURLToPath as fileURLToPath62, pathToFileURL as pathToFileURL53 } from "node:url";
+import * as fs92 from "node:fs";
+import * as path95 from "node:path";
+import { fileURLToPath as fileURLToPath65, pathToFileURL as pathToFileURL55 } from "node:url";
 var EXIT_ALLOW30 = 0;
 var EXIT_WARN18 = 2;
 var EXEMPT_PATH_PATTERNS2 = [
@@ -36179,11 +36881,11 @@ function deriveSessionKey4(envelope, payload) {
   return crypto12.createHash("sha256").update(material).digest("hex");
 }
 function ledgerFile(workspaceRoot3, sessionKey) {
-  return path90.join(workspaceRoot3, "agents", "runtime", "state", "reread-guard", `${sessionKey}.json`);
+  return path95.join(workspaceRoot3, "agents", "runtime", "state", "reread-guard", `${sessionKey}.json`);
 }
 function readLedger(workspaceRoot3, sessionKey) {
   try {
-    const parsed = JSON.parse(fs88.readFileSync(ledgerFile(workspaceRoot3, sessionKey), "utf8"));
+    const parsed = JSON.parse(fs92.readFileSync(ledgerFile(workspaceRoot3, sessionKey), "utf8"));
     if (!isObject16(parsed)) return emptyLedger();
     return {
       reads: isObject16(parsed["reads"]) ? parsed["reads"] : {},
@@ -36224,7 +36926,7 @@ 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 main60() {
+function main62() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
     const event = str11(envelope["event"]);
@@ -36237,8 +36939,8 @@ function main60() {
     const filePath = extractFilePath3(toolInput);
     if (!filePath) return EXIT_ALLOW30;
     const workspaceRoot3 = str11(envelope["workspace_root"]).trim() || process.cwd();
-    const absPath = path90.isAbsolute(filePath) ? filePath : path90.resolve(workspaceRoot3, filePath);
-    const relPath = path90.relative(workspaceRoot3, absPath);
+    const absPath = path95.isAbsolute(filePath) ? filePath : path95.resolve(workspaceRoot3, filePath);
+    const relPath = path95.relative(workspaceRoot3, absPath);
     if (isExemptPath2(relPath) || isExemptPath2(absPath)) return EXIT_ALLOW30;
     const sessionKey = deriveSessionKey4(envelope, payload);
     const ledger = readLedger(workspaceRoot3, sessionKey);
@@ -36254,7 +36956,7 @@ function main60() {
     let mtime;
     let size;
     try {
-      const st = fs88.statSync(absPath);
+      const st = fs92.statSync(absPath);
       mtime = st.mtimeMs;
       size = st.size;
     } catch {
@@ -36287,34 +36989,34 @@ function main60() {
     return EXIT_ALLOW30;
   }
 }
-function _isCliEntry43() {
+function _isCliEntry45() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL53(path90.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL55(path95.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs88.realpathSync(fileURLToPath62(import.meta.url));
-    const argv = fs88.realpathSync(path90.resolve(process.argv[1]));
+    const here = fs92.realpathSync(fileURLToPath65(import.meta.url));
+    const argv = fs92.realpathSync(path95.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry43()) {
-  process.exit(main60());
+if (_isCliEntry45()) {
+  process.exit(main62());
 }
 
 // src/scripts/hooks/session_eol_hook.ts
-import * as fs95 from "node:fs";
-import * as path97 from "node:path";
+import * as fs99 from "node:fs";
+import * as path102 from "node:path";
 import process16 from "node:process";
-import { fileURLToPath as fileURLToPath63, pathToFileURL as pathToFileURL54 } from "node:url";
+import { fileURLToPath as fileURLToPath66, pathToFileURL as pathToFileURL56 } from "node:url";
 
 // src/config/recycle-threshold-budget.json
 var recycle_threshold_budget_default = {
@@ -36332,13 +37034,13 @@ var recycle_threshold_budget_default = {
 
 // src/scripts/_lib/session_eol.ts
 import * as crypto13 from "node:crypto";
-import * as fs89 from "node:fs";
-import * as path92 from "node:path";
+import * as fs93 from "node:fs";
+import * as path97 from "node:path";
 
 // src/scripts/_lib/cc_transcript.ts
-import * as path91 from "node:path";
+import * as path96 from "node:path";
 import { homedir as homedir8 } from "node:os";
-var DEFAULT_PROJECTS_ROOT = path91.join(homedir8(), ".claude", "projects");
+var DEFAULT_PROJECTS_ROOT = path96.join(homedir8(), ".claude", "projects");
 function billableInputTokens(u) {
   return u.input_tokens + u.cache_read_input_tokens + u.cache_creation_input_tokens;
 }
@@ -36447,10 +37149,10 @@ function scanEolSlice(text, prior) {
   return next;
 }
 function eolStateDir(workspaceRoot3) {
-  return path92.join(workspaceRoot3, "agents", "runtime", "state", "session-eol");
+  return path97.join(workspaceRoot3, "agents", "runtime", "state", "session-eol");
 }
 function eolStateFile(workspaceRoot3, sessionKey) {
-  return path92.join(eolStateDir(workspaceRoot3), `${sessionKey}.json`);
+  return path97.join(eolStateDir(workspaceRoot3), `${sessionKey}.json`);
 }
 function eolSessionKey(raw) {
   return crypto13.createHash("sha256").update(raw || "unknown-session").digest("hex");
@@ -36467,7 +37169,7 @@ function is_substantive(counters) {
 }
 function readNewCompleteLines(filePath, fromByte) {
   try {
-    const { size } = fs89.statSync(filePath);
+    const { size } = fs93.statSync(filePath);
     if (size < fromByte) {
       return { text: "", nextOffset: 0, truncated: true };
     }
@@ -36476,11 +37178,11 @@ function readNewCompleteLines(filePath, fromByte) {
     }
     const length = size - fromByte;
     const buffer = Buffer.alloc(length);
-    const fd = fs89.openSync(filePath, "r");
+    const fd = fs93.openSync(filePath, "r");
     try {
-      fs89.readSync(fd, buffer, 0, length, fromByte);
+      fs93.readSync(fd, buffer, 0, length, fromByte);
     } finally {
-      fs89.closeSync(fd);
+      fs93.closeSync(fd);
     }
     const lastNewline = buffer.lastIndexOf(10);
     if (lastNewline === -1) {
@@ -36497,23 +37199,23 @@ function readNewCompleteLines(filePath, fromByte) {
 }
 
 // src/scripts/_lib/context_observation.ts
-import * as fs91 from "node:fs";
-import * as path94 from "node:path";
+import * as fs95 from "node:fs";
+import * as path99 from "node:path";
 
 // src/scripts/_lib/loop_guards.ts
-import * as fs90 from "node:fs";
-import * as path93 from "node:path";
+import * as fs94 from "node:fs";
+import * as path98 from "node:path";
 function atomicWriteJson(file, value) {
   const tmp = `${file}.${String(process.pid)}.tmp`;
   try {
-    fs90.mkdirSync(path93.dirname(file), { recursive: true });
-    fs90.writeFileSync(tmp, `${JSON.stringify(value)}
+    fs94.mkdirSync(path98.dirname(file), { recursive: true });
+    fs94.writeFileSync(tmp, `${JSON.stringify(value)}
 `, "utf8");
-    fs90.renameSync(tmp, file);
+    fs94.renameSync(tmp, file);
     return true;
   } catch {
     try {
-      fs90.unlinkSync(tmp);
+      fs94.unlinkSync(tmp);
     } catch {
     }
     return false;
@@ -36559,7 +37261,7 @@ function stallSignal(history, window = 3) {
 }
 function readUnavailableDependency(transcriptPath) {
   try {
-    const raw = fs90.readFileSync(transcriptPath, "utf8");
+    const raw = fs94.readFileSync(transcriptPath, "utf8");
     return detectUnavailableDependency(raw.slice(-DEPENDENCY_SCAN_BYTES));
   } catch {
     return null;
@@ -36567,18 +37269,18 @@ function readUnavailableDependency(transcriptPath) {
 }
 
 // src/scripts/_lib/context_observation.ts
-var CONTEXT_OBSERVATION_REL = path94.join(
+var CONTEXT_OBSERVATION_REL = path99.join(
   "agents",
   "runtime",
   "state",
   "context-observation.json"
 );
 function observationFile(repoRoot) {
-  return path94.join(repoRoot, CONTEXT_OBSERVATION_REL);
+  return path99.join(repoRoot, CONTEXT_OBSERVATION_REL);
 }
 function readContextObservation(repoRoot) {
   try {
-    const parsed = JSON.parse(fs91.readFileSync(observationFile(repoRoot), "utf-8"));
+    const parsed = JSON.parse(fs95.readFileSync(observationFile(repoRoot), "utf-8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     const o = parsed;
     if (typeof o["fingerprint"] !== "string" || o["fingerprint"] === "") return null;
@@ -36600,8 +37302,8 @@ function premiseMoved(claimed, observed) {
 }
 
 // src/scripts/_lib/run_checkpoint.ts
-import * as fs92 from "node:fs";
-import * as path95 from "node:path";
+import * as fs96 from "node:fs";
+import * as path100 from "node:path";
 
 // src/scripts/_lib/roadmap_checkboxes.ts
 var CHECKBOX_LINE = /^[ \t]*[-*][ \t]+\[([ xX~-])\][ \t]+(.*)$/;
@@ -36631,7 +37333,7 @@ function phaseLines(text) {
 }
 
 // src/scripts/_lib/run_checkpoint.ts
-var CHECKPOINT_DIR_REL = path95.join("agents", "runtime", "state", "checkpoints");
+var CHECKPOINT_DIR_REL = path100.join("agents", "runtime", "state", "checkpoints");
 function countRoadmap(text) {
   const counts = { open: 0, done: 0, parked: 0, next: null };
   for (const raw of phaseLines(text)) {
@@ -36652,34 +37354,34 @@ function countRoadmap(text) {
   return counts;
 }
 function checkpointFile(repoRoot, runId) {
-  return path95.join(repoRoot, CHECKPOINT_DIR_REL, `${runId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  return path100.join(repoRoot, CHECKPOINT_DIR_REL, `${runId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
 }
 function roadmapPath(repoRoot, slug) {
-  return path95.join(repoRoot, "agents", "roadmaps", `${slug}.md`);
+  return path100.join(repoRoot, "agents", "roadmaps", `${slug}.md`);
 }
 function readHead(repoRoot) {
   try {
-    let gitDir = path95.join(repoRoot, ".git");
-    if (fs92.statSync(gitDir).isFile()) {
-      const m = /^gitdir:\s*(.+)$/m.exec(fs92.readFileSync(gitDir, "utf-8").trim());
+    let gitDir = path100.join(repoRoot, ".git");
+    if (fs96.statSync(gitDir).isFile()) {
+      const m = /^gitdir:\s*(.+)$/m.exec(fs96.readFileSync(gitDir, "utf-8").trim());
       if (m === null) return null;
-      gitDir = path95.resolve(repoRoot, m[1]);
+      gitDir = path100.resolve(repoRoot, m[1]);
     }
     let refRoot = gitDir;
     try {
-      const common = fs92.readFileSync(path95.join(gitDir, "commondir"), "utf-8").trim();
-      if (common !== "") refRoot = path95.resolve(gitDir, common);
+      const common = fs96.readFileSync(path100.join(gitDir, "commondir"), "utf-8").trim();
+      if (common !== "") refRoot = path100.resolve(gitDir, common);
     } catch {
     }
-    const head = fs92.readFileSync(path95.join(gitDir, "HEAD"), "utf-8").trim();
+    const head = fs96.readFileSync(path100.join(gitDir, "HEAD"), "utf-8").trim();
     if (/^[0-9a-f]{40}$/.test(head)) return head;
     const ref = /^ref:\s*(.+)$/.exec(head);
     if (ref === null) return null;
     const refName = ref[1];
     try {
-      return fs92.readFileSync(path95.join(refRoot, refName), "utf-8").trim() || null;
+      return fs96.readFileSync(path100.join(refRoot, refName), "utf-8").trim() || null;
     } catch {
-      const packed = fs92.readFileSync(path95.join(refRoot, "packed-refs"), "utf-8");
+      const packed = fs96.readFileSync(path100.join(refRoot, "packed-refs"), "utf-8");
       for (const line of packed.split("\n")) {
         const pm = /^([0-9a-f]{40})\s+(.+)$/.exec(line.trim());
         if (pm !== null && pm[2] === refName) return pm[1];
@@ -36693,7 +37395,7 @@ function readHead(repoRoot) {
 function buildCheckpoint(repoRoot, runId, slug, opts = {}) {
   let text;
   try {
-    text = fs92.readFileSync(roadmapPath(repoRoot, slug), "utf-8");
+    text = fs96.readFileSync(roadmapPath(repoRoot, slug), "utf-8");
   } catch {
     return null;
   }
@@ -36717,8 +37419,8 @@ function buildCheckpoint(repoRoot, runId, slug, opts = {}) {
 function writeCheckpoint(repoRoot, cp) {
   const file = checkpointFile(repoRoot, cp.run_id);
   try {
-    fs92.mkdirSync(path95.dirname(file), { recursive: true });
-    fs92.writeFileSync(file, `${JSON.stringify(cp, null, 2)}
+    fs96.mkdirSync(path100.dirname(file), { recursive: true });
+    fs96.writeFileSync(file, `${JSON.stringify(cp, null, 2)}
 `, "utf-8");
     return file;
   } catch {
@@ -36727,7 +37429,7 @@ function writeCheckpoint(repoRoot, cp) {
 }
 
 // src/scripts/_lib/continuity_writer.ts
-import * as fs93 from "node:fs";
+import * as fs97 from "node:fs";
 var AUTO_RECORD_KEY = "continuity.auto_record";
 function auto_record_enabled(root) {
   try {
@@ -36825,7 +37527,7 @@ function buildContinuityRecord(input) {
   }
   let text;
   try {
-    text = fs93.readFileSync(roadmapPath(root, slug), "utf-8");
+    text = fs97.readFileSync(roadmapPath(root, slug), "utf-8");
   } catch {
     return { record: null, reason: `no record \u2014 the claimed roadmap ${slug} is not readable` };
   }
@@ -36864,12 +37566,12 @@ function buildContinuityRecord(input) {
 }
 
 // src/scripts/_lib/continuity_slot.ts
-import * as fs94 from "node:fs";
-import * as path96 from "node:path";
+import * as fs98 from "node:fs";
+import * as path101 from "node:path";
 var MAX_AGE_MS = RECYCLE_MAX_AGE_HOURS * 3600 * 1e3;
 function _parse2(file) {
   try {
-    const decoded = JSON.parse(fs94.readFileSync(file, "utf-8"));
+    const decoded = JSON.parse(fs98.readFileSync(file, "utf-8"));
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded;
     }
@@ -36886,14 +37588,14 @@ function _ageMs(record, now) {
   return now.getTime() - at;
 }
 function inspectSlot(workspace_root, session_id, now = /* @__PURE__ */ new Date()) {
-  const target = path96.join(workspace_root, recycle_envelope_rel(session_id));
-  if (!fs94.existsSync(target)) {
-    const consumed = path96.join(workspace_root, recycle_consumed_rel(session_id));
-    if (fs94.existsSync(consumed)) {
+  const target = path101.join(workspace_root, recycle_envelope_rel(session_id));
+  if (!fs98.existsSync(target)) {
+    const consumed = path101.join(workspace_root, recycle_consumed_rel(session_id));
+    if (fs98.existsSync(consumed)) {
       return { state: "consumed", reason: "the record for this session was consumed", target };
     }
-    const quarantined = path96.join(workspace_root, recycle_quarantine_rel(session_id));
-    if (fs94.existsSync(quarantined)) {
+    const quarantined = path101.join(workspace_root, recycle_quarantine_rel(session_id));
+    if (fs98.existsSync(quarantined)) {
       return {
         state: "quarantined",
         reason: "the slot is free; an unusable record sits in quarantine",
@@ -36953,7 +37655,7 @@ function publishContinuityRecord(workspace_root, session_id, record, now = /* @_
       reason: `refused \u2014 ${bytes} bytes exceeds the ${RECYCLE_ENVELOPE_MAX_BYTES} byte slot cap`
     };
   }
-  const target = path96.join(workspace_root, recycle_envelope_rel(session_id));
+  const target = path101.join(workspace_root, recycle_envelope_rel(session_id));
   const before = inspectSlot(workspace_root, session_id, now);
   if (before.state === "conflicting") {
     return { state: "conflicting", wrote: false, reason: `refused \u2014 ${before.reason}` };
@@ -36970,11 +37672,11 @@ function publishContinuityRecord(workspace_root, session_id, record, now = /* @_
     }
   }
   let quarantined;
-  if (before.state === "quarantined" && fs94.existsSync(target)) {
-    const dest = path96.join(workspace_root, recycle_quarantine_rel(session_id));
+  if (before.state === "quarantined" && fs98.existsSync(target)) {
+    const dest = path101.join(workspace_root, recycle_quarantine_rel(session_id));
     try {
-      fs94.mkdirSync(path96.dirname(dest), { recursive: true });
-      fs94.renameSync(target, dest);
+      fs98.mkdirSync(path101.dirname(dest), { recursive: true });
+      fs98.renameSync(target, dest);
       quarantined = dest;
     } catch (exc) {
       return {
@@ -37003,7 +37705,7 @@ function publishContinuityRecord(workspace_root, session_id, record, now = /* @_
 
 // src/scripts/hooks/session_eol_hook.ts
 var THRESHOLD_OVERRIDE_ENV = "AGENT_RECYCLE_THRESHOLD_TOKENS";
-var CONTEXT_FILL_REL = path97.join("agents", "runtime", "state", "context-fill.json");
+var CONTEXT_FILL_REL = path102.join("agents", "runtime", "state", "context-fill.json");
 function str12(value) {
   return typeof value === "string" ? value : "";
 }
@@ -37018,7 +37720,7 @@ function payloadSessionId(payload, envelope) {
 }
 function readState4(file) {
   try {
-    const parsed = JSON.parse(fs95.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs99.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,
@@ -37049,7 +37751,7 @@ function readThresholdTokens() {
 }
 function writeContextFill(workspaceRoot3, tokens, threshold, ts) {
   try {
-    atomic_write_json(path97.join(workspaceRoot3, CONTEXT_FILL_REL), {
+    atomic_write_json(path102.join(workspaceRoot3, CONTEXT_FILL_REL), {
       schema_version: 1,
       final_context_tokens: tokens,
       recycle_threshold_tokens: threshold,
@@ -37059,7 +37761,7 @@ function writeContextFill(workspaceRoot3, tokens, threshold, ts) {
   } catch {
   }
 }
-function main61() {
+function main63() {
   const [envelope, payload] = unwrap(readHookStdin(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
@@ -37142,38 +37844,38 @@ function writeContinuityRecord(workspaceRoot3, rawSessionId, counters, threshold
   } catch {
   }
 }
-function _isCliEntry44() {
+function _isCliEntry46() {
   if (true) {
     return false;
   }
   if (process16.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL54(path97.resolve(process16.argv[1])).href;
+  const argvUrl = pathToFileURL56(path102.resolve(process16.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs95.realpathSync(fileURLToPath63(import.meta.url));
-    const argv = fs95.realpathSync(path97.resolve(process16.argv[1]));
+    const here = fs99.realpathSync(fileURLToPath66(import.meta.url));
+    const argv = fs99.realpathSync(path102.resolve(process16.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry44()) {
-  process16.exit(main61());
+if (_isCliEntry46()) {
+  process16.exit(main63());
 }
 
 // src/scripts/hooks/tool_result_bytes_hook.ts
-import * as fs96 from "node:fs";
-import * as path98 from "node:path";
-import { fileURLToPath as fileURLToPath64, pathToFileURL as pathToFileURL55 } from "node:url";
+import * as fs100 from "node:fs";
+import * as path103 from "node:path";
+import { fileURLToPath as fileURLToPath67, pathToFileURL as pathToFileURL57 } from "node:url";
 var EXIT_ALLOW31 = 0;
 function isObject17(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var CENSUS_FILE = path98.join("agents", "runtime", "state", "tool-result-census.jsonl");
+var CENSUS_FILE = path103.join("agents", "runtime", "state", "tool-result-census.jsonl");
 var RESULT_KEYS = ["tool_response", "toolResponse", "tool_result", "toolUseResult"];
 function _resultBytes(payload) {
   for (const key of RESULT_KEYS) {
@@ -37208,13 +37910,13 @@ function unwrapPayload4(envelope) {
   return isObject17(inner) ? inner : envelope;
 }
 function censusFile(consumerRoot) {
-  return path98.join(consumerRoot, CENSUS_FILE);
+  return path103.join(consumerRoot, CENSUS_FILE);
 }
 function _appendCensusLine(consumerRoot, line) {
   if (is_replay_mode()) return;
   const file = censusFile(consumerRoot);
-  fs96.mkdirSync(path98.dirname(file), { recursive: true });
-  fs96.appendFileSync(file, `${JSON.stringify(line)}
+  fs100.mkdirSync(path103.dirname(file), { recursive: true });
+  fs100.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 function processEnvelope4(envelope, consumerRoot) {
@@ -37245,7 +37947,7 @@ function resolveConsumerRoot2(envelope) {
   }
   return process.cwd();
 }
-function main62() {
+function main64() {
   const raw = readHookStdin();
   let envelope = {};
   try {
@@ -37255,25 +37957,25 @@ function main62() {
   }
   return processEnvelope4(envelope, resolveConsumerRoot2(envelope));
 }
-function _isCliEntry45() {
+function _isCliEntry47() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL55(path98.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL57(path103.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs96.realpathSync(fileURLToPath64(import.meta.url)) === fs96.realpathSync(path98.resolve(process.argv[1]));
+    return fs100.realpathSync(fileURLToPath67(import.meta.url)) === fs100.realpathSync(path103.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry45()) process.exit(main62());
+if (_isCliEntry47()) process.exit(main64());
 
 // src/scripts/hooks/spawn_guard_shadow_hook.ts
-import * as fs97 from "node:fs";
-import * as path99 from "node:path";
-import { fileURLToPath as fileURLToPath65, pathToFileURL as pathToFileURL56 } from "node:url";
+import * as fs101 from "node:fs";
+import * as path104 from "node:path";
+import { fileURLToPath as fileURLToPath68, pathToFileURL as pathToFileURL58 } from "node:url";
 var EXIT_ALLOW32 = 0;
 function isObject18(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -37337,7 +38039,7 @@ function processEnvelope5(envelope, consumerRoot) {
   }
   return EXIT_ALLOW32;
 }
-function main63() {
+function main65() {
   const raw = readHookStdin();
   let envelope = {};
   try {
@@ -37347,27 +38049,27 @@ function main63() {
   }
   return processEnvelope5(envelope, resolveConsumerRoot(envelope));
 }
-function _isCliEntry46() {
+function _isCliEntry48() {
   if (true) return false;
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL56(path99.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL58(path104.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs97.realpathSync(fileURLToPath65(import.meta.url)) === fs97.realpathSync(path99.resolve(process.argv[1]));
+    return fs101.realpathSync(fileURLToPath68(import.meta.url)) === fs101.realpathSync(path104.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry46()) process.exit(main63());
+if (_isCliEntry48()) process.exit(main65());
 
 // src/scripts/hooks/source_first_gate_hook.ts
-import * as fs98 from "node:fs";
-import * as path100 from "node:path";
-import { fileURLToPath as fileURLToPath66, pathToFileURL as pathToFileURL57 } from "node:url";
+import * as fs102 from "node:fs";
+import * as path105 from "node:path";
+import { fileURLToPath as fileURLToPath69, pathToFileURL as pathToFileURL59 } from "node:url";
 var EXIT_ALLOW33 = 0;
 var MAX_SHADOW_WARNS = 2;
-var SHADOW_LOG = path100.join("agents", "runtime", "state", "source-first-gate.jsonl");
-var STATE_FILE9 = path100.join("agents", "runtime", "state", "source-first-gate.json");
+var SHADOW_LOG = path105.join("agents", "runtime", "state", "source-first-gate.jsonl");
+var STATE_FILE9 = path105.join("agents", "runtime", "state", "source-first-gate.json");
 function isObject19(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -37441,7 +38143,7 @@ var EMPTY_STATE = { handoverSeen: false, sourceRead: false, wouldWarn: 0 };
 var MAX_SESSIONS2 = 50;
 function readState5(root, session) {
   try {
-    const all = JSON.parse(fs98.readFileSync(path100.join(root, STATE_FILE9), "utf-8"));
+    const all = JSON.parse(fs102.readFileSync(path105.join(root, STATE_FILE9), "utf-8"));
     const entry = all[session];
     if (entry && typeof entry.handoverSeen === "boolean" && typeof entry.sourceRead === "boolean" && typeof entry.wouldWarn === "number") {
       return entry;
@@ -37453,10 +38155,10 @@ function readState5(root, session) {
 function writeState4(root, session, state) {
   if (is_replay_mode()) return;
   try {
-    const file = path100.join(root, STATE_FILE9);
+    const file = path105.join(root, STATE_FILE9);
     let all = {};
     try {
-      all = JSON.parse(fs98.readFileSync(file, "utf-8"));
+      all = JSON.parse(fs102.readFileSync(file, "utf-8"));
     } catch {
     }
     if (!isObject19(all)) all = {};
@@ -37467,8 +38169,8 @@ function writeState4(root, session, state) {
       for (const key of keys.slice(keys.length - MAX_SESSIONS2)) pruned[key] = all[key];
       all = pruned;
     }
-    fs98.mkdirSync(path100.dirname(file), { recursive: true });
-    fs98.writeFileSync(file, JSON.stringify(all));
+    fs102.mkdirSync(path105.dirname(file), { recursive: true });
+    fs102.writeFileSync(file, JSON.stringify(all));
   } catch {
   }
 }
@@ -37489,7 +38191,7 @@ function evaluateCandidates2(handoverSeen, handoverOnDisk, sourceRead) {
 }
 function handoverPresentOnDisk(root) {
   try {
-    return fs98.statSync(path100.join(root, ".claude", "design-system")).isDirectory();
+    return fs102.statSync(path105.join(root, ".claude", "design-system")).isDirectory();
   } catch {
     return false;
   }
@@ -37497,9 +38199,9 @@ function handoverPresentOnDisk(root) {
 function appendShadowLine(root, line) {
   if (is_replay_mode()) return;
   try {
-    const file = path100.join(root, SHADOW_LOG);
-    fs98.mkdirSync(path100.dirname(file), { recursive: true });
-    fs98.appendFileSync(file, `${JSON.stringify(line)}
+    const file = path105.join(root, SHADOW_LOG);
+    fs102.mkdirSync(path105.dirname(file), { recursive: true });
+    fs102.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
@@ -37560,7 +38262,7 @@ function processEnvelope6(envelope, consumerRoot, session) {
   }
   return EXIT_ALLOW33;
 }
-function main64() {
+function main66() {
   const raw = readHookStdin();
   let envelope = {};
   try {
@@ -37572,26 +38274,26 @@ function main64() {
   const session = typeof sessionVal === "string" && sessionVal ? sessionVal : "unknown";
   return processEnvelope6(envelope, resolveConsumerRoot(envelope), session);
 }
-function _isCliEntry47() {
+function _isCliEntry49() {
   if (true) return false;
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL57(path100.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL59(path105.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs98.realpathSync(fileURLToPath66(import.meta.url)) === fs98.realpathSync(path100.resolve(process.argv[1]));
+    return fs102.realpathSync(fileURLToPath69(import.meta.url)) === fs102.realpathSync(path105.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry47()) process.exit(main64());
+if (_isCliEntry49()) process.exit(main66());
 
 // src/scripts/hooks/interruption_ledger_hook.ts
-import * as fs99 from "node:fs";
-import * as path101 from "node:path";
-import { fileURLToPath as fileURLToPath67, pathToFileURL as pathToFileURL58 } from "node:url";
-var EXIT_OK2 = 0;
+import * as fs103 from "node:fs";
+import * as path106 from "node:path";
+import { fileURLToPath as fileURLToPath70, pathToFileURL as pathToFileURL60 } from "node:url";
+var EXIT_OK3 = 0;
 var TRANSCRIPT_READ_MAX_BYTES2 = 2 * 1024 * 1024;
-var LEDGER_RELPATH = path101.join("agents", "runtime", "state", "interruptions.jsonl");
+var LEDGER_RELPATH = path106.join("agents", "runtime", "state", "interruptions.jsonl");
 function hasNumberedOptions(reply) {
   let count = 0;
   for (const line of reply.split("\n")) {
@@ -37615,14 +38317,14 @@ function classifyReply(reply) {
 function readClaimedRoadmap(workspaceRoot3, sessionId3) {
   if (!sessionId3) return null;
   try {
-    const file = path101.join(
+    const file = path106.join(
       workspaceRoot3,
       "agents",
       "runtime",
       "state",
       `roadmap-claim-${sessionId3}.json`
     );
-    const parsed = JSON.parse(fs99.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs103.readFileSync(file, "utf8"));
     if (parsed === null || typeof parsed !== "object") return null;
     const slug = parsed["slug"];
     return typeof slug === "string" && slug.length > 0 ? slug : null;
@@ -37633,7 +38335,7 @@ function readClaimedRoadmap(workspaceRoot3, sessionId3) {
 function alreadyRecorded(ledgerPath, runId, turn) {
   let raw;
   try {
-    raw = fs99.readFileSync(ledgerPath, "utf8");
+    raw = fs103.readFileSync(ledgerPath, "utf8");
   } catch {
     return false;
   }
@@ -37652,19 +38354,19 @@ function alreadyRecorded(ledgerPath, runId, turn) {
 function str14(v) {
   return typeof v === "string" ? v : "";
 }
-function main65() {
+function main67() {
   let envelope;
   let payload;
   try {
     [envelope, payload] = unwrap(readHookStdin(), "claude");
   } catch {
-    return EXIT_OK2;
+    return EXIT_OK3;
   }
   const workspaceRoot3 = str14(envelope["workspace_root"]) || process.cwd();
   const transcriptPath = str14(
     payload["transcript_path"] ?? payload["transcriptPath"]
   );
-  if (!transcriptPath) return EXIT_OK2;
+  if (!transcriptPath) return EXIT_OK3;
   let lastAssistant = "";
   let turnOrdinal = 0;
   try {
@@ -37672,13 +38374,13 @@ function main65() {
     lastAssistant = tail.lastAssistant;
     turnOrdinal = tail.turnOrdinal;
   } catch {
-    return EXIT_OK2;
+    return EXIT_OK3;
   }
-  if (!lastAssistant) return EXIT_OK2;
+  if (!lastAssistant) return EXIT_OK3;
   const sessionId3 = str14(payload["session_id"]) || str14(envelope["session_id"]);
   const runId = sessionId3 ? derive_session_tag(sessionId3) : "unknown";
-  const ledgerPath = path101.join(workspaceRoot3, LEDGER_RELPATH);
-  if (alreadyRecorded(ledgerPath, runId, turnOrdinal)) return EXIT_OK2;
+  const ledgerPath = path106.join(workspaceRoot3, LEDGER_RELPATH);
+  if (alreadyRecorded(ledgerPath, runId, turnOrdinal)) return EXIT_OK3;
   const verdict2 = classifyReply(lastAssistant);
   const record = {
     run_id: runId,
@@ -37689,43 +38391,43 @@ function main65() {
     at: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs99.mkdirSync(path101.dirname(ledgerPath), { recursive: true });
-    fs99.appendFileSync(ledgerPath, `${JSON.stringify(record)}
+    fs103.mkdirSync(path106.dirname(ledgerPath), { recursive: true });
+    fs103.appendFileSync(ledgerPath, `${JSON.stringify(record)}
 `, "utf8");
   } catch {
   }
-  return EXIT_OK2;
+  return EXIT_OK3;
 }
-function _isCliEntry48() {
+function _isCliEntry50() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL58(path101.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL60(path106.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs99.realpathSync(fileURLToPath67(import.meta.url));
-    const argv = fs99.realpathSync(path101.resolve(process.argv[1]));
+    const here = fs103.realpathSync(fileURLToPath70(import.meta.url));
+    const argv = fs103.realpathSync(path106.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry48()) {
-  process.exit(main65());
+if (_isCliEntry50()) {
+  process.exit(main67());
 }
 
 // src/scripts/hooks/run_continuation_hook.ts
-import * as fs101 from "node:fs";
+import * as fs105 from "node:fs";
 
 // src/scripts/_lib/billing_grant.ts
-import * as fs100 from "node:fs";
-import * as path102 from "node:path";
-var BILLING_GRANT_DIR_REL = path102.join("agents", "runtime", "billing-grants");
+import * as fs104 from "node:fs";
+import * as path107 from "node:path";
+var BILLING_GRANT_DIR_REL = path107.join("agents", "runtime", "billing-grants");
 var BILLING_GRANT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function grantFile(repoRoot, runId) {
-  return path102.join(
+  return path107.join(
     repoRoot,
     BILLING_GRANT_DIR_REL,
     `${runId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`
@@ -37733,14 +38435,14 @@ function grantFile(repoRoot, runId) {
 }
 function revokeBillingGrant(repoRoot, runId) {
   try {
-    fs100.unlinkSync(grantFile(repoRoot, runId));
+    fs104.unlinkSync(grantFile(repoRoot, runId));
   } catch {
   }
 }
 
 // src/scripts/hooks/run_continuation_hook.ts
-import * as path103 from "node:path";
-import { fileURLToPath as fileURLToPath68, pathToFileURL as pathToFileURL59 } from "node:url";
+import * as path108 from "node:path";
+import { fileURLToPath as fileURLToPath71, pathToFileURL as pathToFileURL61 } from "node:url";
 
 // src/scripts/_lib/outcome_vocabularies.ts
 var RUN_TERMINAL_STATES = [
@@ -37830,13 +38532,13 @@ var EXIT_ALLOW34 = 0;
 var EXIT_BLOCK4 = 1;
 var BLOCKED_BY_MARKER = /<!--\s*blocked-by:\s*\S[^>]*-->/;
 var LEDGER_TAIL_MAX_BYTES = 512 * 1024;
-var EVENTS_RELPATH = path103.join(
+var EVENTS_RELPATH = path108.join(
   "agents",
   "runtime",
   "state",
   "run-continuation.jsonl"
 );
-var STATE_DIR_REL = path103.join("agents", "runtime", "state");
+var STATE_DIR_REL = path108.join("agents", "runtime", "state");
 var ABSENT_CONFIRM_FIRES = 2;
 var DUPLICATE_WINDOW_MS = 60 * 1e3;
 function isDuplicateFire(state, turnOrdinal, openCount, nowMs, roadmapSource) {
@@ -37908,20 +38610,20 @@ function extractVerify(stepText) {
 function stateRelPath(runId, slug) {
   const safeRun = runId.replace(/[^A-Za-z0-9_-]/g, "_");
   const safeSlug = slug.replace(/[^A-Za-z0-9_-]/g, "_");
-  return path103.join(STATE_DIR_REL, `run-continuation-${safeRun}-${safeSlug}.json`);
+  return path108.join(STATE_DIR_REL, `run-continuation-${safeRun}-${safeSlug}.json`);
 }
 function legacyStateRelPath(runId) {
   const safe = runId.replace(/[^A-Za-z0-9_-]/g, "_");
-  return path103.join(STATE_DIR_REL, `run-continuation-${safe}.json`);
+  return path108.join(STATE_DIR_REL, `run-continuation-${safe}.json`);
 }
 function readRunState(workspaceRoot3, runId, slug) {
-  const keyedFile = path103.join(workspaceRoot3, stateRelPath(runId, slug));
+  const keyedFile = path108.join(workspaceRoot3, stateRelPath(runId, slug));
   const keyed = readState6(keyedFile);
   if (keyed !== null) return { state: keyed, from: "keyed", keyedFile };
   if (fileExists(keyedFile)) {
     return { state: null, from: "keyed", keyedFile };
   }
-  const legacy = readState6(path103.join(workspaceRoot3, legacyStateRelPath(runId)));
+  const legacy = readState6(path108.join(workspaceRoot3, legacyStateRelPath(runId)));
   if (legacy === null) return { state: null, from: "none", keyedFile };
   if (legacy.roadmap !== void 0 && legacy.roadmap !== slug) {
     return { state: null, from: "none", keyedFile };
@@ -37934,25 +38636,25 @@ function writeState5(file, state) {
 function clearRunState(workspaceRoot3, runId, keyedFile, adoptedLegacy) {
   revokeBillingGrant(workspaceRoot3, runId);
   try {
-    fs101.rmSync(keyedFile, { force: true });
+    fs105.rmSync(keyedFile, { force: true });
   } catch {
   }
   if (!adoptedLegacy) return;
   try {
-    fs101.rmSync(path103.join(workspaceRoot3, legacyStateRelPath(runId)), { force: true });
+    fs105.rmSync(path108.join(workspaceRoot3, legacyStateRelPath(runId)), { force: true });
   } catch {
   }
 }
 function fileExists(p) {
   try {
-    return fs101.statSync(p).isFile();
+    return fs105.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function readState6(file) {
   try {
-    const parsed = JSON.parse(fs101.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs105.readFileSync(file, "utf8"));
     if (parsed === null || typeof parsed !== "object") return null;
     const o = parsed;
     if (typeof o["started_at"] !== "string") return null;
@@ -37993,16 +38695,16 @@ function readState6(file) {
   }
 }
 function normalizeDir(p) {
-  const abs = path103.resolve(p);
+  const abs = path108.resolve(p);
   try {
-    return fs101.realpathSync(abs);
+    return fs105.realpathSync(abs);
   } catch {
     return abs;
   }
 }
 function normalizeFile(p) {
-  const abs = path103.resolve(p);
-  return path103.join(normalizeDir(path103.dirname(abs)), path103.basename(abs));
+  const abs = path108.resolve(p);
+  return path108.join(normalizeDir(path108.dirname(abs)), path108.basename(abs));
 }
 function provenance(workspaceRoot3, claimPath, sessionRoot, sessionCwd) {
   const reader = normalizeDir(workspaceRoot3);
@@ -38029,36 +38731,36 @@ function provenance(workspaceRoot3, claimPath, sessionRoot, sessionCwd) {
   };
 }
 function resolveRoadmap(sessionRoot, workspaceRoot3, slug) {
-  const dirRel = path103.join("agents", "roadmaps");
+  const dirRel = path108.join("agents", "roadmaps");
   const stem = slug.trim().replace(/\.md$/, "");
-  const rel = path103.join(dirRel, `${stem}.md`);
-  const norm = path103.normalize(rel);
-  if (path103.dirname(norm) !== dirRel) return null;
-  if (sessionRoot !== workspaceRoot3 && isDirectory(path103.join(sessionRoot, dirRel))) {
-    return path103.join(sessionRoot, norm);
+  const rel = path108.join(dirRel, `${stem}.md`);
+  const norm = path108.normalize(rel);
+  if (path108.dirname(norm) !== dirRel) return null;
+  if (sessionRoot !== workspaceRoot3 && isDirectory(path108.join(sessionRoot, dirRel))) {
+    return path108.join(sessionRoot, norm);
   }
-  return path103.join(normalizeDir(workspaceRoot3), norm);
+  return path108.join(normalizeDir(workspaceRoot3), norm);
 }
 function isDirectory(p) {
   try {
-    return fs101.statSync(p).isDirectory();
+    return fs105.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function eventAlreadyLogged(workspaceRoot3, runId, slug, event) {
   try {
-    const file = path103.join(workspaceRoot3, EVENTS_RELPATH);
-    const size = fs101.statSync(file).size;
+    const file = path108.join(workspaceRoot3, EVENTS_RELPATH);
+    const size = fs105.statSync(file).size;
     const start = Math.max(0, size - LEDGER_TAIL_MAX_BYTES);
-    const fd = fs101.openSync(file, "r");
+    const fd = fs105.openSync(file, "r");
     let text;
     try {
       const buf = Buffer.alloc(size - start);
-      const read = fs101.readSync(fd, buf, 0, buf.length, start);
+      const read = fs105.readSync(fd, buf, 0, buf.length, start);
       text = buf.subarray(0, read).toString("utf8");
     } finally {
-      fs101.closeSync(fd);
+      fs105.closeSync(fd);
     }
     for (const line of text.split("\n")) {
       if (line === "") continue;
@@ -38081,9 +38783,9 @@ function eventAlreadyLogged(workspaceRoot3, runId, slug, event) {
 }
 function appendEvent2(workspaceRoot3, record) {
   try {
-    const file = path103.join(workspaceRoot3, EVENTS_RELPATH);
-    fs101.mkdirSync(path103.dirname(file), { recursive: true });
-    fs101.appendFileSync(file, `${JSON.stringify(record)}
+    const file = path108.join(workspaceRoot3, EVENTS_RELPATH);
+    fs105.mkdirSync(path108.dirname(file), { recursive: true });
+    fs105.appendFileSync(file, `${JSON.stringify(record)}
 `, "utf8");
   } catch {
   }
@@ -38091,7 +38793,7 @@ function appendEvent2(workspaceRoot3, record) {
 function refusedThisTurn(workspaceRoot3, sessionId3, turnOrdinal) {
   try {
     const file = sessionRefusalFile(workspaceRoot3, deriveSessionKey(sessionId3 || "unknown-session"));
-    const rec = parseRecord(fs101.readFileSync(file, "utf-8"));
+    const rec = parseRecord(fs105.readFileSync(file, "utf-8"));
     return rec !== null && rec.refused_turn === turnOrdinal;
   } catch {
     return false;
@@ -38100,7 +38802,7 @@ function refusedThisTurn(workspaceRoot3, sessionId3, turnOrdinal) {
 function str15(v) {
   return typeof v === "string" ? v : "";
 }
-function main66() {
+function main68() {
   if (is_replay_mode()) return EXIT_ALLOW34;
   if (process.env["AGENT_CONFIG_NO_RUN_CONTINUATION"] === "1") return EXIT_ALLOW34;
   let envelope;
@@ -38125,7 +38827,7 @@ function main66() {
   let roadmapText = null;
   if (roadmapPath2 !== null) {
     try {
-      roadmapText = fs101.readFileSync(roadmapPath2, "utf8");
+      roadmapText = fs105.readFileSync(roadmapPath2, "utf8");
       roadmapFile = roadmapPath2;
     } catch {
       roadmapText = null;
@@ -38174,7 +38876,7 @@ function main66() {
   );
   if (!transcriptPath) return EXIT_ALLOW34;
   try {
-    if (fs101.statSync(transcriptPath).size > TRANSCRIPT_READ_MAX_BYTES) {
+    if (fs105.statSync(transcriptPath).size > TRANSCRIPT_READ_MAX_BYTES) {
       const inert = readRunState(workspaceRoot3, runId, slug);
       if (inert.state !== null && inert.state.inert_reported !== true) {
         const inertRoots = provenance(
@@ -38328,29 +39030,29 @@ ${stepLine}
 Continue with this step now: do the work, run its verify line, flip the box, then end the turn. Escalate instead of continuing ONLY for a locked decision class (high_impact / user_required) or a halt your contract names.
 `;
 }
-function _isCliEntry49() {
+function _isCliEntry51() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL59(path103.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL61(path108.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    const here = fs101.realpathSync(fileURLToPath68(import.meta.url));
-    const argv = fs101.realpathSync(path103.resolve(process.argv[1]));
+    const here = fs105.realpathSync(fileURLToPath71(import.meta.url));
+    const argv = fs105.realpathSync(path108.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry49()) {
-  process.exit(main66());
+if (_isCliEntry51()) {
+  process.exit(main68());
 }
 
 // src/scripts/hooks/journal_record_hook.ts
-import * as fs103 from "node:fs";
-import * as path105 from "node:path";
-import { fileURLToPath as fileURLToPath69, pathToFileURL as pathToFileURL60 } from "node:url";
+import * as fs107 from "node:fs";
+import * as path110 from "node:path";
+import { fileURLToPath as fileURLToPath72, pathToFileURL as pathToFileURL62 } from "node:url";
 
 // src/scripts/_lib/surface.ts
 var SURFACES = ["ide", "cli", "cloud", "unknown"];
@@ -38380,8 +39082,8 @@ function readSurface(v) {
 
 // src/scripts/_lib/runtime_journal.ts
 import * as crypto14 from "node:crypto";
-import * as fs102 from "node:fs";
-import * as path104 from "node:path";
+import * as fs106 from "node:fs";
+import * as path109 from "node:path";
 
 // src/scripts/_lib/sqlite_schema.ts
 function addColumnIfMissing(db, table, column, decl) {
@@ -38483,7 +39185,7 @@ function requireId(name, id, optional) {
 }
 var JOURNAL_DIR_NAME = "agent-journal";
 var JOURNAL_FILE_NAME = "journal.sqlite";
-var JOURNAL_FALLBACK_REL = path104.join("agents", "runtime", "state", JOURNAL_FILE_NAME);
+var JOURNAL_FALLBACK_REL = path109.join("agents", "runtime", "state", JOURNAL_FILE_NAME);
 function digest(domain, input) {
   return crypto14.createHash("sha256").update(`${domain}\0${input}`).digest("hex").slice(0, 12);
 }
@@ -38494,20 +39196,20 @@ function resolveJournal(root) {
   if (common !== null) {
     const own = git_dir(root) ?? common;
     return {
-      path: path104.join(common, JOURNAL_DIR_NAME, JOURNAL_FILE_NAME),
+      path: path109.join(common, JOURNAL_DIR_NAME, JOURNAL_FILE_NAME),
       scope: "repo-shared",
       reason: "common git dir resolved \u2014 every worktree of this repo writes one database",
       repository_id: digest(REPO_DOMAIN, common),
       worktree_id: digest(WORKTREE_DOMAIN, own)
     };
   }
-  let real = path104.resolve(root);
+  let real = path109.resolve(root);
   try {
-    real = fs102.realpathSync(real);
+    real = fs106.realpathSync(real);
   } catch {
   }
   return {
-    path: path104.join(real, JOURNAL_FALLBACK_REL),
+    path: path109.join(real, JOURNAL_FALLBACK_REL),
     scope: "worktree-local",
     reason: "no common git dir \u2014 not inside a git repository; falling back to the tree-local path",
     repository_id: digest(REPO_DOMAIN, real),
@@ -38595,7 +39297,7 @@ function ensureWal(db) {
 function discard(dbPath) {
   for (const p of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
     try {
-      fs102.rmSync(p, { force: true });
+      fs106.rmSync(p, { force: true });
     } catch {
     }
   }
@@ -38607,9 +39309,9 @@ function openJournal(root) {
     );
   }
   const location = resolveJournal(root);
-  fs102.mkdirSync(path104.dirname(location.path), { recursive: true });
+  fs106.mkdirSync(path109.dirname(location.path), { recursive: true });
   const { DatabaseSync } = loadSqliteSync("runtime_journal");
-  if (fs102.existsSync(location.path)) {
+  if (fs106.existsSync(location.path)) {
     let drift = false;
     let probe = null;
     try {
@@ -38848,7 +39550,7 @@ function processEnvelope7(envelope, consumerRoot) {
   }
   return EXIT_ALLOW35;
 }
-function main67() {
+function main69() {
   const raw = readHookStdin();
   let envelope = {};
   try {
@@ -38858,20 +39560,20 @@ function main67() {
   }
   return processEnvelope7(envelope, resolveConsumerRoot3(envelope));
 }
-function _isCliEntry50() {
+function _isCliEntry52() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL60(path105.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL62(path110.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs103.realpathSync(fileURLToPath69(import.meta.url)) === fs103.realpathSync(path105.resolve(process.argv[1]));
+    return fs107.realpathSync(fileURLToPath72(import.meta.url)) === fs107.realpathSync(path110.resolve(process.argv[1]));
   } catch {
     return false;
   }
 }
-if (_isCliEntry50()) process.exit(main67());
+if (_isCliEntry52()) process.exit(main69());
 
 // src/scripts/hooks/concern_registry.ts
 var CONCERN_REGISTRY = {
@@ -38920,22 +39622,23 @@ var CONCERN_REGISTRY = {
   "src/scripts/hooks/skill_route_hook.ts": main52,
   "src/scripts/hooks/rule_inject_hook.ts": main53,
   "src/scripts/hooks/end_review_nudge_hook.ts": main54,
-  "src/scripts/hooks/turn_end_gate_hook.ts": main56,
-  "src/scripts/hooks/edit_shape_hook.ts": main57,
-  "src/scripts/hooks/comment_discipline_hook.ts": main59,
-  "src/scripts/hooks/reread_guard_hook.ts": main60,
-  "src/scripts/hooks/session_eol_hook.ts": main61,
-  "src/scripts/hooks/subagent_ledger_hook.ts": main55,
-  "src/scripts/hooks/tool_result_bytes_hook.ts": main62,
-  "src/scripts/hooks/spawn_guard_shadow_hook.ts": main63,
-  "src/scripts/hooks/source_first_gate_hook.ts": main64,
-  "src/scripts/hooks/interruption_ledger_hook.ts": main65,
-  "src/scripts/hooks/run_continuation_hook.ts": main66,
-  "src/scripts/hooks/journal_record_hook.ts": main67
+  "src/scripts/hooks/review_baseline_hook.ts": main55,
+  "src/scripts/hooks/turn_end_gate_hook.ts": main58,
+  "src/scripts/hooks/edit_shape_hook.ts": main59,
+  "src/scripts/hooks/comment_discipline_hook.ts": main61,
+  "src/scripts/hooks/reread_guard_hook.ts": main62,
+  "src/scripts/hooks/session_eol_hook.ts": main63,
+  "src/scripts/hooks/subagent_ledger_hook.ts": main57,
+  "src/scripts/hooks/tool_result_bytes_hook.ts": main64,
+  "src/scripts/hooks/spawn_guard_shadow_hook.ts": main65,
+  "src/scripts/hooks/source_first_gate_hook.ts": main66,
+  "src/scripts/hooks/interruption_ledger_hook.ts": main67,
+  "src/scripts/hooks/run_continuation_hook.ts": main68,
+  "src/scripts/hooks/journal_record_hook.ts": main69
 };
 
 // src/scripts/hooks/category_a.ts
-import * as path106 from "node:path";
+import * as path111 from "node:path";
 var READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
   "Read",
   "Glob",
@@ -39114,10 +39817,10 @@ var SCRIPT_TAKING_SUBCOMMANDS = /* @__PURE__ */ new Set([
 ]);
 function isInsideWorkingTree(candidate, root) {
   if (!candidate.trim() || !root.trim()) return false;
-  const abs = path106.resolve(root, candidate);
-  const rel = path106.relative(path106.resolve(root), abs);
+  const abs = path111.resolve(root, candidate);
+  const rel = path111.relative(path111.resolve(root), abs);
   if (rel === "") return true;
-  return !rel.startsWith("..") && !path106.isAbsolute(rel);
+  return !rel.startsWith("..") && !path111.isAbsolute(rel);
 }
 function _argv(command) {
   return command.trim().split(/\s+/).filter((t) => t.length > 0);
@@ -39145,7 +39848,7 @@ function _gitSubcommand(argv) {
     if (!_isFlag(token)) return token;
     const [flag, inlineValue] = token.includes("=") ? [token.slice(0, token.indexOf("=")), token.slice(token.indexOf("=") + 1)] : [token, null];
     const value = inlineValue ?? (GIT_VALUE_FLAGS.has(flag) ? argv[++i] : void 0);
-    if (value !== void 0 && (path106.isAbsolute(value) || value.split("/").includes(".."))) {
+    if (value !== void 0 && (path111.isAbsolute(value) || value.split("/").includes(".."))) {
       return "";
     }
   }
@@ -39348,8 +40051,8 @@ function _py_json_dumps2(value, indent) {
 
 // src/scripts/_lib/collector_denominator.ts
 import crypto15 from "node:crypto";
-import fs105 from "node:fs";
-import path108 from "node:path";
+import fs109 from "node:fs";
+import path113 from "node:path";
 
 // src/scripts/_lib/collector_record.ts
 var COLLECTOR_EVENTS = [
@@ -39426,30 +40129,30 @@ var FIELD_PURPOSE = {
 var ALLOWED_FIELDS = new Set(Object.keys(FIELD_PURPOSE));
 
 // src/scripts/_lib/collector_store.ts
-import * as fs104 from "node:fs";
+import * as fs108 from "node:fs";
 import * as os13 from "node:os";
-import * as path107 from "node:path";
+import * as path112 from "node:path";
 var COLLECTOR_DIR_NAME = "agent-collector";
 var COLLECTOR_FILE_NAME = "collector.sqlite";
 var OPT_OUT_MARKER_NAME = "OPT-OUT";
 var MIGRATION_MARKER_NAME = "MIGRATION-IN-FLIGHT";
 var QUARANTINE_DIR_NAME = "quarantine";
 function defaultUserRoot() {
-  return path107.join(os13.homedir(), ".event4u", "agent-config");
+  return path112.join(os13.homedir(), ".event4u", "agent-config");
 }
 function resolveCollectorStore(userRoot = defaultUserRoot()) {
-  const dir = path107.join(userRoot, COLLECTOR_DIR_NAME);
+  const dir = path112.join(userRoot, COLLECTOR_DIR_NAME);
   return {
     userRoot,
     root: dir,
-    path: path107.join(dir, COLLECTOR_FILE_NAME),
-    optOutMarker: path107.join(dir, OPT_OUT_MARKER_NAME),
-    migrationMarker: path107.join(dir, MIGRATION_MARKER_NAME),
-    quarantineDir: path107.join(dir, QUARANTINE_DIR_NAME)
+    path: path112.join(dir, COLLECTOR_FILE_NAME),
+    optOutMarker: path112.join(dir, OPT_OUT_MARKER_NAME),
+    migrationMarker: path112.join(dir, MIGRATION_MARKER_NAME),
+    quarantineDir: path112.join(dir, QUARANTINE_DIR_NAME)
   };
 }
 function isOptedOut(userRoot = defaultUserRoot()) {
-  return fs104.existsSync(resolveCollectorStore(userRoot).optOutMarker);
+  return fs108.existsSync(resolveCollectorStore(userRoot).optOutMarker);
 }
 var MIGRATIONS = Object.freeze({
   // 0 → 1. No DDL: `user_version` 0 is the default SQLite assigns, and a
@@ -39466,24 +40169,24 @@ var SPOOL_DIR_NAME = "spool";
 var SPOOL_PENDING_NAME = "pending.jsonl";
 var ENABLED_MARKER_NAME = "ENABLED";
 function denominatorPath(userRoot) {
-  return path108.join(resolveCollectorStore(userRoot).root, DENOMINATOR_FILE_NAME);
+  return path113.join(resolveCollectorStore(userRoot).root, DENOMINATOR_FILE_NAME);
 }
 function spoolDir(userRoot) {
-  return path108.join(resolveCollectorStore(userRoot).root, SPOOL_DIR_NAME);
+  return path113.join(resolveCollectorStore(userRoot).root, SPOOL_DIR_NAME);
 }
 function spoolPendingPath(userRoot) {
-  return path108.join(spoolDir(userRoot), SPOOL_PENDING_NAME);
+  return path113.join(spoolDir(userRoot), SPOOL_PENDING_NAME);
 }
 function enabledMarkerPath(userRoot) {
-  return path108.join(resolveCollectorStore(userRoot).root, ENABLED_MARKER_NAME);
+  return path113.join(resolveCollectorStore(userRoot).root, ENABLED_MARKER_NAME);
 }
 function isCollectorEnabled(userRoot) {
   if (isOptedOut(userRoot)) return false;
-  if (fs105.existsSync(killSwitchPathLocal(userRoot))) return false;
-  return fs105.existsSync(enabledMarkerPath(userRoot));
+  if (fs109.existsSync(killSwitchPathLocal(userRoot))) return false;
+  return fs109.existsSync(enabledMarkerPath(userRoot));
 }
 function killSwitchPathLocal(userRoot) {
-  return path108.join(resolveCollectorStore(userRoot).root, "STOP");
+  return path113.join(resolveCollectorStore(userRoot).root, "STOP");
 }
 function utcDate(at = Date.now()) {
   return new Date(at).toISOString().slice(0, 10);
@@ -39495,8 +40198,8 @@ function recordOpportunity(event, platform, userRoot, at = Date.now(), opts = {}
     if (!COLLECTOR_EVENTS.includes(event)) return false;
     if (!COLLECTOR_PLATFORMS.includes(platform)) return false;
     const target = denominatorPath(userRoot);
-    fs105.mkdirSync(path108.dirname(target), { recursive: true });
-    fs105.appendFileSync(target, `${utcDate(at)}	${event}	${platform}
+    fs109.mkdirSync(path113.dirname(target), { recursive: true });
+    fs109.appendFileSync(target, `${utcDate(at)}	${event}	${platform}
 `);
     return true;
   } catch {
@@ -39510,19 +40213,19 @@ var MACHINE_ID_NAME = "machine-id";
 var EPISODE_DIR_NAME = "episodes";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function machineIdPath(userRoot) {
-  return path108.join(resolveCollectorStore(userRoot).root, MACHINE_ID_NAME);
+  return path113.join(resolveCollectorStore(userRoot).root, MACHINE_ID_NAME);
 }
 function machineId(userRoot) {
   const target = machineIdPath(userRoot);
   try {
-    const existing = fs105.readFileSync(target, "utf8").trim();
+    const existing = fs109.readFileSync(target, "utf8").trim();
     if (UUID_RE.test(existing)) return existing;
   } catch {
   }
   try {
     const minted = crypto15.randomUUID();
-    fs105.mkdirSync(path108.dirname(target), { recursive: true });
-    fs105.writeFileSync(target, `${minted}
+    fs109.mkdirSync(path113.dirname(target), { recursive: true });
+    fs109.writeFileSync(target, `${minted}
 `);
     return minted;
   } catch {
@@ -39546,17 +40249,17 @@ function episodeId(env = process.env) {
   ].join("-");
 }
 function nextSequence(episode, userRoot) {
-  const dir = path108.join(resolveCollectorStore(userRoot).root, EPISODE_DIR_NAME);
-  const target = path108.join(dir, `${episode}.seq`);
+  const dir = path113.join(resolveCollectorStore(userRoot).root, EPISODE_DIR_NAME);
+  const target = path113.join(dir, `${episode}.seq`);
   try {
-    fs105.mkdirSync(dir, { recursive: true });
+    fs109.mkdirSync(dir, { recursive: true });
     let current = 0;
     try {
-      const raw = Number.parseInt(fs105.readFileSync(target, "utf8").trim(), 10);
+      const raw = Number.parseInt(fs109.readFileSync(target, "utf8").trim(), 10);
       if (Number.isInteger(raw) && raw >= 0) current = raw + 1;
     } catch {
     }
-    fs105.writeFileSync(target, `${current}
+    fs109.writeFileSync(target, `${current}
 `);
     return current;
   } catch {
@@ -39595,12 +40298,12 @@ function spoolRecord(record, userRoot) {
   try {
     if (!isCollectorEnabled(userRoot)) return false;
     const target = spoolPendingPath(userRoot);
-    fs105.mkdirSync(path108.dirname(target), { recursive: true });
+    fs109.mkdirSync(path113.dirname(target), { recursive: true });
     try {
-      if (fs105.statSync(target).size >= SPOOL_MAX_BYTES) return false;
+      if (fs109.statSync(target).size >= SPOOL_MAX_BYTES) return false;
     } catch {
     }
-    fs105.appendFileSync(target, `${JSON.stringify(record)}
+    fs109.appendFileSync(target, `${JSON.stringify(record)}
 `);
     return true;
   } catch {
@@ -39609,12 +40312,12 @@ function spoolRecord(record, userRoot) {
 }
 
 // src/scripts/hooks/dispatch_hook.ts
-var _IN_BUNDLE2 = true;
-var REPO_ROOT = path109.resolve(
-  path109.dirname(fileURLToPath70(import.meta.url)),
-  ..._IN_BUNDLE2 ? ["..", ".."] : ["..", "..", ".."]
+var _IN_BUNDLE3 = true;
+var REPO_ROOT = path114.resolve(
+  path114.dirname(fileURLToPath73(import.meta.url)),
+  ..._IN_BUNDLE3 ? ["..", ".."] : ["..", "..", ".."]
 );
-var MANIFEST_PATH = path109.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
+var MANIFEST_PATH = path114.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
 var EXIT_ALLOW37 = 0;
 var EXIT_BLOCK6 = 1;
 var EXIT_WARN19 = 2;
@@ -39676,11 +40379,11 @@ function _manifest_fingerprint(text) {
   return `${h.toString(16)}:${String(text.length)}`;
 }
 function _load_yaml3(p) {
-  const text = fs106.readFileSync(p, "utf-8");
+  const text = fs110.readFileSync(p, "utf-8");
   const compiled = p.replace(/\.ya?ml$/u, ".json");
   if (compiled !== p) {
     try {
-      const raw = JSON.parse(fs106.readFileSync(compiled, "utf-8"));
+      const raw = JSON.parse(fs110.readFileSync(compiled, "utf-8"));
       if (_isObject18(raw) && raw["fingerprint"] === _manifest_fingerprint(text) && _isObject18(raw["manifest"])) {
         return raw["manifest"];
       }
@@ -39778,7 +40481,7 @@ function _maybe_capture_payload(args, payload_text) {
   }
   try {
     const target = _expanduser3(capture_dir);
-    fs106.mkdirSync(target, { recursive: true });
+    fs110.mkdirSync(target, { recursive: true });
     let payload;
     try {
       payload = payload_text.trim() ? JSON.parse(payload_text) : {};
@@ -39795,8 +40498,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`;
-    fs106.writeFileSync(
-      path109.join(target, fname),
+    fs110.writeFileSync(
+      path114.join(target, fname),
       _py_json_dumps2(record, 2) + "\n",
       { encoding: "utf-8" }
     );
@@ -39807,7 +40510,7 @@ function _maybe_capture_payload(args, payload_text) {
 function _expanduser3(p) {
   if (p === "~" || p.startsWith("~/")) {
     const home = process.env["HOME"] || process.env["USERPROFILE"] || "";
-    return path109.join(home, p.slice(1));
+    return path114.join(home, p.slice(1));
   }
   return p;
 }
@@ -39840,25 +40543,25 @@ function _resolve_tsx_invocation2(scriptPath, scriptArgs) {
   const walkUp = (start) => {
     let dir = start;
     for (; ; ) {
-      const candidate = path109.join(dir, "node_modules", ".bin", binName);
+      const candidate = path114.join(dir, "node_modules", ".bin", binName);
       if (_isFile8(candidate)) {
         return candidate;
       }
-      const parent = path109.dirname(dir);
+      const parent = path114.dirname(dir);
       if (parent === dir) {
         return null;
       }
       dir = parent;
     }
   };
-  const tsx = walkUp(path109.dirname(scriptPath)) ?? walkUp(path109.dirname(fileURLToPath70(import.meta.url)));
+  const tsx = walkUp(path114.dirname(scriptPath)) ?? walkUp(path114.dirname(fileURLToPath73(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 = path109.join(REPO_ROOT, String(concern["script"]));
+  const scriptAbs = path114.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());
@@ -39894,7 +40597,7 @@ function _run_concern_inproc(main_fn, concern, envelope) {
       if (!(k in hardened)) delete process.env[k];
     }
     Object.assign(process.env, hardened);
-    if (workspace !== prevCwd && _isDir4(workspace)) {
+    if (workspace !== prevCwd && _isDir6(workspace)) {
       process.chdir(workspace);
     }
     const result = main_fn(argsList);
@@ -39935,7 +40638,7 @@ function _run_concern(concern, envelope) {
       return _run_concern_inproc(inproc, concern, envelope);
     }
   }
-  const script = path109.join(REPO_ROOT, String(concern["script"]));
+  const script = path114.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"));
@@ -39958,7 +40661,7 @@ function _run_concern(concern, envelope) {
   const concern_env = hardenedSpawnEnv({ AGENT_CONFIG_PACKAGE_ROOT: REPO_ROOT });
   const started = performance.now();
   const { command, args: spawnArgs } = _resolve_tsx_invocation2(script, cmd.slice(1));
-  const proc = spawnSync10(command, spawnArgs, {
+  const proc = spawnSync11(command, spawnArgs, {
     input: _compactJsonDumps(envelope),
     encoding: "utf-8",
     cwd: workspace,
@@ -39992,7 +40695,7 @@ function _run_concern(concern, envelope) {
 }
 function _isFile8(p) {
   try {
-    return fs106.statSync(p).isFile();
+    return fs110.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -40014,10 +40717,10 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     return;
   }
   const workspace = String(envelope["workspace_root"] || process.cwd());
-  const state_root = path109.join(workspace, "agents", "runtime", "state");
+  const state_root = path114.join(workspace, "agents", "runtime", "state");
   const fb_dir = feedback_dir(state_root, session_id);
   try {
-    fs106.mkdirSync(fb_dir, { recursive: true });
+    fs110.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}
@@ -40025,7 +40728,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     return;
   }
   for (const entry of entries) {
-    const target = path109.join(fb_dir, `${entry["concern"]}.json`);
+    const target = path114.join(fb_dir, `${entry["concern"]}.json`);
     try {
       atomic_write_json(target, entry);
     } catch (exc) {
@@ -40074,7 +40777,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
   };
   try {
     const invocation = `${String(process.pid)}-${process.hrtime.bigint().toString()}`;
-    update_json_under_lock(path109.join(fb_dir, "summary.json"), (loaded) => {
+    update_json_under_lock(path114.join(fb_dir, "summary.json"), (loaded) => {
       const priorRaw = loaded["invocations"];
       const prior = Array.isArray(priorRaw) ? priorRaw : [];
       const next = [...prior, { invocation, ...summary }];
@@ -40101,8 +40804,8 @@ function _record_rule_trips(envelope, entries) {
   if (tripped.length === 0) return;
   try {
     const workspace = String(envelope["workspace_root"] || process.cwd());
-    const state_dir = path109.join(workspace, "agents", "runtime", "state");
-    const target = path109.join(state_dir, "rule-trips.json");
+    const state_dir = path114.join(workspace, "agents", "runtime", "state");
+    const target = path114.join(state_dir, "rule-trips.json");
     const today = _now_iso3().slice(0, 10);
     update_json_under_lock(target, (loaded) => {
       const doc = { schema_version: 1, concerns: {}, ...loaded };
@@ -40207,11 +40910,11 @@ function _parse_args(argv) {
   }
   return args;
 }
-function main68(argv) {
+function main70(argv) {
   const args = _parse_args(argv ?? process.argv.slice(2));
   if (args.project_dir) {
     const project_dir = _expanduser3(args.project_dir);
-    if (_isDir4(project_dir)) {
+    if (_isDir6(project_dir)) {
       process.chdir(project_dir);
     } else {
       process.stderr.write(
@@ -40244,7 +40947,7 @@ function main68(argv) {
   recordOpportunity(args.event, args.platform);
   recordCapture(args.event, args.platform);
   const manifest_path = args.manifest;
-  if (!fs106.existsSync(manifest_path)) {
+  if (!fs110.existsSync(manifest_path)) {
     process.stderr.write(`dispatch_hook: manifest missing at ${manifest_path}
 `);
     return EXIT_ALLOW37;
@@ -40412,9 +41115,9 @@ function main68(argv) {
   }
   return emission.exit;
 }
-function _isDir4(p) {
+function _isDir6(p) {
   try {
-    return fs106.statSync(p).isDirectory();
+    return fs110.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -40424,36 +41127,36 @@ function _sortedRepr(s) {
   return `[${items.map((x) => `'${x}'`).join(", ")}]`;
 }
 var _stdin_read_failed = null;
-function _isCliEntry51() {
+function _isCliEntry53() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL61(path109.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL63(path114.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs106.realpathSync(fileURLToPath70(import.meta.url));
-    const argv = fs106.realpathSync(path109.resolve(process.argv[1]));
+    const here = fs110.realpathSync(fileURLToPath73(import.meta.url));
+    const argv = fs110.realpathSync(path114.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var isCliEntry16 = _isCliEntry51();
+var isCliEntry16 = _isCliEntry53();
 if (isCliEntry16) {
-  process.exit(main68(process.argv.slice(2)));
+  process.exit(main70(process.argv.slice(2)));
 }
 
 // src/scripts/hooks/dispatch_entry.ts
-var _selfPath = fileURLToPath71(import.meta.url);
-var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path110.resolve(process.argv[1]) === path110.resolve(_selfPath);
+var _selfPath = fileURLToPath74(import.meta.url);
+var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path115.resolve(process.argv[1]) === path115.resolve(_selfPath);
 if (_invokedDirectly2) {
-  process.exitCode = main68(process.argv.slice(2));
+  process.exitCode = main70(process.argv.slice(2));
 }
 export {
-  main68 as main
+  main70 as main
 };