@event4u/agent-config 10.3.0 → 10.4.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, path69) {
-      const ctrl = callVisitor(key, node, visitor, path69);
+    function visit_(key, node, visitor, path71) {
+      const ctrl = callVisitor(key, node, visitor, path71);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path69, ctrl);
-        return visit_(key, ctrl, visitor, path69);
+        replaceNode(key, path71, ctrl);
+        return visit_(key, ctrl, visitor, path71);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path69 = Object.freeze(path69.concat(node));
+          path71 = Object.freeze(path71.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path69);
+            const ci = visit_(i, node.items[i], visitor, path71);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -133,13 +133,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path69 = Object.freeze(path69.concat(node));
-          const ck = visit_("key", node.key, visitor, path69);
+          path71 = Object.freeze(path71.concat(node));
+          const ck = visit_("key", node.key, visitor, path71);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path69);
+          const cv = visit_("value", node.value, visitor, path71);
           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, path69) {
-      const ctrl = await callVisitor(key, node, visitor, path69);
+    async function visitAsync_(key, node, visitor, path71) {
+      const ctrl = await callVisitor(key, node, visitor, path71);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path69, ctrl);
-        return visitAsync_(key, ctrl, visitor, path69);
+        replaceNode(key, path71, ctrl);
+        return visitAsync_(key, ctrl, visitor, path71);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path69 = Object.freeze(path69.concat(node));
+          path71 = Object.freeze(path71.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path69);
+            const ci = await visitAsync_(i, node.items[i], visitor, path71);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -181,13 +181,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path69 = Object.freeze(path69.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path69);
+          path71 = Object.freeze(path71.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path71);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path69);
+          const cv = await visitAsync_("value", node.value, visitor, path71);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -214,23 +214,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path69) {
+    function callVisitor(key, node, visitor, path71) {
       if (typeof visitor === "function")
-        return visitor(key, node, path69);
+        return visitor(key, node, path71);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path69);
+        return visitor.Map?.(key, node, path71);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path69);
+        return visitor.Seq?.(key, node, path71);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path69);
+        return visitor.Pair?.(key, node, path71);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path69);
+        return visitor.Scalar?.(key, node, path71);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path69);
+        return visitor.Alias?.(key, node, path71);
       return void 0;
     }
-    function replaceNode(key, path69, node) {
-      const parent = path69[path69.length - 1];
+    function replaceNode(key, path71, node) {
+      const parent = path71[path71.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, path69, value) {
+    function collectionFromPath(schema, path71, value) {
       let v = value;
-      for (let i = path69.length - 1; i >= 0; --i) {
-        const k = path69[i];
+      for (let i = path71.length - 1; i >= 0; --i) {
+        const k = path71[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 = (path69) => path69 == null || typeof path69 === "object" && !!path69[Symbol.iterator]().next().done;
+    var isEmptyPath = (path71) => path71 == null || typeof path71 === "object" && !!path71[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(path69, value) {
-        if (isEmptyPath(path69))
+      addIn(path71, value) {
+        if (isEmptyPath(path71))
           this.add(value);
         else {
-          const [key, ...rest] = path69;
+          const [key, ...rest] = path71;
           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(path69) {
-        const [key, ...rest] = path69;
+      deleteIn(path71) {
+        const [key, ...rest] = path71;
         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(path69, keepScalar) {
-        const [key, ...rest] = path69;
+      getIn(path71, keepScalar) {
+        const [key, ...rest] = path71;
         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(path69) {
-        const [key, ...rest] = path69;
+      hasIn(path71) {
+        const [key, ...rest] = path71;
         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(path69, value) {
-        const [key, ...rest] = path69;
+      setIn(path71, value) {
+        const [key, ...rest] = path71;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -980,13 +980,13 @@ var require_Collection = __commonJS({
 var require_stringifyComment = __commonJS({
   "node_modules/yaml/dist/stringify/stringifyComment.js"(exports) {
     "use strict";
-    var stringifyComment = (str8) => str8.replace(/^(?!$)(?: $)?/gm, "#");
+    var stringifyComment = (str9) => str9.replace(/^(?!$)(?: $)?/gm, "#");
     function indentComment(comment, indent) {
       if (/^\n+$/.test(comment))
         return comment.substring(1);
       return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
     }
-    var lineComment = (str8, indent, comment) => str8.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str8.endsWith(" ") ? "" : " ") + comment;
+    var lineComment = (str9, indent, comment) => str9.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str9.endsWith(" ") ? "" : " ") + comment;
     exports.indentComment = indentComment;
     exports.lineComment = lineComment;
     exports.stringifyComment = stringifyComment;
@@ -1140,16 +1140,16 @@ var require_stringifyString = __commonJS({
       lineWidth: ctx.options.lineWidth,
       minContentWidth: ctx.options.minContentWidth
     });
-    var containsDocumentMarker = (str8) => /^(%|---|\.\.\.)/m.test(str8);
-    function lineLengthOverLimit(str8, lineWidth, indentLength) {
+    var containsDocumentMarker = (str9) => /^(%|---|\.\.\.)/m.test(str9);
+    function lineLengthOverLimit(str9, lineWidth, indentLength) {
       if (!lineWidth || lineWidth < 0)
         return false;
       const limit = lineWidth - indentLength;
-      const strLen = str8.length;
+      const strLen = str9.length;
       if (strLen <= limit)
         return false;
       for (let i = 0, start = 0; i < strLen; ++i) {
-        if (str8[i] === "\n") {
+        if (str9[i] === "\n") {
           if (i - start > limit)
             return true;
           start = i + 1;
@@ -1166,11 +1166,11 @@ var require_stringifyString = __commonJS({
       const { implicitKey } = ctx;
       const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
       const indent = ctx.indent || (containsDocumentMarker(value) ? "  " : "");
-      let str8 = "";
+      let str9 = "";
       let start = 0;
       for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
         if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") {
-          str8 += json.slice(start, i) + "\\ ";
+          str9 += json.slice(start, i) + "\\ ";
           i += 1;
           start = i;
           ch = "\\";
@@ -1179,38 +1179,38 @@ var require_stringifyString = __commonJS({
           switch (json[i + 1]) {
             case "u":
               {
-                str8 += json.slice(start, i);
+                str9 += json.slice(start, i);
                 const code = json.substr(i + 2, 4);
                 switch (code) {
                   case "0000":
-                    str8 += "\\0";
+                    str9 += "\\0";
                     break;
                   case "0007":
-                    str8 += "\\a";
+                    str9 += "\\a";
                     break;
                   case "000b":
-                    str8 += "\\v";
+                    str9 += "\\v";
                     break;
                   case "001b":
-                    str8 += "\\e";
+                    str9 += "\\e";
                     break;
                   case "0085":
-                    str8 += "\\N";
+                    str9 += "\\N";
                     break;
                   case "00a0":
-                    str8 += "\\_";
+                    str9 += "\\_";
                     break;
                   case "2028":
-                    str8 += "\\L";
+                    str9 += "\\L";
                     break;
                   case "2029":
-                    str8 += "\\P";
+                    str9 += "\\P";
                     break;
                   default:
                     if (code.substr(0, 2) === "00")
-                      str8 += "\\x" + code.substr(2);
+                      str9 += "\\x" + code.substr(2);
                     else
-                      str8 += json.substr(i, 6);
+                      str9 += json.substr(i, 6);
                 }
                 i += 5;
                 start = i + 1;
@@ -1220,14 +1220,14 @@ var require_stringifyString = __commonJS({
               if (implicitKey || json[i + 2] === '"' || json.length < minMultiLineLength) {
                 i += 1;
               } else {
-                str8 += json.slice(start, i) + "\n\n";
+                str9 += json.slice(start, i) + "\n\n";
                 while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== '"') {
-                  str8 += "\n";
+                  str9 += "\n";
                   i += 2;
                 }
-                str8 += indent;
+                str9 += indent;
                 if (json[i + 2] === " ")
-                  str8 += "\\";
+                  str9 += "\\";
                 i += 1;
                 start = i + 1;
               }
@@ -1236,8 +1236,8 @@ var require_stringifyString = __commonJS({
               i += 1;
           }
       }
-      str8 = start ? str8 + json.slice(start) : json;
-      return implicitKey ? str8 : foldFlowLines.foldFlowLines(str8, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false));
+      str9 = start ? str9 + json.slice(start) : json;
+      return implicitKey ? str9 : foldFlowLines.foldFlowLines(str9, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false));
     }
     function singleQuotedString(value, ctx) {
       if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value))
@@ -1365,15 +1365,15 @@ ${indent}${start}${value}${end}`;
           return quotedString(value, ctx);
         }
       }
-      const str8 = value.replace(/\n+/g, `$&
+      const str9 = value.replace(/\n+/g, `$&
 ${indent}`);
       if (actualString) {
-        const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str8);
+        const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str9);
         const { compat, tags } = ctx.doc.schema;
         if (tags.some(test) || compat?.some(test))
           return quotedString(value, ctx);
       }
-      return implicitKey ? str8 : foldFlowLines.foldFlowLines(str8, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
+      return implicitKey ? str9 : foldFlowLines.foldFlowLines(str9, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
     }
     function stringifyString(item, ctx, onComment, onChompKeep) {
       const { implicitKey, inFlow } = ctx;
@@ -1525,11 +1525,11 @@ var require_stringify = __commonJS({
       const props = stringifyProps(node, tagObj, ctx);
       if (props.length > 0)
         ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
-      const str8 = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : identity.isScalar(node) ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
+      const str9 = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : identity.isScalar(node) ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep);
       if (!props)
-        return str8;
-      return identity.isScalar(node) || str8[0] === "{" || str8[0] === "[" ? `${props} ${str8}` : `${props}
-${ctx.indent}${str8}`;
+        return str9;
+      return identity.isScalar(node) || str9[0] === "{" || str9[0] === "[" ? `${props} ${str9}` : `${props}
+${ctx.indent}${str9}`;
     }
     exports.createStringifyContext = createStringifyContext;
     exports.stringify = stringify;
@@ -1564,8 +1564,8 @@ var require_stringifyPair = __commonJS({
       });
       let keyCommentDone = false;
       let chompKeep = false;
-      let str8 = stringify.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
-      if (!explicitKey && !ctx.inFlow && str8.length > 1024) {
+      let str9 = stringify.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
+      if (!explicitKey && !ctx.inFlow && str9.length > 1024) {
         if (simpleKeys)
           throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
         explicitKey = true;
@@ -1574,27 +1574,27 @@ var require_stringifyPair = __commonJS({
         if (allNullValues || value == null) {
           if (keyCommentDone && onComment)
             onComment();
-          return str8 === "" ? "?" : explicitKey ? `? ${str8}` : str8;
+          return str9 === "" ? "?" : explicitKey ? `? ${str9}` : str9;
         }
       } else if (allNullValues && !simpleKeys || value == null && explicitKey) {
-        str8 = `? ${str8}`;
+        str9 = `? ${str9}`;
         if (keyComment && !keyCommentDone) {
-          str8 += stringifyComment.lineComment(str8, ctx.indent, commentString(keyComment));
+          str9 += stringifyComment.lineComment(str9, ctx.indent, commentString(keyComment));
         } else if (chompKeep && onChompKeep)
           onChompKeep();
-        return str8;
+        return str9;
       }
       if (keyCommentDone)
         keyComment = null;
       if (explicitKey) {
         if (keyComment)
-          str8 += stringifyComment.lineComment(str8, ctx.indent, commentString(keyComment));
-        str8 = `? ${str8}
+          str9 += stringifyComment.lineComment(str9, ctx.indent, commentString(keyComment));
+        str9 = `? ${str9}
 ${indent}:`;
       } else {
-        str8 = `${str8}:`;
+        str9 = `${str9}:`;
         if (keyComment)
-          str8 += stringifyComment.lineComment(str8, ctx.indent, commentString(keyComment));
+          str9 += stringifyComment.lineComment(str9, ctx.indent, commentString(keyComment));
       }
       let vsb, vcb, valueComment;
       if (identity.isNode(value)) {
@@ -1610,7 +1610,7 @@ ${indent}:`;
       }
       ctx.implicitKey = false;
       if (!explicitKey && !keyComment && identity.isScalar(value))
-        ctx.indentAtStart = str8.length + 1;
+        ctx.indentAtStart = str9.length + 1;
       chompKeep = false;
       if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && identity.isSeq(value) && !value.flow && !value.tag && !value.anchor) {
         ctx.indent = ctx.indent.substring(2);
@@ -1654,16 +1654,16 @@ ${ctx.indent}`;
       } else if (valueStr === "" || valueStr[0] === "\n") {
         ws = "";
       }
-      str8 += ws + valueStr;
+      str9 += ws + valueStr;
       if (ctx.inFlow) {
         if (valueCommentDone && onComment)
           onComment();
       } else if (valueComment && !valueCommentDone) {
-        str8 += stringifyComment.lineComment(str8, ctx.indent, commentString(valueComment));
+        str9 += stringifyComment.lineComment(str9, ctx.indent, commentString(valueComment));
       } else if (chompKeep && onChompKeep) {
         onChompKeep();
       }
-      return str8;
+      return str9;
     }
     exports.stringifyPair = stringifyPair;
   }
@@ -1890,31 +1890,31 @@ var require_stringifyCollection = __commonJS({
           }
         }
         chompKeep = false;
-        let str9 = stringify.stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true);
+        let str10 = stringify.stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true);
         if (comment2)
-          str9 += stringifyComment.lineComment(str9, itemIndent, commentString(comment2));
+          str10 += stringifyComment.lineComment(str10, itemIndent, commentString(comment2));
         if (chompKeep && comment2)
           chompKeep = false;
-        lines.push(blockItemPrefix + str9);
+        lines.push(blockItemPrefix + str10);
       }
-      let str8;
+      let str9;
       if (lines.length === 0) {
-        str8 = flowChars.start + flowChars.end;
+        str9 = flowChars.start + flowChars.end;
       } else {
-        str8 = lines[0];
+        str9 = lines[0];
         for (let i = 1; i < lines.length; ++i) {
           const line = lines[i];
-          str8 += line ? `
+          str9 += line ? `
 ${indent}${line}` : "\n";
         }
       }
       if (comment) {
-        str8 += "\n" + stringifyComment.indentComment(commentString(comment), indent);
+        str9 += "\n" + stringifyComment.indentComment(commentString(comment), indent);
         if (onComment)
           onComment();
       } else if (chompKeep && onChompKeep)
         onChompKeep();
-      return str8;
+      return str9;
     }
     function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {
       const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
@@ -1957,21 +1957,21 @@ ${indent}${line}` : "\n";
         }
         if (comment)
           reqNewline = true;
-        let str8 = stringify.stringify(item, itemCtx, () => comment = null);
-        reqNewline || (reqNewline = lines.length > linesAtValue || str8.includes("\n"));
+        let str9 = stringify.stringify(item, itemCtx, () => comment = null);
+        reqNewline || (reqNewline = lines.length > linesAtValue || str9.includes("\n"));
         if (i < items.length - 1) {
-          str8 += ",";
+          str9 += ",";
         } else if (ctx.options.trailingComma) {
           if (ctx.options.lineWidth > 0) {
-            reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str8.length + 2) > ctx.options.lineWidth);
+            reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str9.length + 2) > ctx.options.lineWidth);
           }
           if (reqNewline) {
-            str8 += ",";
+            str9 += ",";
           }
         }
         if (comment)
-          str8 += stringifyComment.lineComment(str8, itemIndent, commentString(comment));
-        lines.push(str8);
+          str9 += stringifyComment.lineComment(str9, itemIndent, commentString(comment));
+        lines.push(str9);
         linesAtValue = lines.length;
       }
       const { start, end } = flowChars;
@@ -1983,11 +1983,11 @@ ${indent}${line}` : "\n";
           reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
         }
         if (reqNewline) {
-          let str8 = start;
+          let str9 = start;
           for (const line of lines)
-            str8 += line ? `
+            str9 += line ? `
 ${indentStep}${indent}${line}` : "\n";
-          return `${str8}
+          return `${str9}
 ${indent}${end}`;
         } else {
           return `${start}${fcPadding}${lines.join(" ")}${fcPadding}${end}`;
@@ -2319,7 +2319,7 @@ var require_string = __commonJS({
       identify: (value) => typeof value === "string",
       default: true,
       tag: "tag:yaml.org,2002:str",
-      resolve: (str8) => str8,
+      resolve: (str9) => str9,
       stringify(item, ctx, onComment, onChompKeep) {
         ctx = Object.assign({ actualString: true }, ctx);
         return stringifyString.stringifyString(item, ctx, onComment, onChompKeep);
@@ -2357,7 +2357,7 @@ var require_bool = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:bool",
       test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
-      resolve: (str8) => new Scalar.Scalar(str8[0] === "t" || str8[0] === "T"),
+      resolve: (str9) => new Scalar.Scalar(str9[0] === "t" || str9[0] === "T"),
       stringify({ source, value }, ctx) {
         if (source && boolTag.test.test(source)) {
           const sv = source[0] === "t" || source[0] === "T";
@@ -2409,7 +2409,7 @@ var require_float = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
-      resolve: (str8) => str8.slice(-3).toLowerCase() === "nan" ? NaN : str8[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+      resolve: (str9) => str9.slice(-3).toLowerCase() === "nan" ? NaN : str9[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
       stringify: stringifyNumber.stringifyNumber
     };
     var floatExp = {
@@ -2418,7 +2418,7 @@ var require_float = __commonJS({
       tag: "tag:yaml.org,2002:float",
       format: "EXP",
       test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
-      resolve: (str8) => parseFloat(str8),
+      resolve: (str9) => parseFloat(str9),
       stringify(node) {
         const num = Number(node.value);
         return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node);
@@ -2429,11 +2429,11 @@ var require_float = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
-      resolve(str8) {
-        const node = new Scalar.Scalar(parseFloat(str8));
-        const dot = str8.indexOf(".");
-        if (dot !== -1 && str8[str8.length - 1] === "0")
-          node.minFractionDigits = str8.length - dot - 1;
+      resolve(str9) {
+        const node = new Scalar.Scalar(parseFloat(str9));
+        const dot = str9.indexOf(".");
+        if (dot !== -1 && str9[str9.length - 1] === "0")
+          node.minFractionDigits = str9.length - dot - 1;
         return node;
       },
       stringify: stringifyNumber.stringifyNumber
@@ -2450,7 +2450,7 @@ var require_int = __commonJS({
     "use strict";
     var stringifyNumber = require_stringifyNumber();
     var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
-    var intResolve = (str8, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str8) : parseInt(str8.substring(offset), radix);
+    var intResolve = (str9, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str9) : parseInt(str9.substring(offset), radix);
     function intStringify(node, radix, prefix) {
       const { value } = node;
       if (intIdentify(value) && value >= 0)
@@ -2463,7 +2463,7 @@ var require_int = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "OCT",
       test: /^0o[0-7]+$/,
-      resolve: (str8, _onError, opt) => intResolve(str8, 2, 8, opt),
+      resolve: (str9, _onError, opt) => intResolve(str9, 2, 8, opt),
       stringify: (node) => intStringify(node, 8, "0o")
     };
     var int2 = {
@@ -2471,7 +2471,7 @@ var require_int = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:int",
       test: /^[-+]?[0-9]+$/,
-      resolve: (str8, _onError, opt) => intResolve(str8, 0, 10, opt),
+      resolve: (str9, _onError, opt) => intResolve(str9, 0, 10, opt),
       stringify: stringifyNumber.stringifyNumber
     };
     var intHex = {
@@ -2480,7 +2480,7 @@ var require_int = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "HEX",
       test: /^0x[0-9a-fA-F]+$/,
-      resolve: (str8, _onError, opt) => intResolve(str8, 2, 16, opt),
+      resolve: (str9, _onError, opt) => intResolve(str9, 2, 16, opt),
       stringify: (node) => intStringify(node, 16, "0x")
     };
     exports.int = int2;
@@ -2533,7 +2533,7 @@ var require_schema2 = __commonJS({
         identify: (value) => typeof value === "string",
         default: true,
         tag: "tag:yaml.org,2002:str",
-        resolve: (str8) => str8,
+        resolve: (str9) => str9,
         stringify: stringifyJSON
       },
       {
@@ -2550,7 +2550,7 @@ var require_schema2 = __commonJS({
         default: true,
         tag: "tag:yaml.org,2002:bool",
         test: /^true$|^false$/,
-        resolve: (str8) => str8 === "true",
+        resolve: (str9) => str9 === "true",
         stringify: stringifyJSON
       },
       {
@@ -2558,7 +2558,7 @@ var require_schema2 = __commonJS({
         default: true,
         tag: "tag:yaml.org,2002:int",
         test: /^-?(?:0|[1-9][0-9]*)$/,
-        resolve: (str8, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str8) : parseInt(str8, 10),
+        resolve: (str9, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str9) : parseInt(str9, 10),
         stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)
       },
       {
@@ -2566,7 +2566,7 @@ var require_schema2 = __commonJS({
         default: true,
         tag: "tag:yaml.org,2002:float",
         test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
-        resolve: (str8) => parseFloat(str8),
+        resolve: (str9) => parseFloat(str9),
         stringify: stringifyJSON
       }
     ];
@@ -2574,9 +2574,9 @@ var require_schema2 = __commonJS({
       default: true,
       tag: "",
       test: /^/,
-      resolve(str8, onError) {
-        onError(`Unresolved plain scalar ${JSON.stringify(str8)}`);
-        return str8;
+      resolve(str9, onError) {
+        onError(`Unresolved plain scalar ${JSON.stringify(str9)}`);
+        return str9;
       }
     };
     var schema = [map.map, seq.seq].concat(jsonScalars, jsonError);
@@ -2608,10 +2608,10 @@ var require_binary = __commonJS({
         if (typeof node_buffer.Buffer === "function") {
           return node_buffer.Buffer.from(src, "base64");
         } else if (typeof atob === "function") {
-          const str8 = atob(src.replace(/[\n\r]/g, ""));
-          const buffer = new Uint8Array(str8.length);
-          for (let i = 0; i < str8.length; ++i)
-            buffer[i] = str8.charCodeAt(i);
+          const str9 = atob(src.replace(/[\n\r]/g, ""));
+          const buffer = new Uint8Array(str9.length);
+          for (let i = 0; i < str9.length; ++i)
+            buffer[i] = str9.charCodeAt(i);
           return buffer;
         } else {
           onError("This environment does not support reading binary tags; either Buffer or atob is required");
@@ -2622,28 +2622,28 @@ var require_binary = __commonJS({
         if (!value)
           return "";
         const buf = value;
-        let str8;
+        let str9;
         if (typeof node_buffer.Buffer === "function") {
-          str8 = buf instanceof node_buffer.Buffer ? buf.toString("base64") : node_buffer.Buffer.from(buf.buffer).toString("base64");
+          str9 = buf instanceof node_buffer.Buffer ? buf.toString("base64") : node_buffer.Buffer.from(buf.buffer).toString("base64");
         } else if (typeof btoa === "function") {
           let s = "";
           for (let i = 0; i < buf.length; ++i)
             s += String.fromCharCode(buf[i]);
-          str8 = btoa(s);
+          str9 = btoa(s);
         } else {
           throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required");
         }
         type ?? (type = Scalar.Scalar.BLOCK_LITERAL);
         if (type !== Scalar.Scalar.QUOTE_DOUBLE) {
           const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
-          const n = Math.ceil(str8.length / lineWidth);
+          const n = Math.ceil(str9.length / lineWidth);
           const lines = new Array(n);
           for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
-            lines[i] = str8.substr(o, lineWidth);
+            lines[i] = str9.substr(o, lineWidth);
           }
-          str8 = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? "\n" : " ");
+          str9 = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? "\n" : " ");
         }
-        return stringifyString.stringifyString({ comment, type, value: str8 }, ctx, onComment, onChompKeep);
+        return stringifyString.stringifyString({ comment, type, value: str9 }, ctx, onComment, onChompKeep);
       }
     };
     exports.binary = binary;
@@ -2849,7 +2849,7 @@ var require_float2 = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
-      resolve: (str8) => str8.slice(-3).toLowerCase() === "nan" ? NaN : str8[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+      resolve: (str9) => str9.slice(-3).toLowerCase() === "nan" ? NaN : str9[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
       stringify: stringifyNumber.stringifyNumber
     };
     var floatExp = {
@@ -2858,7 +2858,7 @@ var require_float2 = __commonJS({
       tag: "tag:yaml.org,2002:float",
       format: "EXP",
       test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
-      resolve: (str8) => parseFloat(str8.replace(/_/g, "")),
+      resolve: (str9) => parseFloat(str9.replace(/_/g, "")),
       stringify(node) {
         const num = Number(node.value);
         return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node);
@@ -2869,11 +2869,11 @@ var require_float2 = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:float",
       test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
-      resolve(str8) {
-        const node = new Scalar.Scalar(parseFloat(str8.replace(/_/g, "")));
-        const dot = str8.indexOf(".");
+      resolve(str9) {
+        const node = new Scalar.Scalar(parseFloat(str9.replace(/_/g, "")));
+        const dot = str9.indexOf(".");
         if (dot !== -1) {
-          const f = str8.substring(dot + 1).replace(/_/g, "");
+          const f = str9.substring(dot + 1).replace(/_/g, "");
           if (f[f.length - 1] === "0")
             node.minFractionDigits = f.length;
         }
@@ -2893,34 +2893,34 @@ var require_int2 = __commonJS({
     "use strict";
     var stringifyNumber = require_stringifyNumber();
     var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
-    function intResolve(str8, offset, radix, { intAsBigInt }) {
-      const sign = str8[0];
+    function intResolve(str9, offset, radix, { intAsBigInt }) {
+      const sign = str9[0];
       if (sign === "-" || sign === "+")
         offset += 1;
-      str8 = str8.substring(offset).replace(/_/g, "");
+      str9 = str9.substring(offset).replace(/_/g, "");
       if (intAsBigInt) {
         switch (radix) {
           case 2:
-            str8 = `0b${str8}`;
+            str9 = `0b${str9}`;
             break;
           case 8:
-            str8 = `0o${str8}`;
+            str9 = `0o${str9}`;
             break;
           case 16:
-            str8 = `0x${str8}`;
+            str9 = `0x${str9}`;
             break;
         }
-        const n2 = BigInt(str8);
+        const n2 = BigInt(str9);
         return sign === "-" ? BigInt(-1) * n2 : n2;
       }
-      const n = parseInt(str8, radix);
+      const n = parseInt(str9, radix);
       return sign === "-" ? -1 * n : n;
     }
     function intStringify(node, radix, prefix) {
       const { value } = node;
       if (intIdentify(value)) {
-        const str8 = value.toString(radix);
-        return value < 0 ? "-" + prefix + str8.substr(1) : prefix + str8;
+        const str9 = value.toString(radix);
+        return value < 0 ? "-" + prefix + str9.substr(1) : prefix + str9;
       }
       return stringifyNumber.stringifyNumber(node);
     }
@@ -2930,7 +2930,7 @@ var require_int2 = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "BIN",
       test: /^[-+]?0b[0-1_]+$/,
-      resolve: (str8, _onError, opt) => intResolve(str8, 2, 2, opt),
+      resolve: (str9, _onError, opt) => intResolve(str9, 2, 2, opt),
       stringify: (node) => intStringify(node, 2, "0b")
     };
     var intOct = {
@@ -2939,7 +2939,7 @@ var require_int2 = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "OCT",
       test: /^[-+]?0[0-7_]+$/,
-      resolve: (str8, _onError, opt) => intResolve(str8, 1, 8, opt),
+      resolve: (str9, _onError, opt) => intResolve(str9, 1, 8, opt),
       stringify: (node) => intStringify(node, 8, "0")
     };
     var int2 = {
@@ -2947,7 +2947,7 @@ var require_int2 = __commonJS({
       default: true,
       tag: "tag:yaml.org,2002:int",
       test: /^[-+]?[0-9][0-9_]*$/,
-      resolve: (str8, _onError, opt) => intResolve(str8, 0, 10, opt),
+      resolve: (str9, _onError, opt) => intResolve(str9, 0, 10, opt),
       stringify: stringifyNumber.stringifyNumber
     };
     var intHex = {
@@ -2956,7 +2956,7 @@ var require_int2 = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "HEX",
       test: /^[-+]?0x[0-9a-fA-F_]+$/,
-      resolve: (str8, _onError, opt) => intResolve(str8, 2, 16, opt),
+      resolve: (str9, _onError, opt) => intResolve(str9, 2, 16, opt),
       stringify: (node) => intStringify(node, 16, "0x")
     };
     exports.int = int2;
@@ -3060,9 +3060,9 @@ var require_timestamp = __commonJS({
   "node_modules/yaml/dist/schema/yaml-1.1/timestamp.js"(exports) {
     "use strict";
     var stringifyNumber = require_stringifyNumber();
-    function parseSexagesimal(str8, asBigInt) {
-      const sign = str8[0];
-      const parts = sign === "-" || sign === "+" ? str8.substring(1) : str8;
+    function parseSexagesimal(str9, asBigInt) {
+      const sign = str9[0];
+      const parts = sign === "-" || sign === "+" ? str9.substring(1) : str9;
       const num = (n) => asBigInt ? BigInt(n) : Number(n);
       const res = parts.replace(/_/g, "").split(":").reduce((res2, p) => res2 * num(60) + num(p), num(0));
       return sign === "-" ? num(-1) * res : res;
@@ -3099,7 +3099,7 @@ var require_timestamp = __commonJS({
       tag: "tag:yaml.org,2002:int",
       format: "TIME",
       test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
-      resolve: (str8, _onError, { intAsBigInt }) => parseSexagesimal(str8, intAsBigInt),
+      resolve: (str9, _onError, { intAsBigInt }) => parseSexagesimal(str9, intAsBigInt),
       stringify: stringifySexagesimal
     };
     var floatTime = {
@@ -3108,7 +3108,7 @@ var require_timestamp = __commonJS({
       tag: "tag:yaml.org,2002:float",
       format: "TIME",
       test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
-      resolve: (str8) => parseSexagesimal(str8, false),
+      resolve: (str9) => parseSexagesimal(str9, false),
       stringify: stringifySexagesimal
     };
     var timestamp = {
@@ -3119,8 +3119,8 @@ var require_timestamp = __commonJS({
       // may be omitted altogether, resulting in a date format. In such a case, the time part is
       // assumed to be 00:00:00Z (start of day, UTC).
       test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"),
-      resolve(str8) {
-        const match = str8.match(timestamp.test);
+      resolve(str9) {
+        const match = str9.match(timestamp.test);
         if (!match)
           throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
         const [, year, month, day, hour, minute, second] = match.map(Number);
@@ -3471,9 +3471,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path69, value) {
+      addIn(path71, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path69, value);
+          this.contents.addIn(path71, 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(path69) {
-        if (Collection.isEmptyPath(path69)) {
+      deleteIn(path71) {
+        if (Collection.isEmptyPath(path71)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path69) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path71) : 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(path69, keepScalar) {
-        if (Collection.isEmptyPath(path69))
+      getIn(path71, keepScalar) {
+        if (Collection.isEmptyPath(path71))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path69, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path71, 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(path69) {
-        if (Collection.isEmptyPath(path69))
+      hasIn(path71) {
+        if (Collection.isEmptyPath(path71))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path69) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path71) : 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(path69, value) {
-        if (Collection.isEmptyPath(path69)) {
+      setIn(path71, value) {
+        if (Collection.isEmptyPath(path71)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path69), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path71), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path69, value);
+          this.contents.setIn(path71, value);
         }
       }
       /**
@@ -5570,9 +5570,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path69) => {
+    visit.itemAtPath = (cst, path71) => {
       let item = cst;
-      for (const [field, index] of path69) {
+      for (const [field, index] of path71) {
         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, path69) => {
-      const parent = visit.itemAtPath(cst, path69.slice(0, -1));
-      const field = path69[path69.length - 1][0];
+    visit.parentCollection = (cst, path71) => {
+      const parent = visit.itemAtPath(cst, path71.slice(0, -1));
+      const field = path71[path71.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path69, item, visitor) {
-      let ctrl = visitor(item, path69);
+    function _visit(path71, item, visitor) {
+      let ctrl = visitor(item, path71);
       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(path69.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path71.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, path69);
+            ctrl = ctrl(item, path71);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path69) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path71) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6913,14 +6913,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs66 = this.flowScalar(this.type);
+              const fs68 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs66, sep: [] });
+                map.items.push({ start, key: fs68, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs66);
+                this.stack.push(fs68);
               } else {
-                Object.assign(it, { key: fs66, sep: [] });
+                Object.assign(it, { key: fs68, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7048,13 +7048,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs66 = this.flowScalar(this.type);
+              const fs68 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs66, sep: [] });
+                fc.items.push({ start: [], key: fs68, sep: [] });
               else if (it.sep)
-                this.stack.push(fs66);
+                this.stack.push(fs68);
               else
-                Object.assign(it, { key: fs66, sep: [] });
+                Object.assign(it, { key: fs68, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7363,15 +7363,15 @@ var require_dist = __commonJS({
 });
 
 // src/scripts/hooks/dispatch_entry.ts
-import * as path68 from "node:path";
-import { fileURLToPath as fileURLToPath48 } from "node:url";
+import * as path70 from "node:path";
+import { fileURLToPath as fileURLToPath50 } from "node:url";
 
 // src/scripts/hooks/dispatch_hook.ts
 var import_yaml6 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync7 } from "node:child_process";
-import fs65 from "node:fs";
-import path67 from "node:path";
-import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL41 } from "node:url";
+import fs67 from "node:fs";
+import path69 from "node:path";
+import { fileURLToPath as fileURLToPath49, pathToFileURL as pathToFileURL43 } from "node:url";
 
 // src/scripts/_lib/spawn_env.ts
 var DENY_EXACT = /* @__PURE__ */ new Set([
@@ -25711,12 +25711,461 @@ if (_isCliEntry31()) {
 }
 
 // src/scripts/hooks/turn_end_gate_hook.ts
+import * as crypto7 from "node:crypto";
+import * as fs61 from "node:fs";
+import * as path62 from "node:path";
+import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL38 } from "node:url";
+
+// src/scripts/hooks/subagent_ledger_hook.ts
 import * as crypto6 from "node:crypto";
 import * as fs60 from "node:fs";
 import * as path61 from "node:path";
 import { fileURLToPath as fileURLToPath43, pathToFileURL as pathToFileURL37 } from "node:url";
-var EXIT_BLOCK4 = 1;
+
+// src/scripts/_lib/subagent_response.ts
+var MAX_SUMMARY_CHARS = 2e3;
+var MAX_RESPONSE_LINE_CHARS = 240;
+var MAX_RESPONSE_ENTRIES = 40;
+var MAX_ARTIFACT_REF_CHARS = 200;
+var MAX_ENVELOPE_CHARS = 12e3;
+var CONFIDENCE = /* @__PURE__ */ new Set(["low", "medium", "high"]);
+function validateResponse(input) {
+  const errors = [];
+  if (input === null || typeof input !== "object") {
+    return { valid: false, errors: ["response is not an object"] };
+  }
+  const r = input;
+  if (typeof r.summary !== "string") errors.push("summary missing or not a string");
+  if (typeof r.handoff !== "string") errors.push("handoff missing or not a string");
+  if (!CONFIDENCE.has(r.confidence)) errors.push(`confidence must be low|medium|high (got ${String(r.confidence)})`);
+  if (!Array.isArray(r.findings)) errors.push("findings missing or not an array");
+  if (!Array.isArray(r.risks)) errors.push("risks missing or not an array");
+  if (Array.isArray(r.findings)) {
+    for (const [i, f] of r.findings.entries()) {
+      if (!f || typeof f.title !== "string") errors.push(`finding[${i}] missing title`);
+      const refs = f?.evidence_refs;
+      if (refs && refs.some((x) => typeof x !== "string" || x.includes("\n"))) {
+        errors.push(`finding[${i}] evidence_refs must be ref tokens, not bodies`);
+      }
+    }
+  }
+  if (r.assumptions !== void 0) {
+    if (!Array.isArray(r.assumptions)) {
+      errors.push("assumptions must be an array of {statement, basis, epistemic_state}");
+    } else {
+      for (const [i, a] of r.assumptions.entries()) {
+        errors.push(...validateAssumption(a, `assumptions[${i}]`));
+      }
+    }
+  }
+  if (typeof r.summary === "string" && r.summary.length > MAX_SUMMARY_CHARS) {
+    errors.push(`summary is ${r.summary.length} chars (max ${MAX_SUMMARY_CHARS}) \u2014 the envelope carries a bounded summary; the full result belongs on disk (artifact_paths)`);
+  }
+  if (typeof r.handoff === "string" && r.handoff.length > MAX_RESPONSE_LINE_CHARS) {
+    errors.push(`handoff is ${r.handoff.length} chars (max ${MAX_RESPONSE_LINE_CHARS})`);
+  }
+  for (const [key, arr] of [
+    ["findings", r.findings],
+    ["risks", r.risks],
+    ["artifact_paths", r.artifact_paths]
+  ]) {
+    if (Array.isArray(arr) && arr.length > MAX_RESPONSE_ENTRIES) {
+      errors.push(`${key} carries ${arr.length} entries (max ${MAX_RESPONSE_ENTRIES}) \u2014 an envelope is a handoff, not a transcript`);
+    }
+  }
+  if (Array.isArray(r.risks)) {
+    for (const [i, risk] of r.risks.entries()) {
+      if (typeof risk === "string" && risk.length > MAX_RESPONSE_LINE_CHARS) {
+        errors.push(`risks[${i}] is ${risk.length} chars (max ${MAX_RESPONSE_LINE_CHARS})`);
+      }
+    }
+  }
+  if (Array.isArray(r.findings)) {
+    for (const [i, f] of r.findings.entries()) {
+      if (f && typeof f.title === "string" && f.title.length > MAX_RESPONSE_LINE_CHARS) {
+        errors.push(`finding[${i}] title is ${f.title.length} chars (max ${MAX_RESPONSE_LINE_CHARS})`);
+      }
+    }
+  }
+  if (r.artifact_paths !== void 0) {
+    if (!Array.isArray(r.artifact_paths)) {
+      errors.push("artifact_paths must be an array of path ref tokens");
+    } else {
+      for (const [i, p] of r.artifact_paths.entries()) {
+        if (typeof p !== "string" || p.includes("\n") || p.length > MAX_ARTIFACT_REF_CHARS) {
+          errors.push(`artifact_paths[${i}] must be a single-line path ref \u2264 ${MAX_ARTIFACT_REF_CHARS} chars`);
+        }
+      }
+    }
+  }
+  try {
+    const serialized = JSON.stringify(input);
+    if (serialized.length > MAX_ENVELOPE_CHARS) {
+      errors.push(`envelope serializes to ${serialized.length} chars (max ${MAX_ENVELOPE_CHARS}) \u2014 move content to disk and reference it via artifact_paths`);
+    }
+  } catch {
+    errors.push("envelope is not JSON-serializable");
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/scripts/hooks/subagent_ledger_hook.ts
 var EXIT_ALLOW18 = 0;
+function isObject7(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var LEDGER_DIR = path61.join("agents", "runtime", "state", "subagent-ledger");
+var OPEN_SUBDIR = "open";
+var OPEN_RECORD_TTL_MS = 24 * 60 * 60 * 1e3;
+function refFor(agentId) {
+  return crypto6.createHash("sha256").update(agentId, "utf8").digest("hex").slice(0, 12);
+}
+function unwrapPayload2(envelope) {
+  const inner = envelope["payload"];
+  return isObject7(inner) ? inner : envelope;
+}
+function str4(payload, ...keys) {
+  for (const k of keys) {
+    const v = payload[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return null;
+}
+function extractParentId(payload, ownId) {
+  const explicit = str4(payload, "parent_agent_id", "parentAgentId");
+  if (explicit) return explicit;
+  const session = payload["session"];
+  if (isObject7(session)) {
+    const sessionAgent = str4(session, "agent_id", "agentId");
+    if (sessionAgent && sessionAgent !== ownId) return sessionAgent;
+  }
+  return null;
+}
+function classifyEnvelope(message) {
+  if (message === null || !message.trim()) return { verdict: "absent", error_count: 0 };
+  const candidates = _jsonObjectCandidates(message);
+  if (candidates.length === 0) return { verdict: "absent", error_count: 0 };
+  let best = null;
+  for (const candidate of candidates) {
+    const result = validateResponse(candidate);
+    if (result.valid) return { verdict: "ok", error_count: 0 };
+    if (best === null) best = { verdict: "fail", error_count: result.errors.length };
+  }
+  return best ?? { verdict: "absent", error_count: 0 };
+}
+function _jsonObjectCandidates(message) {
+  const texts = [];
+  for (const match of message.matchAll(/^[ \t]*```[ \t]*(?:json)?[ \t]*\r?\n([\s\S]*?)^[ \t]*```/gm)) {
+    if (match[1]) texts.push(match[1]);
+  }
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < message.length; i++) {
+    const ch = message[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (ch === "}") {
+      if (depth > 0) {
+        depth--;
+        if (depth === 0 && start !== -1) {
+          texts.push(message.slice(start, i + 1));
+          start = -1;
+        }
+      }
+    }
+  }
+  const out = [];
+  for (const text of texts) {
+    try {
+      const parsed = JSON.parse(text.trim());
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+function openDir(root) {
+  return path61.join(root, LEDGER_DIR, OPEN_SUBDIR);
+}
+function openFile(root, ref) {
+  return path61.join(openDir(root), `${ref}.json`);
+}
+var DEPTH_BASES = /* @__PURE__ */ new Set(["observed", "asserted-parent", "assumed-root"]);
+function _asOpenRecord(value, expectedRef) {
+  if (!isObject7(value)) return null;
+  const ref = value["ref"];
+  if (typeof ref !== "string" || ref !== expectedRef) return null;
+  if (typeof value["started_at"] !== "string") return null;
+  if (typeof value["depth"] !== "number" || !Number.isFinite(value["depth"])) return null;
+  if (typeof value["depth_basis"] !== "string" || !DEPTH_BASES.has(value["depth_basis"])) return null;
+  const agentType = value["agent_type"];
+  const parentRef = value["parent_ref"];
+  const sessionId2 = value["session_id"];
+  return {
+    ref,
+    agent_type: typeof agentType === "string" ? agentType : null,
+    started_at: value["started_at"],
+    parent_ref: typeof parentRef === "string" ? parentRef : null,
+    depth: value["depth"],
+    depth_basis: value["depth_basis"],
+    session_id: typeof sessionId2 === "string" ? sessionId2 : null
+  };
+}
+function readOpenRecords(root) {
+  const out = /* @__PURE__ */ new Map();
+  let names;
+  try {
+    names = fs60.readdirSync(openDir(root));
+  } catch {
+    return out;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const expectedRef = name.slice(0, -".json".length);
+    try {
+      const raw = fs60.readFileSync(path61.join(openDir(root), name), "utf8");
+      const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
+      if (rec) out.set(rec.ref, rec);
+    } catch {
+    }
+  }
+  return out;
+}
+function resolveDepth(parentRef, open) {
+  if (parentRef === null) return { depth: 1, depth_basis: "assumed-root" };
+  const parent = open.get(parentRef);
+  if (!parent) return { depth: 2, depth_basis: "asserted-parent" };
+  return { depth: parent.depth + 1, depth_basis: "observed" };
+}
+function ledgerFileFor(root, ts) {
+  return path61.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
+}
+function appendLedgerLine(root, ts, line) {
+  if (is_replay_mode()) return;
+  const file = ledgerFileFor(root, ts);
+  fs60.mkdirSync(path61.dirname(file), { recursive: true });
+  fs60.appendFileSync(file, `${JSON.stringify(line)}
+`, "utf8");
+}
+var WALL_CLOCK_ARMS_MS = [
+  { label: "5m", ms: 5 * 60 * 1e3 },
+  { label: "15m", ms: 15 * 60 * 1e3 },
+  { label: "30m", ms: 30 * 60 * 1e3 },
+  { label: "2h", ms: 2 * 60 * 60 * 1e3 }
+];
+function armsExceeded(elapsedMs) {
+  if (elapsedMs === null || !Number.isFinite(elapsedMs)) return [];
+  return WALL_CLOCK_ARMS_MS.filter((a) => elapsedMs >= a.ms).map((a) => a.label);
+}
+function openRecordStats(root, nowMs = Date.now()) {
+  const ledgerPresent = fs60.existsSync(path61.join(root, LEDGER_DIR));
+  const open = readOpenRecords(root);
+  let maxDepth = 0;
+  let counted = 0;
+  let stale = 0;
+  for (const rec of open.values()) {
+    const started = Date.parse(rec.started_at);
+    const isStale2 = Number.isFinite(started) && nowMs - started >= OPEN_RECORD_TTL_MS;
+    if (isStale2) {
+      stale++;
+      continue;
+    }
+    counted++;
+    if (rec.depth > maxDepth) maxDepth = rec.depth;
+  }
+  return {
+    open_count: counted,
+    max_depth: maxDepth,
+    stale_excluded: stale,
+    ledger_present: ledgerPresent
+  };
+}
+function writeOpenRecord(root, rec) {
+  atomic_write_json(openFile(root, rec.ref), rec);
+}
+function removeOpenRecord(root, ref) {
+  if (is_replay_mode()) return;
+  try {
+    fs60.unlinkSync(openFile(root, ref));
+  } catch {
+  }
+}
+function countOpen(root) {
+  try {
+    return fs60.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+  } catch {
+    return 0;
+  }
+}
+function reapStaleOpenRecords(root, nowIso) {
+  const now = Date.parse(nowIso);
+  if (!Number.isFinite(now)) return 0;
+  let reaped = 0;
+  for (const rec of readOpenRecords(root).values()) {
+    const started = Date.parse(rec.started_at);
+    if (!Number.isFinite(started) || now - started < OPEN_RECORD_TTL_MS) continue;
+    removeOpenRecord(root, rec.ref);
+    reaped++;
+    appendLedgerLine(root, nowIso, {
+      event: "subagent_reaped",
+      ts: nowIso,
+      ref: rec.ref,
+      agent_type: rec.agent_type,
+      depth: rec.depth,
+      depth_basis: rec.depth_basis,
+      // R2 round 2, finding 5: the arm list is NOT repeated here. A reap
+      // fires only past OPEN_RECORD_TTL_MS (24 h), which exceeds every
+      // arm (largest: 2 h), so `stop_loss_arms_exceeded` would be a
+      // constant on this line — a field that cannot vary answers no
+      // question. `age_ms` carries strictly more information and is what
+      // a reader should aggregate over.
+      age_ms: now - started,
+      reason: "open record exceeded OPEN_RECORD_TTL_MS without a stop"
+    });
+  }
+  return reaped;
+}
+function appendUnidentified(root, event, nowIso, payload) {
+  appendLedgerLine(root, nowIso, {
+    event,
+    ts: nowIso,
+    ref: null,
+    unidentified: true,
+    // The agent TYPE is an id-shaped enum and may still be present; it is
+    // the only thing salvageable from a payload with no id.
+    agent_type: str4(payload, "agent_type", "agentType", "subagent_type", "subagentType"),
+    reason: "payload carried no agent id \u2014 nothing to correlate start with stop"
+  });
+}
+function handleStart(root, payload, nowIso, sessionId2) {
+  const agentId = str4(payload, "agent_id", "agentId");
+  if (agentId === null) {
+    appendUnidentified(root, "subagent_start", nowIso, payload);
+    return;
+  }
+  const ref = refFor(agentId);
+  const parentId = extractParentId(payload, agentId);
+  const parentRef = parentId ? refFor(parentId) : null;
+  const { depth, depth_basis } = resolveDepth(parentRef, readOpenRecords(root));
+  const rec = {
+    ref,
+    agent_type: str4(payload, "agent_type", "agentType", "subagent_type", "subagentType"),
+    started_at: nowIso,
+    parent_ref: parentRef,
+    depth,
+    depth_basis,
+    session_id: sessionId2
+  };
+  writeOpenRecord(root, rec);
+  appendLedgerLine(root, nowIso, {
+    event: "subagent_start",
+    ts: nowIso,
+    ref,
+    agent_type: rec.agent_type,
+    parent_ref: parentRef,
+    depth,
+    depth_basis,
+    concurrent_open: countOpen(root)
+  });
+}
+function handleStop(root, payload, nowIso) {
+  const agentId = str4(payload, "agent_id", "agentId");
+  if (agentId === null) {
+    appendUnidentified(root, "subagent_stop", nowIso, payload);
+    return;
+  }
+  const ref = refFor(agentId);
+  const rec = readOpenRecords(root).get(ref) ?? null;
+  let durationMs = null;
+  if (rec) {
+    const started = Date.parse(rec.started_at);
+    if (Number.isFinite(started)) durationMs = Math.max(0, Date.parse(nowIso) - started);
+  }
+  const parse = classifyEnvelope(str4(payload, "last_assistant_message", "lastAssistantMessage"));
+  removeOpenRecord(root, ref);
+  appendLedgerLine(root, nowIso, {
+    event: "subagent_stop",
+    ts: nowIso,
+    ref,
+    agent_type: rec?.agent_type ?? str4(payload, "agent_type", "agentType", "subagent_type", "subagentType"),
+    depth: rec?.depth ?? null,
+    depth_basis: rec?.depth_basis ?? null,
+    // `null` = the matching start was never seen. That is a finding about
+    // the instrument's own coverage and is recorded as such, not as 0.
+    duration_ms: durationMs,
+    // Phase 3 Step 3, shadow: which wall-clock arms this dispatch would
+    // have tripped. Recorded, never acted on.
+    stop_loss_arms_exceeded: armsExceeded(durationMs),
+    start_seen: rec !== null,
+    envelope_parse: parse.verdict,
+    envelope_error_count: parse.error_count,
+    concurrent_open: countOpen(root)
+  });
+}
+function processEnvelope2(envelope, consumerRoot) {
+  try {
+    if (!isObject7(envelope)) return EXIT_ALLOW18;
+    const event = envelope["event"];
+    if (event !== "subagent_start" && event !== "subagent_stop") return EXIT_ALLOW18;
+    const payload = unwrapPayload2(envelope);
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionId2 = str4(payload, "session_id", "sessionId") ?? str4(envelope, "session_id", "sessionId");
+    reapStaleOpenRecords(consumerRoot, nowIso);
+    if (event === "subagent_start") handleStart(consumerRoot, payload, nowIso, sessionId2);
+    else handleStop(consumerRoot, payload, nowIso);
+  } catch {
+    return EXIT_ALLOW18;
+  }
+  return EXIT_ALLOW18;
+}
+function resolveConsumerRoot(envelope) {
+  if (isObject7(envelope)) {
+    const pr = str4(envelope, "workspace_root", "project_root");
+    if (pr) return pr;
+    const payload = unwrapPayload2(envelope);
+    const cwd = str4(payload, "cwd");
+    if (cwd) return cwd;
+  }
+  return process.cwd();
+}
+function main42() {
+  const raw = readHookStdin();
+  let envelope = {};
+  try {
+    envelope = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return EXIT_ALLOW18;
+  }
+  return processEnvelope2(envelope, resolveConsumerRoot(envelope));
+}
+function _isCliEntry32() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) return false;
+  const argvUrl = pathToFileURL37(path61.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) return true;
+  try {
+    return fs60.realpathSync(fileURLToPath43(import.meta.url)) === fs60.realpathSync(path61.resolve(process.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry32()) process.exit(main42());
+
+// src/scripts/hooks/turn_end_gate_hook.ts
+var EXIT_BLOCK4 = 1;
+var EXIT_ALLOW19 = 0;
 var TRANSCRIPT_READ_MAX_BYTES = 8 * 1024 * 1024;
 function stripFencedBlocks(text) {
   const out = [];
@@ -25820,7 +26269,7 @@ function detectPromissory(reply) {
 }
 function readCiSettled(workspaceRoot2) {
   try {
-    const raw = fs60.readFileSync(path61.join(workspaceRoot2, STATE_FILE3), "utf-8");
+    const raw = fs61.readFileSync(path62.join(workspaceRoot2, STATE_FILE3), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       const ci = decoded["ci_last"];
@@ -25854,7 +26303,7 @@ function detectCompletionClaim(reply, ci) {
 }
 function readLanguagePin(workspaceRoot2) {
   try {
-    const raw = fs60.readFileSync(path61.join(workspaceRoot2, STATE_FILE5), "utf-8");
+    const raw = fs61.readFileSync(path62.join(workspaceRoot2, STATE_FILE5), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       const lang = decoded["language"];
@@ -25903,17 +26352,17 @@ function detectUnverifiedEdit(toolCalls) {
   };
 }
 function stateDir(workspaceRoot2) {
-  return path61.join(workspaceRoot2, "agents", "runtime", "state", "turn-end-gate");
+  return path62.join(workspaceRoot2, "agents", "runtime", "state", "turn-end-gate");
 }
 function sessionStateFile2(workspaceRoot2, sessionKey) {
-  return path61.join(stateDir(workspaceRoot2), `${sessionKey}.json`);
+  return path62.join(stateDir(workspaceRoot2), `${sessionKey}.json`);
 }
 function deriveSessionKey2(sessionId2) {
-  return crypto6.createHash("sha256").update(sessionId2).digest("hex").slice(0, 32);
+  return crypto7.createHash("sha256").update(sessionId2).digest("hex").slice(0, 32);
 }
 function alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal) {
   try {
-    const raw = fs60.readFileSync(sessionStateFile2(workspaceRoot2, sessionKey), "utf-8");
+    const raw = fs61.readFileSync(sessionStateFile2(workspaceRoot2, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -25938,10 +26387,10 @@ function readTranscriptTail(transcriptPath, opts = {}) {
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs60.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs61.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs60.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs61.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
@@ -26014,33 +26463,41 @@ function _messageText(content) {
   }
   return parts.length > 0 ? parts.join("\n") : null;
 }
-function str4(v) {
+function str5(v) {
   return typeof v === "string" ? v : "";
 }
-function main42() {
+function main43() {
   let envelope;
   let payload;
   try {
     [envelope, payload] = unwrap(readHookStdin(), "claude");
   } catch {
-    return EXIT_ALLOW18;
+    return EXIT_ALLOW19;
   }
-  if (payload["stop_hook_active"] === true) return EXIT_ALLOW18;
-  const workspaceRoot2 = str4(envelope["workspace_root"]) || process.cwd();
-  const transcriptPath = str4(
+  if (payload["stop_hook_active"] === true) return EXIT_ALLOW19;
+  const workspaceRoot2 = str5(envelope["workspace_root"]) || process.cwd();
+  let dispatchOpen = false;
+  try {
+    dispatchOpen = openRecordStats(workspaceRoot2).open_count > 0;
+  } catch {
+  }
+  const transcriptPath = str5(
     payload["transcript_path"] ?? payload["transcriptPath"]
   );
   const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
     maxBytes: TRANSCRIPT_READ_MAX_BYTES
   });
-  if (!lastAssistant) return EXIT_ALLOW18;
+  if (!lastAssistant) return EXIT_ALLOW19;
   const sessionKey = deriveSessionKey2(
-    str4(envelope["session_id"]) || "unknown-session"
+    str5(envelope["session_id"]) || "unknown-session"
   );
-  if (alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal)) return EXIT_ALLOW18;
+  if (alreadyRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal)) return EXIT_ALLOW19;
   const findings = [];
   for (const f of [
-    detectPromissory(lastAssistant),
+    // A and D are the completion-adjacent pair a pending dispatch excuses
+    // (Phase 3 Step 2, narrowed by R2 round 2 finding 2). B and C are not
+    // excused by anything about a dispatch and run unchanged.
+    dispatchOpen ? null : detectPromissory(lastAssistant),
     detectLanguage(lastAssistant, readLanguagePin(workspaceRoot2)),
     detectUnverifiedEdit(toolCalls),
     // Round 7 § Phase 1 — detector D, in the same unconditional list as the
@@ -26050,11 +26507,11 @@ function main42() {
     // 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.
-    detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot2))
+    dispatchOpen ? null : detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot2))
   ]) {
     if (f) findings.push(f);
   }
-  if (findings.length === 0) return EXIT_ALLOW18;
+  if (findings.length === 0) return EXIT_ALLOW19;
   markRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal, findings[0].detector);
   const lines = findings.map(
     (f) => `  \xB7 ${f.detector}: ${f.reason}
@@ -26069,36 +26526,36 @@ ${lines.join("\n")}
   );
   return EXIT_BLOCK4;
 }
-function _isCliEntry32() {
+function _isCliEntry33() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL37(path61.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL38(path62.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs60.realpathSync(fileURLToPath43(import.meta.url));
-    const argv = fs60.realpathSync(path61.resolve(process.argv[1]));
+    const here = fs61.realpathSync(fileURLToPath44(import.meta.url));
+    const argv = fs61.realpathSync(path62.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry32()) {
-  process.exit(main42());
+if (_isCliEntry33()) {
+  process.exit(main43());
 }
 
 // src/scripts/hooks/edit_shape_hook.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import * as crypto7 from "node:crypto";
-import * as fs61 from "node:fs";
-import * as path62 from "node:path";
-import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL38 } from "node:url";
-var EXIT_ALLOW19 = 0;
+import * as crypto8 from "node:crypto";
+import * as fs62 from "node:fs";
+import * as path63 from "node:path";
+import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL39 } from "node:url";
+var EXIT_ALLOW20 = 0;
 var EXIT_WARN11 = 2;
 var MIN_FILE_LINES = 50;
 var MAX_DIFF_RATIO = 0.2;
@@ -26114,10 +26571,10 @@ var EXEMPT_PATH_PATTERNS = [
   /(^|\/)agents\/runtime\//i
   // agents/runtime/**
 ];
-function isObject7(v) {
+function isObject8(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function str5(v) {
+function str6(v) {
   return typeof v === "string" ? v : "";
 }
 function isExemptPath(filePath) {
@@ -26150,7 +26607,7 @@ function effectiveDiffLines(cwd, relPath) {
 }
 function fileLineCount(absPath) {
   try {
-    const text = fs61.readFileSync(absPath, "utf8");
+    const text = fs62.readFileSync(absPath, "utf8");
     if (text.length === 0) return 0;
     return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
   } catch {
@@ -26162,16 +26619,16 @@ function buildAdvisoryLine2(fileLines, diffLines) {
   return `this Write replaced ${fileLines} lines for an effective diff of ~${pct}% (${diffLines} changed lines) \u2014 a targeted Edit pays for the diff, not the file.`;
 }
 function deriveSessionKey3(envelope, payload) {
-  const raw = str5(envelope["session_id"]) || str5(payload["session_id"] ?? payload["sessionId"]);
+  const raw = str6(envelope["session_id"]) || str6(payload["session_id"] ?? payload["sessionId"]);
   const material = raw || "unknown-session";
-  return crypto7.createHash("sha256").update(material).digest("hex");
+  return crypto8.createHash("sha256").update(material).digest("hex");
 }
 function sessionStateFile3(workspaceRoot2, sessionKey) {
-  return path62.join(workspaceRoot2, "agents", "runtime", "state", "edit-shape", `${sessionKey}.json`);
+  return path63.join(workspaceRoot2, "agents", "runtime", "state", "edit-shape", `${sessionKey}.json`);
 }
 function hasFiredThisSession2(workspaceRoot2, sessionKey) {
   try {
-    return fs61.existsSync(sessionStateFile3(workspaceRoot2, sessionKey));
+    return fs62.existsSync(sessionStateFile3(workspaceRoot2, sessionKey));
   } catch {
     return false;
   }
@@ -26185,33 +26642,33 @@ function markFiredThisSession2(workspaceRoot2, sessionKey) {
   }
 }
 function extractToolName2(payload) {
-  return str5(payload["tool_name"] ?? payload["toolName"] ?? payload["tool"]);
+  return str6(payload["tool_name"] ?? payload["toolName"] ?? payload["tool"]);
 }
 function extractFilePath(payload) {
   const ti = payload["tool_input"] ?? payload["toolInput"] ?? payload["input"];
-  if (!isObject7(ti)) return "";
-  return str5(ti["file_path"] ?? ti["path"] ?? ti["filePath"]);
+  if (!isObject8(ti)) return "";
+  return str6(ti["file_path"] ?? ti["path"] ?? ti["filePath"]);
 }
-function main43() {
+function main44() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
-    const event = str5(envelope["event"]);
-    if (event !== "" && event !== "post_tool_use") return EXIT_ALLOW19;
+    const event = str6(envelope["event"]);
+    if (event !== "" && event !== "post_tool_use") return EXIT_ALLOW20;
     const toolName = extractToolName2(payload);
-    if (toolName !== "Write") return EXIT_ALLOW19;
+    if (toolName !== "Write") return EXIT_ALLOW20;
     const filePath = extractFilePath(payload);
-    if (!filePath) return EXIT_ALLOW19;
-    const workspaceRoot2 = str5(envelope["workspace_root"]).trim() || process.cwd();
-    const absPath = path62.isAbsolute(filePath) ? filePath : path62.resolve(workspaceRoot2, filePath);
-    const relPath = path62.relative(workspaceRoot2, absPath);
-    if (isExemptPath(relPath) || isExemptPath(absPath)) return EXIT_ALLOW19;
+    if (!filePath) return EXIT_ALLOW20;
+    const workspaceRoot2 = str6(envelope["workspace_root"]).trim() || process.cwd();
+    const absPath = path63.isAbsolute(filePath) ? filePath : path63.resolve(workspaceRoot2, filePath);
+    const relPath = path63.relative(workspaceRoot2, absPath);
+    if (isExemptPath(relPath) || isExemptPath(absPath)) return EXIT_ALLOW20;
     const fileLines = fileLineCount(absPath);
-    if (fileLines < MIN_FILE_LINES) return EXIT_ALLOW19;
+    if (fileLines < MIN_FILE_LINES) return EXIT_ALLOW20;
     const diffLines = effectiveDiffLines(workspaceRoot2, relPath.startsWith("..") ? absPath : relPath);
-    if (diffLines === 0) return EXIT_ALLOW19;
-    if (diffLines / fileLines > MAX_DIFF_RATIO) return EXIT_ALLOW19;
+    if (diffLines === 0) return EXIT_ALLOW20;
+    if (diffLines / fileLines > MAX_DIFF_RATIO) return EXIT_ALLOW20;
     const sessionKey = deriveSessionKey3(envelope, payload);
-    if (hasFiredThisSession2(workspaceRoot2, sessionKey)) return EXIT_ALLOW19;
+    if (hasFiredThisSession2(workspaceRoot2, sessionKey)) return EXIT_ALLOW20;
     markFiredThisSession2(workspaceRoot2, sessionKey);
     process.stdout.write(
       `${JSON.stringify({
@@ -26223,38 +26680,38 @@ function main43() {
     );
     return EXIT_WARN11;
   } catch {
-    return EXIT_ALLOW19;
+    return EXIT_ALLOW20;
   }
 }
-function _isCliEntry33() {
+function _isCliEntry34() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL38(path62.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL39(path63.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs61.realpathSync(fileURLToPath44(import.meta.url));
-    const argv = fs61.realpathSync(path62.resolve(process.argv[1]));
+    const here = fs62.realpathSync(fileURLToPath45(import.meta.url));
+    const argv = fs62.realpathSync(path63.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry33()) {
-  process.exit(main43());
+if (_isCliEntry34()) {
+  process.exit(main44());
 }
 
 // src/scripts/hooks/reread_guard_hook.ts
-import * as crypto8 from "node:crypto";
-import * as fs62 from "node:fs";
-import * as path63 from "node:path";
-import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL39 } from "node:url";
-var EXIT_ALLOW20 = 0;
+import * as crypto9 from "node:crypto";
+import * as fs63 from "node:fs";
+import * as path64 from "node:path";
+import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL40 } from "node:url";
+var EXIT_ALLOW21 = 0;
 var EXIT_WARN12 = 2;
 var EXEMPT_PATH_PATTERNS2 = [
   /(^|\/)dist\//i,
@@ -26270,10 +26727,10 @@ var EXEMPT_PATH_PATTERNS2 = [
 ];
 var READ_TOOLS = /* @__PURE__ */ new Set(["Read"]);
 var WRITE_TOOLS2 = /* @__PURE__ */ new Set(["Edit", "Write"]);
-function isObject8(v) {
+function isObject9(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function str6(v) {
+function str7(v) {
   return typeof v === "string" ? v : "";
 }
 function isExemptPath2(filePath) {
@@ -26284,21 +26741,21 @@ function emptyLedger() {
   return { reads: {}, writes: {}, fired: {} };
 }
 function deriveSessionKey4(envelope, payload) {
-  const raw = str6(envelope["session_id"]) || str6(payload["session_id"] ?? payload["sessionId"]);
+  const raw = str7(envelope["session_id"]) || str7(payload["session_id"] ?? payload["sessionId"]);
   const material = raw || "unknown-session";
-  return crypto8.createHash("sha256").update(material).digest("hex");
+  return crypto9.createHash("sha256").update(material).digest("hex");
 }
 function ledgerFile(workspaceRoot2, sessionKey) {
-  return path63.join(workspaceRoot2, "agents", "runtime", "state", "reread-guard", `${sessionKey}.json`);
+  return path64.join(workspaceRoot2, "agents", "runtime", "state", "reread-guard", `${sessionKey}.json`);
 }
 function readLedger(workspaceRoot2, sessionKey) {
   try {
-    const parsed = JSON.parse(fs62.readFileSync(ledgerFile(workspaceRoot2, sessionKey), "utf8"));
-    if (!isObject8(parsed)) return emptyLedger();
+    const parsed = JSON.parse(fs63.readFileSync(ledgerFile(workspaceRoot2, sessionKey), "utf8"));
+    if (!isObject9(parsed)) return emptyLedger();
     return {
-      reads: isObject8(parsed["reads"]) ? parsed["reads"] : {},
-      writes: isObject8(parsed["writes"]) ? parsed["writes"] : {},
-      fired: isObject8(parsed["fired"]) ? parsed["fired"] : {}
+      reads: isObject9(parsed["reads"]) ? parsed["reads"] : {},
+      writes: isObject9(parsed["writes"]) ? parsed["writes"] : {},
+      fired: isObject9(parsed["fired"]) ? parsed["fired"] : {}
     };
   } catch {
     return emptyLedger();
@@ -26311,14 +26768,14 @@ function writeLedger(workspaceRoot2, sessionKey, ledger) {
   }
 }
 function extractToolName3(payload) {
-  return str6(payload["tool_name"] ?? payload["toolName"] ?? payload["tool"]);
+  return str7(payload["tool_name"] ?? payload["toolName"] ?? payload["tool"]);
 }
 function extractToolInput2(payload) {
   const ti = payload["tool_input"] ?? payload["toolInput"] ?? payload["input"];
-  return isObject8(ti) ? ti : {};
+  return isObject9(ti) ? ti : {};
 }
 function extractFilePath2(toolInput) {
-  return str6(toolInput["file_path"] ?? toolInput["path"] ?? toolInput["filePath"]);
+  return str7(toolInput["file_path"] ?? toolInput["path"] ?? toolInput["filePath"]);
 }
 function isRangedRead(toolInput) {
   for (const key of ["offset", "limit", "start_line", "end_line", "startLine", "endLine"]) {
@@ -26334,41 +26791,41 @@ function buildDuplicateReadLine(relPath, earlierTs) {
 function buildPostEditReadLine(relPath) {
   return `re-read guard: this session just edited ${relPath} \u2014 a full-file re-read re-pays for content you already have; a ranged Read (offset/limit) over the edited hunk is enough to verify the change.`;
 }
-function main44() {
+function main45() {
   try {
     const [envelope, payload] = unwrap(readHookStdin(), "claude");
-    const event = str6(envelope["event"]);
-    if (event !== "" && event !== "pre_tool_use") return EXIT_ALLOW20;
+    const event = str7(envelope["event"]);
+    if (event !== "" && event !== "pre_tool_use") return EXIT_ALLOW21;
     const toolName = extractToolName3(payload);
     const isRead = READ_TOOLS.has(toolName);
     const isWrite = WRITE_TOOLS2.has(toolName);
-    if (!isRead && !isWrite) return EXIT_ALLOW20;
+    if (!isRead && !isWrite) return EXIT_ALLOW21;
     const toolInput = extractToolInput2(payload);
     const filePath = extractFilePath2(toolInput);
-    if (!filePath) return EXIT_ALLOW20;
-    const workspaceRoot2 = str6(envelope["workspace_root"]).trim() || process.cwd();
-    const absPath = path63.isAbsolute(filePath) ? filePath : path63.resolve(workspaceRoot2, filePath);
-    const relPath = path63.relative(workspaceRoot2, absPath);
-    if (isExemptPath2(relPath) || isExemptPath2(absPath)) return EXIT_ALLOW20;
+    if (!filePath) return EXIT_ALLOW21;
+    const workspaceRoot2 = str7(envelope["workspace_root"]).trim() || process.cwd();
+    const absPath = path64.isAbsolute(filePath) ? filePath : path64.resolve(workspaceRoot2, filePath);
+    const relPath = path64.relative(workspaceRoot2, absPath);
+    if (isExemptPath2(relPath) || isExemptPath2(absPath)) return EXIT_ALLOW21;
     const sessionKey = deriveSessionKey4(envelope, payload);
     const ledger = readLedger(workspaceRoot2, sessionKey);
     const key = relPath.startsWith("..") ? absPath : relPath;
     if (isWrite) {
       ledger.writes[key] = Date.now();
       writeLedger(workspaceRoot2, sessionKey, ledger);
-      return EXIT_ALLOW20;
+      return EXIT_ALLOW21;
     }
     if (isRangedRead(toolInput)) {
-      return EXIT_ALLOW20;
+      return EXIT_ALLOW21;
     }
     let mtime;
     let size;
     try {
-      const st = fs62.statSync(absPath);
+      const st = fs63.statSync(absPath);
       mtime = st.mtimeMs;
       size = st.size;
     } catch {
-      return EXIT_ALLOW20;
+      return EXIT_ALLOW21;
     }
     const prior = ledger.reads[key];
     const ownWrite = ledger.writes[key];
@@ -26383,7 +26840,7 @@ function main44() {
     if (ownWrite !== void 0) delete ledger.writes[key];
     if (advisory !== null) ledger.fired[key] = true;
     writeLedger(workspaceRoot2, sessionKey, ledger);
-    if (advisory === null) return EXIT_ALLOW20;
+    if (advisory === null) return EXIT_ALLOW21;
     process.stdout.write(
       `${JSON.stringify({
         decision: "warn",
@@ -26394,37 +26851,37 @@ function main44() {
     );
     return EXIT_WARN12;
   } catch {
-    return EXIT_ALLOW20;
+    return EXIT_ALLOW21;
   }
 }
-function _isCliEntry34() {
+function _isCliEntry35() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL39(path63.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL40(path64.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs62.realpathSync(fileURLToPath45(import.meta.url));
-    const argv = fs62.realpathSync(path63.resolve(process.argv[1]));
+    const here = fs63.realpathSync(fileURLToPath46(import.meta.url));
+    const argv = fs63.realpathSync(path64.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry34()) {
-  process.exit(main44());
+if (_isCliEntry35()) {
+  process.exit(main45());
 }
 
 // src/scripts/hooks/session_eol_hook.ts
-import * as fs64 from "node:fs";
-import * as path66 from "node:path";
+import * as fs65 from "node:fs";
+import * as path67 from "node:path";
 import process11 from "node:process";
-import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL40 } from "node:url";
+import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL41 } from "node:url";
 
 // src/config/recycle-threshold-budget.json
 var recycle_threshold_budget_default = {
@@ -26441,14 +26898,14 @@ var recycle_threshold_budget_default = {
 };
 
 // src/scripts/_lib/session_eol.ts
-import * as crypto9 from "node:crypto";
-import * as fs63 from "node:fs";
-import * as path65 from "node:path";
+import * as crypto10 from "node:crypto";
+import * as fs64 from "node:fs";
+import * as path66 from "node:path";
 
 // src/scripts/_lib/cc_transcript.ts
-import * as path64 from "node:path";
+import * as path65 from "node:path";
 import { homedir as homedir6 } from "node:os";
-var DEFAULT_PROJECTS_ROOT = path64.join(homedir6(), ".claude", "projects");
+var DEFAULT_PROJECTS_ROOT = path65.join(homedir6(), ".claude", "projects");
 function billableInputTokens(u) {
   return u.input_tokens + u.cache_read_input_tokens + u.cache_creation_input_tokens;
 }
@@ -26557,17 +27014,17 @@ function scanEolSlice(text, prior) {
   return next;
 }
 function eolStateDir(workspaceRoot2) {
-  return path65.join(workspaceRoot2, "agents", "runtime", "state", "session-eol");
+  return path66.join(workspaceRoot2, "agents", "runtime", "state", "session-eol");
 }
 function eolStateFile(workspaceRoot2, sessionKey) {
-  return path65.join(eolStateDir(workspaceRoot2), `${sessionKey}.json`);
+  return path66.join(eolStateDir(workspaceRoot2), `${sessionKey}.json`);
 }
 function eolSessionKey(raw) {
-  return crypto9.createHash("sha256").update(raw || "unknown-session").digest("hex");
+  return crypto10.createHash("sha256").update(raw || "unknown-session").digest("hex");
 }
 function readNewCompleteLines(filePath, fromByte) {
   try {
-    const { size } = fs63.statSync(filePath);
+    const { size } = fs64.statSync(filePath);
     if (size < fromByte) {
       return { text: "", nextOffset: 0, truncated: true };
     }
@@ -26576,11 +27033,11 @@ function readNewCompleteLines(filePath, fromByte) {
     }
     const length = size - fromByte;
     const buffer = Buffer.alloc(length);
-    const fd = fs63.openSync(filePath, "r");
+    const fd = fs64.openSync(filePath, "r");
     try {
-      fs63.readSync(fd, buffer, 0, length, fromByte);
+      fs64.readSync(fd, buffer, 0, length, fromByte);
     } finally {
-      fs63.closeSync(fd);
+      fs64.closeSync(fd);
     }
     const lastNewline = buffer.lastIndexOf(10);
     if (lastNewline === -1) {
@@ -26599,19 +27056,19 @@ function readNewCompleteLines(filePath, fromByte) {
 // src/scripts/hooks/session_eol_hook.ts
 var EXIT_WARN13 = 2;
 var THRESHOLD_OVERRIDE_ENV = "AGENT_RECYCLE_THRESHOLD_TOKENS";
-var CONTEXT_FILL_REL = path66.join("agents", "runtime", "state", "context-fill.json");
-function str7(value) {
+var CONTEXT_FILL_REL = path67.join("agents", "runtime", "state", "context-fill.json");
+function str8(value) {
   return typeof value === "string" ? value : "";
 }
 var stateFile3 = eolStateFile;
 function deriveSessionKey5(envelope, payload) {
   return eolSessionKey(
-    str7(envelope["session_id"]) || str7(payload["transcript_path"] ?? payload["transcriptPath"])
+    str8(envelope["session_id"]) || str8(payload["transcript_path"] ?? payload["transcriptPath"])
   );
 }
 function readState3(file) {
   try {
-    const parsed = JSON.parse(fs64.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs65.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,
@@ -26632,10 +27089,10 @@ function readState3(file) {
   };
 }
 function envelopeExists(workspaceRoot2, since = null) {
-  const target = path66.join(workspaceRoot2, RECYCLE_ENVELOPE_REL);
+  const target = path67.join(workspaceRoot2, RECYCLE_ENVELOPE_REL);
   let raw;
   try {
-    raw = fs64.readFileSync(target, "utf-8");
+    raw = fs65.readFileSync(target, "utf-8");
   } catch (exc) {
     return exc?.code !== "ENOENT";
   }
@@ -26649,7 +27106,7 @@ function envelopeExists(workspaceRoot2, since = null) {
   }
 }
 function buildMissingEnvelopeLine(workspaceRoot2) {
-  return `recycle advised earlier, but no envelope exists at ${path66.join(workspaceRoot2, RECYCLE_ENVELOPE_REL)} \u2014 /clear now starts the successor from nothing. Re-run \`agent-config session:recycle\` and check that it prints the absolute path it wrote before clearing.`;
+  return `recycle advised earlier, but no envelope exists at ${path67.join(workspaceRoot2, RECYCLE_ENVELOPE_REL)} \u2014 /clear now starts the successor from nothing. Re-run \`agent-config session:recycle\` and check that it prints the absolute path it wrote before clearing.`;
 }
 function readThresholdTokens() {
   const override = process11.env[THRESHOLD_OVERRIDE_ENV];
@@ -26665,7 +27122,7 @@ function buildAdvisoryLine3(tokens, threshold) {
 }
 function writeContextFill(workspaceRoot2, tokens, threshold, ts) {
   try {
-    atomic_write_json(path66.join(workspaceRoot2, CONTEXT_FILL_REL), {
+    atomic_write_json(path67.join(workspaceRoot2, CONTEXT_FILL_REL), {
       schema_version: 1,
       final_context_tokens: tokens,
       recycle_threshold_tokens: threshold,
@@ -26675,7 +27132,7 @@ function writeContextFill(workspaceRoot2, tokens, threshold, ts) {
   } catch {
   }
 }
-function main45() {
+function main46() {
   const [envelope, payload] = unwrap(readHookStdin(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
@@ -26685,7 +27142,7 @@ function main45() {
     return 0;
   }
   const workspaceRoot2 = String(envelope["workspace_root"] ?? "").trim() || process11.cwd();
-  const transcriptPath = str7(
+  const transcriptPath = str8(
     payload["transcript_path"] ?? payload["transcriptPath"]
   ).trim();
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath)) {
@@ -26747,29 +27204,119 @@ function main45() {
   }
   return 0;
 }
-function _isCliEntry35() {
+function _isCliEntry36() {
   if (true) {
     return false;
   }
   if (process11.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL40(path66.resolve(process11.argv[1])).href;
+  const argvUrl = pathToFileURL41(path67.resolve(process11.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs64.realpathSync(fileURLToPath46(import.meta.url));
-    const argv = fs64.realpathSync(path66.resolve(process11.argv[1]));
+    const here = fs65.realpathSync(fileURLToPath47(import.meta.url));
+    const argv = fs65.realpathSync(path67.resolve(process11.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-if (_isCliEntry35()) {
-  process11.exit(main45());
+if (_isCliEntry36()) {
+  process11.exit(main46());
 }
 
+// src/scripts/hooks/spawn_guard_shadow_hook.ts
+import * as fs66 from "node:fs";
+import * as path68 from "node:path";
+import { fileURLToPath as fileURLToPath48, pathToFileURL as pathToFileURL42 } from "node:url";
+var EXIT_ALLOW22 = 0;
+function isObject10(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var DISPATCH_TOOL_NAMES2 = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var CANDIDATES = [
+  { label: "n2m4", max_depth: 2, max_concurrent: 4 },
+  { label: "n3m6", max_depth: 3, max_concurrent: 6 },
+  { label: "n4m8", max_depth: 4, max_concurrent: 8 }
+];
+function evaluateCandidates(depthEstimate, concurrentOpen) {
+  void depthEstimate;
+  return CANDIDATES.map((c) => {
+    const on = [];
+    if (concurrentOpen >= c.max_concurrent) on.push("concurrent");
+    return { label: c.label, would_deny: on.length > 0, on };
+  });
+}
+function unwrapPayload3(envelope) {
+  const inner = envelope["payload"];
+  return isObject10(inner) ? inner : envelope;
+}
+function extractToolName4(payload) {
+  const v = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
+  return typeof v === "string" && v ? v : null;
+}
+function processEnvelope3(envelope, consumerRoot) {
+  try {
+    if (!isObject10(envelope)) return EXIT_ALLOW22;
+    const payload = unwrapPayload3(envelope);
+    const toolName = extractToolName4(payload);
+    if (toolName === null || !DISPATCH_TOOL_NAMES2.has(toolName)) return EXIT_ALLOW22;
+    const stats = openRecordStats(consumerRoot);
+    const depthEstimate = stats.max_depth + 1;
+    const verdicts = evaluateCandidates(depthEstimate, stats.open_count);
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    appendLedgerLine(consumerRoot, nowIso, {
+      event: "spawn_guard_shadow",
+      ts: nowIso,
+      tool: toolName,
+      concurrent_open: stats.open_count,
+      depth_estimate: depthEstimate,
+      depth_estimate_basis: "deepest-open-record-plus-one",
+      // R2 round 2, finding 3: the estimate is >= 2 whenever anything is
+      // open, nesting or not, so it must not reach a derivation. It rides
+      // as context with the flag that says so.
+      depth_usable_for_derivation: false,
+      // R2 round 2, finding 4: without these, a quiet estate, a ledger
+      // this hook cannot see, and a root mismatch all emit byte-identical
+      // records — the instrument-goes-quiet failure one layer up from the
+      // one the ledger already fixed for itself.
+      ledger_present: stats.ledger_present,
+      stale_open_excluded: stats.stale_excluded,
+      candidates: verdicts.map((v) => ({ label: v.label, would_deny: v.would_deny, on: v.on })),
+      // Shadow posture is a property of this file, not of a setting —
+      // there is no code path here that can deny.
+      posture: "shadow"
+    });
+  } catch {
+    return EXIT_ALLOW22;
+  }
+  return EXIT_ALLOW22;
+}
+function main47() {
+  const raw = readHookStdin();
+  let envelope = {};
+  try {
+    envelope = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return EXIT_ALLOW22;
+  }
+  return processEnvelope3(envelope, resolveConsumerRoot(envelope));
+}
+function _isCliEntry37() {
+  if (true) return false;
+  if (process.argv[1] === void 0) return false;
+  const argvUrl = pathToFileURL42(path68.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) return true;
+  try {
+    return fs66.realpathSync(fileURLToPath48(import.meta.url)) === fs66.realpathSync(path68.resolve(process.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry37()) process.exit(main47());
+
 // src/scripts/hooks/concern_registry.ts
 var CONCERN_REGISTRY = {
   "src/scripts/chat_history.ts": main6,
@@ -26806,10 +27353,12 @@ var CONCERN_REGISTRY = {
   "src/scripts/hooks/orchestration_record_hook.ts": main39,
   "src/scripts/hooks/delegation_nudge_hook.ts": main40,
   "src/scripts/hooks/end_review_nudge_hook.ts": main41,
-  "src/scripts/hooks/turn_end_gate_hook.ts": main42,
-  "src/scripts/hooks/edit_shape_hook.ts": main43,
-  "src/scripts/hooks/reread_guard_hook.ts": main44,
-  "src/scripts/hooks/session_eol_hook.ts": main45
+  "src/scripts/hooks/turn_end_gate_hook.ts": main43,
+  "src/scripts/hooks/edit_shape_hook.ts": main44,
+  "src/scripts/hooks/reread_guard_hook.ts": main45,
+  "src/scripts/hooks/session_eol_hook.ts": main46,
+  "src/scripts/hooks/subagent_ledger_hook.ts": main42,
+  "src/scripts/hooks/spawn_guard_shadow_hook.ts": main47
 };
 
 // src/scripts/hooks/host_semantics.ts
@@ -26821,7 +27370,9 @@ var CLAUDE_HOOK_EVENT_NAME = {
   session_start: "SessionStart",
   session_end: "SessionEnd",
   stop: "Stop",
-  pre_compact: "PreCompact"
+  pre_compact: "PreCompact",
+  subagent_start: "SubagentStart",
+  subagent_stop: "SubagentStop"
 };
 var CLAUDE_BLOCK_CAPABLE_EVENTS = /* @__PURE__ */ new Set([
   "pre_tool_use",
@@ -26863,12 +27414,12 @@ function emitFor(platform, event, severity, reasons, legacyExit) {
 
 // src/scripts/hooks/dispatch_hook.ts
 var _IN_BUNDLE = true;
-var REPO_ROOT = path67.resolve(
-  path67.dirname(fileURLToPath47(import.meta.url)),
+var REPO_ROOT = path69.resolve(
+  path69.dirname(fileURLToPath49(import.meta.url)),
   ..._IN_BUNDLE ? ["..", ".."] : ["..", "..", ".."]
 );
-var MANIFEST_PATH = path67.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
-var EXIT_ALLOW21 = 0;
+var MANIFEST_PATH = path69.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
+var EXIT_ALLOW23 = 0;
 var EXIT_BLOCK5 = 1;
 var EXIT_WARN14 = 2;
 var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
@@ -26879,10 +27430,12 @@ var EVENT_VOCABULARY = /* @__PURE__ */ new Set([
   "post_tool_use",
   "stop",
   "pre_compact",
-  "agent_error"
+  "agent_error",
+  "subagent_start",
+  "subagent_stop"
 ]);
 var _SEVERITY_BY_EXIT = {
-  [EXIT_ALLOW21]: "allow",
+  [EXIT_ALLOW23]: "allow",
   [EXIT_BLOCK5]: "block",
   [EXIT_WARN14]: "warn"
 };
@@ -26919,7 +27472,7 @@ function _parse_concern_stdout(stdout_text) {
   return _isObject14(parsed) ? parsed : { _raw: parsed };
 }
 function _load_yaml3(p) {
-  const text = fs65.readFileSync(p, "utf-8");
+  const text = fs67.readFileSync(p, "utf-8");
   const data = (0, import_yaml6.parse)(text, { version: "1.1" });
   return _isObject14(data) ? data : {};
 }
@@ -27076,7 +27629,7 @@ function _maybe_capture_payload(args, payload_text) {
   }
   try {
     const target = _expanduser3(capture_dir);
-    fs65.mkdirSync(target, { recursive: true });
+    fs67.mkdirSync(target, { recursive: true });
     let payload;
     try {
       payload = payload_text.trim() ? JSON.parse(payload_text) : {};
@@ -27093,8 +27646,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`;
-    fs65.writeFileSync(
-      path67.join(target, fname),
+    fs67.writeFileSync(
+      path69.join(target, fname),
       _py_json_dumps2(record, 2) + "\n",
       { encoding: "utf-8" }
     );
@@ -27105,7 +27658,7 @@ function _maybe_capture_payload(args, payload_text) {
 function _expanduser3(p) {
   if (p === "~" || p.startsWith("~/")) {
     const home = process.env["HOME"] || process.env["USERPROFILE"] || "";
-    return path67.join(home, p.slice(1));
+    return path69.join(home, p.slice(1));
   }
   return p;
 }
@@ -27137,25 +27690,25 @@ function _resolve_tsx_invocation2(scriptPath, scriptArgs) {
   const walkUp = (start) => {
     let dir = start;
     for (; ; ) {
-      const candidate = path67.join(dir, "node_modules", ".bin", binName);
+      const candidate = path69.join(dir, "node_modules", ".bin", binName);
       if (_isFile7(candidate)) {
         return candidate;
       }
-      const parent = path67.dirname(dir);
+      const parent = path69.dirname(dir);
       if (parent === dir) {
         return null;
       }
       dir = parent;
     }
   };
-  const tsx = walkUp(path67.dirname(scriptPath)) ?? walkUp(path67.dirname(fileURLToPath47(import.meta.url)));
+  const tsx = walkUp(path69.dirname(scriptPath)) ?? walkUp(path69.dirname(fileURLToPath49(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 = path67.join(REPO_ROOT, String(concern["script"]));
+  const scriptAbs = path69.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());
@@ -27232,7 +27785,7 @@ function _run_concern(concern, envelope) {
       return _run_concern_inproc(inproc, concern, envelope);
     }
   }
-  const script = path67.join(REPO_ROOT, String(concern["script"]));
+  const script = path69.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"));
@@ -27289,7 +27842,7 @@ function _run_concern(concern, envelope) {
 }
 function _isFile7(p) {
   try {
-    return fs65.statSync(p).isFile();
+    return fs67.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -27304,17 +27857,17 @@ function _reduce(rcs) {
   if (rcs.some((rc) => rc === EXIT_WARN14)) {
     return EXIT_WARN14;
   }
-  return EXIT_ALLOW21;
+  return EXIT_ALLOW23;
 }
 function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
   if (is_replay_mode()) {
     return;
   }
   const workspace = String(envelope["workspace_root"] || process.cwd());
-  const state_root = path67.join(workspace, "agents", "runtime", "state");
+  const state_root = path69.join(workspace, "agents", "runtime", "state");
   const fb_dir = feedback_dir(state_root, session_id);
   try {
-    fs65.mkdirSync(fb_dir, { recursive: true });
+    fs67.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}
@@ -27322,7 +27875,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     return;
   }
   for (const entry of entries) {
-    const target = path67.join(fb_dir, `${entry["concern"]}.json`);
+    const target = path69.join(fb_dir, `${entry["concern"]}.json`);
     try {
       atomic_write_json(target, entry);
     } catch (exc) {
@@ -27362,7 +27915,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     })
   };
   try {
-    atomic_write_json(path67.join(fb_dir, "summary.json"), summary);
+    atomic_write_json(path69.join(fb_dir, "summary.json"), summary);
   } catch (exc) {
     const msg = exc instanceof Error ? exc.message : String(exc);
     process.stderr.write(`dispatch_hook: summary write failed: ${msg}
@@ -27377,12 +27930,12 @@ function _record_rule_trips(envelope, entries) {
   if (tripped.length === 0) return;
   try {
     const workspace = String(envelope["workspace_root"] || process.cwd());
-    const state_dir = path67.join(workspace, "agents", "runtime", "state");
-    const target = path67.join(state_dir, "rule-trips.json");
-    fs65.mkdirSync(state_dir, { recursive: true });
+    const state_dir = path69.join(workspace, "agents", "runtime", "state");
+    const target = path69.join(state_dir, "rule-trips.json");
+    fs67.mkdirSync(state_dir, { recursive: true });
     let doc = { schema_version: 1, concerns: {} };
     try {
-      const parsed = JSON.parse(fs65.readFileSync(target, "utf-8"));
+      const parsed = JSON.parse(fs67.readFileSync(target, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) doc = parsed;
     } catch {
     }
@@ -27481,7 +28034,7 @@ function _parse_args(argv) {
   }
   return args;
 }
-function main46(argv) {
+function main48(argv) {
   const args = _parse_args(argv ?? process.argv.slice(2));
   if (args.project_dir) {
     const project_dir = _expanduser3(args.project_dir);
@@ -27499,13 +28052,13 @@ function main46(argv) {
       `dispatch_hook: unknown event '${args.event}'; allowed: ${_sortedRepr(EVENT_VOCABULARY)}
 `
     );
-    return EXIT_ALLOW21;
+    return EXIT_ALLOW23;
   }
   const manifest_path = args.manifest;
-  if (!fs65.existsSync(manifest_path)) {
+  if (!fs67.existsSync(manifest_path)) {
     process.stderr.write(`dispatch_hook: manifest missing at ${manifest_path}
 `);
-    return EXIT_ALLOW21;
+    return EXIT_ALLOW23;
   }
   const manifest = _load_yaml3(manifest_path);
   if (args.min_version) {
@@ -27529,10 +28082,10 @@ function main46(argv) {
       concerns: concerns.map((c) => c["name"])
     };
     process.stdout.write(_py_json_dumps2(plan, 2) + "\n");
-    return EXIT_ALLOW21;
+    return EXIT_ALLOW23;
   }
   if (concerns.length === 0) {
-    return EXIT_ALLOW21;
+    return EXIT_ALLOW23;
   }
   const envelope = _build_envelope(args, payload_text);
   const session_id = _resolve_session_id(envelope);
@@ -27552,7 +28105,7 @@ function main46(argv) {
     const raw_rc = rc;
     if (rc >= 3) {
       if (!concern["fail_closed"]) {
-        rc = EXIT_ALLOW21;
+        rc = EXIT_ALLOW23;
       } else {
         rc = EXIT_BLOCK5;
       }
@@ -27575,7 +28128,7 @@ function main46(argv) {
     if (message) {
       concern_messages.push({ rc, text: message });
     }
-    if (args.event === "session_start" && rc === EXIT_ALLOW21 && typeof reply["context"] === "string" && reply["context"].trim()) {
+    if (args.event === "session_start" && rc === EXIT_ALLOW23 && typeof reply["context"] === "string" && reply["context"].trim()) {
       context_blocks.push(reply["context"].trim());
     }
     feedback_entries.push({
@@ -27594,7 +28147,7 @@ function main46(argv) {
   const final_rc = _reduce(rcs);
   _write_feedback(envelope, session_id, feedback_entries, final_rc, started_at);
   _record_rule_trips(envelope, feedback_entries);
-  if (context_blocks.length > 0 && final_rc === EXIT_ALLOW21) {
+  if (context_blocks.length > 0 && final_rc === EXIT_ALLOW23) {
     process.stdout.write(context_blocks.join("\n\n") + "\n");
   }
   const decidingReasons = concern_messages.filter((m) => m.rc === final_rc).map((m) => m.text);
@@ -27615,7 +28168,7 @@ function main46(argv) {
 }
 function _isDir4(p) {
   try {
-    return fs65.statSync(p).isDirectory();
+    return fs67.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -27626,41 +28179,41 @@ function _sortedRepr(s) {
 }
 function _readStdin14() {
   try {
-    return fs65.readFileSync(0, "utf-8");
+    return fs67.readFileSync(0, "utf-8");
   } catch {
     return "";
   }
 }
-function _isCliEntry36() {
+function _isCliEntry38() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL41(path67.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL43(path69.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs65.realpathSync(fileURLToPath47(import.meta.url));
-    const argv = fs65.realpathSync(path67.resolve(process.argv[1]));
+    const here = fs67.realpathSync(fileURLToPath49(import.meta.url));
+    const argv = fs67.realpathSync(path69.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var isCliEntry13 = _isCliEntry36();
+var isCliEntry13 = _isCliEntry38();
 if (isCliEntry13) {
-  process.exit(main46(process.argv.slice(2)));
+  process.exit(main48(process.argv.slice(2)));
 }
 
 // src/scripts/hooks/dispatch_entry.ts
-var _selfPath = fileURLToPath48(import.meta.url);
-var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path68.resolve(process.argv[1]) === path68.resolve(_selfPath);
+var _selfPath = fileURLToPath50(import.meta.url);
+var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path70.resolve(process.argv[1]) === path70.resolve(_selfPath);
 if (_invokedDirectly2) {
-  process.exitCode = main46(process.argv.slice(2));
+  process.exitCode = main48(process.argv.slice(2));
 }
 export {
-  main46 as main
+  main48 as main
 };