@event4u/agent-config 15.0.0 → 16.0.0

package/dist/mcp/server.mjs

@@ -1080,17 +1080,17 @@ function _strip_frontmatter(text) {
   }
   return [meta, _lstripNewlines(body)];
 }
-function _splitMax(text, sep20, maxsplit) {
+function _splitMax(text, sep21, maxsplit) {
   const out = [];
   let rest = text;
   let count = 0;
   while (count < maxsplit) {
-    const idx = rest.indexOf(sep20);
+    const idx = rest.indexOf(sep21);
     if (idx === -1) {
       break;
     }
     out.push(rest.slice(0, idx));
-    rest = rest.slice(idx + sep20.length);
+    rest = rest.slice(idx + sep21.length);
     count += 1;
   }
   out.push(rest);
@@ -1900,17 +1900,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path103) {
-      const ctrl = callVisitor(key, node, visitor, path103);
+    function visit_(key, node, visitor, path105) {
+      const ctrl = callVisitor(key, node, visitor, path105);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path103, ctrl);
-        return visit_(key, ctrl, visitor, path103);
+        replaceNode(key, path105, ctrl);
+        return visit_(key, ctrl, visitor, path105);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path103 = Object.freeze(path103.concat(node));
+          path105 = Object.freeze(path105.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path103);
+            const ci = visit_(i, node.items[i], visitor, path105);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -1921,13 +1921,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path103 = Object.freeze(path103.concat(node));
-          const ck = visit_("key", node.key, visitor, path103);
+          path105 = Object.freeze(path105.concat(node));
+          const ck = visit_("key", node.key, visitor, path105);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path103);
+          const cv = visit_("value", node.value, visitor, path105);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -1948,17 +1948,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path103) {
-      const ctrl = await callVisitor(key, node, visitor, path103);
+    async function visitAsync_(key, node, visitor, path105) {
+      const ctrl = await callVisitor(key, node, visitor, path105);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path103, ctrl);
-        return visitAsync_(key, ctrl, visitor, path103);
+        replaceNode(key, path105, ctrl);
+        return visitAsync_(key, ctrl, visitor, path105);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path103 = Object.freeze(path103.concat(node));
+          path105 = Object.freeze(path105.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path103);
+            const ci = await visitAsync_(i, node.items[i], visitor, path105);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -1969,13 +1969,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path103 = Object.freeze(path103.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path103);
+          path105 = Object.freeze(path105.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path105);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path103);
+          const cv = await visitAsync_("value", node.value, visitor, path105);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -2002,23 +2002,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path103) {
+    function callVisitor(key, node, visitor, path105) {
       if (typeof visitor === "function")
-        return visitor(key, node, path103);
+        return visitor(key, node, path105);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path103);
+        return visitor.Map?.(key, node, path105);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path103);
+        return visitor.Seq?.(key, node, path105);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path103);
+        return visitor.Pair?.(key, node, path105);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path103);
+        return visitor.Scalar?.(key, node, path105);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path103);
+        return visitor.Alias?.(key, node, path105);
       return void 0;
     }
-    function replaceNode(key, path103, node) {
-      const parent = path103[path103.length - 1];
+    function replaceNode(key, path105, node) {
+      const parent = path105[path105.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -2628,10 +2628,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path103, value) {
+    function collectionFromPath(schema, path105, value) {
       let v = value;
-      for (let i = path103.length - 1; i >= 0; --i) {
-        const k = path103[i];
+      for (let i = path105.length - 1; i >= 0; --i) {
+        const k = path105[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -2650,7 +2650,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path103) => path103 == null || typeof path103 === "object" && !!path103[Symbol.iterator]().next().done;
+    var isEmptyPath = (path105) => path105 == null || typeof path105 === "object" && !!path105[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -2680,11 +2680,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(path103, value) {
-        if (isEmptyPath(path103))
+      addIn(path105, value) {
+        if (isEmptyPath(path105))
           this.add(value);
         else {
-          const [key, ...rest] = path103;
+          const [key, ...rest] = path105;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -2698,8 +2698,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path103) {
-        const [key, ...rest] = path103;
+      deleteIn(path105) {
+        const [key, ...rest] = path105;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -2713,8 +2713,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path103, keepScalar) {
-        const [key, ...rest] = path103;
+      getIn(path105, keepScalar) {
+        const [key, ...rest] = path105;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -2732,8 +2732,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path103) {
-        const [key, ...rest] = path103;
+      hasIn(path105) {
+        const [key, ...rest] = path105;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -2743,8 +2743,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(path103, value) {
-        const [key, ...rest] = path103;
+      setIn(path105, value) {
+        const [key, ...rest] = path105;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -5259,9 +5259,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path103, value) {
+      addIn(path105, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path103, value);
+          this.contents.addIn(path105, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -5336,14 +5336,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path103) {
-        if (Collection.isEmptyPath(path103)) {
+      deleteIn(path105) {
+        if (Collection.isEmptyPath(path105)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path103) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path105) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -5358,10 +5358,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path103, keepScalar) {
-        if (Collection.isEmptyPath(path103))
+      getIn(path105, keepScalar) {
+        if (Collection.isEmptyPath(path105))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path103, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path105, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -5372,10 +5372,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path103) {
-        if (Collection.isEmptyPath(path103))
+      hasIn(path105) {
+        if (Collection.isEmptyPath(path105))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path103) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path105) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -5392,13 +5392,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(path103, value) {
-        if (Collection.isEmptyPath(path103)) {
+      setIn(path105, value) {
+        if (Collection.isEmptyPath(path105)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path103), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path105), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path103, value);
+          this.contents.setIn(path105, value);
         }
       }
       /**
@@ -5784,10 +5784,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep20, value } = collItem;
+        const { start, key, sep: sep21, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep20?.[0],
+          next: key ?? sep21?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -5801,7 +5801,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep20) {
+          if (!keyProps.anchor && !keyProps.tag && !sep21) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -5825,7 +5825,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep20 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep21 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -5841,7 +5841,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep20, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep21, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -5932,7 +5932,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep20 = "";
+        let sep21 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -5946,13 +5946,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep20 + cb;
-              sep20 = "";
+                comment += sep21 + cb;
+              sep21 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep20 += source;
+                sep21 += source;
               hasSpace = true;
               break;
             default:
@@ -5995,18 +5995,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep: sep20, value } = collItem;
+        const { start, key, sep: sep21, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep20?.[0],
+          next: key ?? sep21?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep20 && !value) {
+          if (!props.anchor && !props.tag && !sep21 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -6060,8 +6060,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep20 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep20, null, props, onError);
+        if (!isMap && !sep21 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep21, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -6073,7 +6073,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep20 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep21 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -6084,8 +6084,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep20)
-                for (const st of sep20) {
+              if (sep21)
+                for (const st of sep21) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -6102,7 +6102,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep20, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep21, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -6282,7 +6282,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep20 = "";
+      let sep21 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -6299,24 +6299,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep20 + indent.slice(trimIndent) + content;
-          sep20 = "\n";
+          value += sep21 + indent.slice(trimIndent) + content;
+          sep21 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep20 === " ")
-            sep20 = "\n";
-          else if (!prevMoreIndented && sep20 === "\n")
-            sep20 = "\n\n";
-          value += sep20 + indent.slice(trimIndent) + content;
-          sep20 = "\n";
+          if (sep21 === " ")
+            sep21 = "\n";
+          else if (!prevMoreIndented && sep21 === "\n")
+            sep21 = "\n\n";
+          value += sep21 + indent.slice(trimIndent) + content;
+          sep21 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep20 === "\n")
+          if (sep21 === "\n")
             value += "\n";
           else
-            sep20 = "\n";
+            sep21 = "\n";
         } else {
-          value += sep20 + content;
-          sep20 = " ";
+          value += sep21 + content;
+          sep21 = " ";
           prevMoreIndented = false;
         }
       }
@@ -6498,25 +6498,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep20 = " ";
+      let sep21 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep20 === "\n")
-            res += sep20;
+          if (sep21 === "\n")
+            res += sep21;
           else
-            sep20 = "\n";
+            sep21 = "\n";
         } else {
-          res += sep20 + match[1];
-          sep20 = " ";
+          res += sep21 + match[1];
+          sep21 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep20 + (match?.[1] ?? "");
+      return res + sep21 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -7326,14 +7326,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep20, value }) {
+    function stringifyItem({ start, key, sep: sep21, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep20)
-        for (const st of sep20)
+      if (sep21)
+        for (const st of sep21)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -7358,9 +7358,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path103) => {
+    visit.itemAtPath = (cst, path105) => {
       let item = cst;
-      for (const [field, index] of path103) {
+      for (const [field, index] of path105) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -7369,23 +7369,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path103) => {
-      const parent = visit.itemAtPath(cst, path103.slice(0, -1));
-      const field = path103[path103.length - 1][0];
+    visit.parentCollection = (cst, path105) => {
+      const parent = visit.itemAtPath(cst, path105.slice(0, -1));
+      const field = path105[path105.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path103, item, visitor) {
-      let ctrl = visitor(item, path103);
+    function _visit(path105, item, visitor) {
+      let ctrl = visitor(item, path105);
       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(path103.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path105.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -7396,10 +7396,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path103);
+            ctrl = ctrl(item, path105);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path103) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path105) : ctrl;
     }
     exports.visit = visit;
   }
@@ -8500,18 +8500,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep20;
+          let sep21;
           if (scalar.end) {
-            sep20 = scalar.end;
-            sep20.push(this.sourceToken);
+            sep21 = scalar.end;
+            sep21.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep20 = [this.sourceToken];
+            sep21 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep20 }]
+            items: [{ start, key: scalar, sep: sep21 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -8664,15 +8664,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep20 = it.sep;
-                  sep20.push(this.sourceToken);
+                  const sep21 = it.sep;
+                  sep21.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep: sep20 }]
+                    items: [{ start: start2, key, sep: sep21 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -8701,14 +8701,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs106 = this.flowScalar(this.type);
+              const fs108 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs106, sep: [] });
+                map.items.push({ start, key: fs108, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs106);
+                this.stack.push(fs108);
               } else {
-                Object.assign(it, { key: fs106, sep: [] });
+                Object.assign(it, { key: fs108, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -8836,13 +8836,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs106 = this.flowScalar(this.type);
+              const fs108 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs106, sep: [] });
+                fc.items.push({ start: [], key: fs108, sep: [] });
               else if (it.sep)
-                this.stack.push(fs106);
+                this.stack.push(fs108);
               else
-                Object.assign(it, { key: fs106, sep: [] });
+                Object.assign(it, { key: fs108, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -8866,13 +8866,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep20 = fc.end.splice(1, fc.end.length);
-            sep20.push(this.sourceToken);
+            const sep21 = fc.end.splice(1, fc.end.length);
+            sep21.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep20 }]
+              items: [{ start, key: fc, sep: sep21 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -19565,17 +19565,17 @@ function freshMatch(pattern, text) {
   const re = new RegExp(pattern.source, pattern.flags);
   return re.exec(text);
 }
-function splitN(text, sep20, maxsplit) {
+function splitN(text, sep21, maxsplit) {
   const parts = [];
   let rest = text;
   let count = 0;
   while (count < maxsplit) {
-    const idx = rest.indexOf(sep20);
+    const idx = rest.indexOf(sep21);
     if (idx === -1) {
       break;
     }
     parts.push(rest.slice(0, idx));
-    rest = rest.slice(idx + sep20.length);
+    rest = rest.slice(idx + sep21.length);
     count += 1;
   }
   parts.push(rest);
@@ -23337,8 +23337,8 @@ function atomicAppendLine(target, line) {
   } catch {
     existing = "";
   }
-  const sep20 = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-  atomicWriteFile(target, `${existing}${sep20}${line}
+  const sep21 = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  atomicWriteFile(target, `${existing}${sep21}${line}
 `);
 }
 function randSuffix() {
@@ -24564,8 +24564,8 @@ function lockfile_path(env) {
   }
   return write_target("installed.lock", { env: env ?? null });
 }
-function read_lockfile(path103) {
-  const target = path103 ?? lockfile_path();
+function read_lockfile(path105) {
+  const target = path105 ?? lockfile_path();
   let text;
   try {
     text = fs52.readFileSync(target, { encoding: "utf-8" });
@@ -24682,18 +24682,18 @@ function manifest_path(project_root, env) {
   }
   return fsPath.join(project_root, DEFAULT_MANIFEST_RELATIVE);
 }
-function read_manifest(path103) {
+function read_manifest(path105) {
   let text;
   try {
-    text = require_read_text(path103);
+    text = require_read_text(path105);
   } catch {
     return null;
   }
   const data = _parse_manual(text);
   return _normalise_v2_shape(data);
 }
-function require_read_text(path103) {
-  return fs53.readFileSync(path103, { encoding: "utf-8" });
+function require_read_text(path105) {
+  return fs53.readFileSync(path105, { encoding: "utf-8" });
 }
 function _normalise_v2_shape(data) {
   if (data["tools"] === void 0 || data["tools"] === null) {
@@ -24874,9 +24874,9 @@ function stable_sort(items, key) {
     return a.index - b.index;
   }).map((entry) => entry.item);
 }
-function write_manifest(path103, version, tools, options = {}) {
+function write_manifest(path105, version, tools, options = {}) {
   const rendered = _render(version, tools, { deploy_roots: options.deploy_roots ?? null });
-  return write_atomic(path103, rendered);
+  return write_atomic(path105, rendered);
 }
 function upsert_tool(existing, options) {
   const {
@@ -27478,17 +27478,17 @@ function _split_frontmatter(text) {
   }
   return [parts[1], parts[2]];
 }
-function _pySplit(s, sep20, maxsplit) {
+function _pySplit(s, sep21, maxsplit) {
   const out = [];
   let rest = s;
   let n = 0;
   while (n < maxsplit) {
-    const idx = rest.indexOf(sep20);
+    const idx = rest.indexOf(sep21);
     if (idx === -1) {
       break;
     }
     out.push(rest.slice(0, idx));
-    rest = rest.slice(idx + sep20.length);
+    rest = rest.slice(idx + sep21.length);
     n++;
   }
   out.push(rest);
@@ -36536,8 +36536,8 @@ function shutilWhich(name) {
     return isExecutableFile(name) ? name : null;
   }
   const pathEnv = process19.env["PATH"] || "";
-  const sep20 = process19.platform === "win32" ? ";" : ":";
-  const dirs = pathEnv.split(sep20);
+  const sep21 = process19.platform === "win32" ? ";" : ":";
+  const dirs = pathEnv.split(sep21);
   const exts = process19.platform === "win32" ? (process19.env["PATHEXT"] || ".COM;.EXE;.BAT;.CMD").split(";") : [""];
   const seenDirs = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
@@ -38551,9 +38551,9 @@ function detectToolPresence(root) {
     agentsMd: existsSync41(join68(root, "AGENTS.md"))
   };
 }
-function isDir5(path103) {
+function isDir5(path105) {
   try {
-    return statSync44(path103).isDirectory();
+    return statSync44(path105).isDirectory();
   } catch {
     return false;
   }
@@ -38566,10 +38566,10 @@ var init_detect = __esm({
 
 // src/scripts/router_target_paths.mjs
 function parseRouteTarget(target) {
-  const sep20 = target.indexOf(":");
-  if (sep20 <= 0) return null;
-  const kind = target.slice(0, sep20);
-  const id = target.slice(sep20 + 1);
+  const sep21 = target.indexOf(":");
+  if (sep21 <= 0) return null;
+  const kind = target.slice(0, sep21);
+  const id = target.slice(sep21 + 1);
   if (!id) return null;
   if (!Object.prototype.hasOwnProperty.call(ROUTE_TARGET_TEMPLATES, kind)) return null;
   return { kind, id };
@@ -40754,6 +40754,473 @@ var init_before_complete_hook = __esm({
   }
 });
 
+// src/scripts/check_reply_consistency.ts
+import * as fs81 from "node:fs";
+import * as path81 from "node:path";
+import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL24 } from "node:url";
+function _strip_codespans(line) {
+  return line.replace(CODESPAN_RE, "``");
+}
+function splitAndMask(text) {
+  return mask_fences(_splitlines8(text));
+}
+function _splitlines8(text) {
+  if (text === "") return [];
+  const parts = text.split(/\r\n|\r|\n/);
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+function mask_fences(lines) {
+  const out = [];
+  let fence = null;
+  for (const raw of lines) {
+    const m = FENCE_RE2.exec(raw);
+    if (m) {
+      const marker = m[1];
+      if (fence === null) {
+        fence = marker;
+      } else if (fence === marker) {
+        fence = null;
+      }
+      out.push("");
+      continue;
+    }
+    out.push(fence === null ? raw : "");
+  }
+  return out;
+}
+function find_option_blocks(text) {
+  const lines = mask_fences(_splitlines8(text));
+  const blocks = [];
+  let current = null;
+  for (let idx = 0; idx < lines.length; idx++) {
+    const m = OPTION_LINE_RE.exec(lines[idx]);
+    if (m) {
+      const num2 = parseInt(m[1], 10);
+      if (current === null) {
+        current = { startLine: idx + 1, endLine: idx + 1, numbers: [num2] };
+      } else {
+        current.endLine = idx + 1;
+        current.numbers.push(num2);
+      }
+    } else {
+      if (current !== null && current.numbers.length >= 2) {
+        blocks.push(current);
+      }
+      current = null;
+    }
+  }
+  if (current !== null && current.numbers.length >= 2) {
+    blocks.push(current);
+  }
+  return blocks;
+}
+function recommendationsUnder(text, block, maskedLines) {
+  const lines = maskedLines ?? mask_fences(_splitlines8(text));
+  const recs = [];
+  let inspected = 0;
+  for (let idx = block.endLine; idx < lines.length && inspected < REC_ADJACENCY_WINDOW; idx++) {
+    const line = lines[idx];
+    if (line.trim() === "") {
+      continue;
+    }
+    if (HEADING_RE.test(line) || OPTION_LINE_RE.test(line)) {
+      break;
+    }
+    inspected += 1;
+    const m = REC_LINE_RE.exec(line);
+    if (m) {
+      recs.push({ line: idx + 1, num: parseInt(m[1], 10) });
+    }
+  }
+  return recs;
+}
+function check_reply(text) {
+  const rawLines = _splitlines8(text);
+  const lines = mask_fences(rawLines);
+  const findings = [];
+  for (let idx = 0; idx < lines.length; idx++) {
+    const stripped = _strip_codespans(lines[idx]);
+    if (OPTION_LINE_RE.test(stripped) && TAG_RE.test(stripped)) {
+      findings.push({
+        line: idx + 1,
+        message: `inline tag on numbered option \u2014 ${rawLines[idx].trim()}`
+      });
+    }
+  }
+  const blocks = find_option_blocks(text);
+  for (const block of blocks) {
+    const recs = recommendationsUnder(text, block);
+    if (recs.length === 0) {
+      findings.push({
+        line: block.startLine,
+        message: "numbered options block without a Recommendation:/Empfehlung: line directly under it"
+      });
+      continue;
+    }
+    if (recs.length > 1) {
+      findings.push({
+        line: recs[1].line,
+        message: `multiple recommendation lines under one options block: [${recs.map((r) => r.num).join(", ")}]`
+      });
+      continue;
+    }
+    const rec = recs[0];
+    if (!block.numbers.includes(rec.num)) {
+      findings.push({
+        line: rec.line,
+        message: `recommendation ${String(rec.num)} not present in the options block above it (options: [${block.numbers.join(", ")}])`
+      });
+    }
+  }
+  findings.sort((a, b) => a.line - b.line);
+  return findings;
+}
+function _isDir12(p) {
+  try {
+    return fs81.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _rglobMdSorted4(dir) {
+  const out = [];
+  const walk = (current) => {
+    let entries;
+    try {
+      entries = fs81.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path81.join(current, ent.name);
+      if (ent.isDirectory() || ent.isSymbolicLink() && _isDir12(full)) {
+        walk(full);
+      } else if (ent.name.endsWith(".md")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(dir);
+  out.sort();
+  return out;
+}
+function _relToPosixOrAbs(child, root) {
+  const rel = path81.relative(root, child);
+  if (rel === "" || rel.startsWith("..") || path81.isAbsolute(rel)) {
+    return child.split(path81.sep).join("/");
+  }
+  return rel.split(path81.sep).join("/");
+}
+function cmd_scan_dir(root) {
+  let roots;
+  if (!_isDir12(root)) {
+    const legacy = path81.join(ROOT4, ".agent-src.uncondensed");
+    if (path81.resolve(root) === path81.resolve(legacy)) {
+      roots = artefact_roots();
+      if (roots.length === 0) {
+        process.stderr.write("error: no artefact roots found (legacy or packages/*)\n");
+        return 1;
+      }
+    } else {
+      process.stderr.write(`error: not a directory: ${root}
+`);
+      return 1;
+    }
+  } else {
+    roots = [root];
+  }
+  const violations = [];
+  let scanned = 0;
+  for (const r of roots) {
+    for (const md of _rglobMdSorted4(r)) {
+      scanned += 1;
+      const text = fs81.readFileSync(md, "utf-8");
+      const lines = _splitlines8(text);
+      for (let idx = 0; idx < lines.length; idx++) {
+        const raw = lines[idx];
+        const stripped = _strip_codespans(raw);
+        if (OPTION_LINE_RE.test(stripped) && TAG_RE.test(stripped)) {
+          violations.push([md, idx + 1, raw.trim()]);
+        }
+      }
+    }
+  }
+  try {
+    assertScanned({
+      gate: "check_reply_consistency",
+      scanned,
+      units: "markdown file(s)",
+      roots: roots.map((r) => _relToPosixOrAbs(r, ROOT4))
+    });
+  } catch (exc) {
+    if (exc instanceof DeadScopeError) {
+      process.stderr.write(`\u274C  ${exc.message}
+`);
+      return 1;
+    }
+    throw exc;
+  }
+  if (violations.length > 0) {
+    for (const [p, line, snippet] of violations) {
+      process.stderr.write(`  \u{1F534} ${p}:${String(line)} \u2014 inline-tag \u2014 ${snippet}
+`);
+    }
+    process.stderr.write(`
+\u274C  ${String(violations.length)} legacy-pattern violation(s)
+`);
+    return 2;
+  }
+  if (!QUIET) {
+    const scanned2 = roots.map((r) => _relToPosixOrAbs(r, ROOT4)).join(", ");
+    process.stdout.write(`\u2705  No legacy (recommended) tags found under ${scanned2}
+`);
+  }
+  return 0;
+}
+function _usage_error(message) {
+  process.stderr.write(USAGE3);
+  process.stderr.write(`check_reply_consistency: error: ${message}
+`);
+  process.exit(1);
+}
+function _readStdin3() {
+  try {
+    return fs81.readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function parse_args8(argv) {
+  let stdin = false;
+  let file = null;
+  let scan_dir2 = null;
+  let verbose = false;
+  const groupSeen = [];
+  const need = (i, name) => {
+    const v = argv[i];
+    if (v === void 0) {
+      _usage_error(`argument ${name}: expected one argument`);
+    }
+    return v;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--stdin") {
+      stdin = true;
+      groupSeen.push("--stdin");
+    } else if (arg === "--file") {
+      file = need(++i, "--file");
+      groupSeen.push("--file");
+    } else if (arg.startsWith("--file=")) {
+      file = arg.slice("--file=".length);
+      groupSeen.push("--file");
+    } else if (arg === "--scan-dir") {
+      scan_dir2 = need(++i, "--scan-dir");
+      groupSeen.push("--scan-dir");
+    } else if (arg.startsWith("--scan-dir=")) {
+      scan_dir2 = arg.slice("--scan-dir=".length);
+      groupSeen.push("--scan-dir");
+    } else if (arg === "-v" || arg === "--verbose") {
+      verbose = true;
+    } else if (arg === "--quiet") {
+    } else if (arg === "-h" || arg === "--help") {
+      process.stdout.write(USAGE3);
+      process.exit(0);
+    } else {
+      _usage_error(`unrecognized arguments: ${arg}`);
+    }
+  }
+  if (groupSeen.length === 0) {
+    _usage_error("one of the arguments --stdin --file --scan-dir is required");
+  }
+  if (groupSeen.length > 1) {
+    _usage_error(`argument ${groupSeen[1]}: not allowed with argument ${groupSeen[0]}`);
+  }
+  return { stdin, file, scan_dir: scan_dir2, verbose };
+}
+function main27(argv = process.argv.slice(2)) {
+  const args = parse_args8(argv);
+  if (args.scan_dir !== null) {
+    return cmd_scan_dir(args.scan_dir);
+  }
+  let text;
+  try {
+    text = args.stdin ? _readStdin3() : fs81.readFileSync(args.file, "utf-8");
+  } catch (e) {
+    process.stderr.write(`error: ${String(e)}
+`);
+    return 1;
+  }
+  const findings = check_reply(text);
+  if (findings.length === 0) {
+    if (args.verbose && !QUIET) {
+      process.stdout.write("\u2705  reply consistent (every options block carries one adjacent recommendation)\n");
+    }
+    return 0;
+  }
+  for (const f of findings) {
+    process.stderr.write(`\u274C  line ${String(f.line)}: ${f.message}
+`);
+  }
+  return 2;
+}
+function _isCliEntry19() {
+  if (true) {
+    return false;
+  }
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL24(path81.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs81.realpathSync(fileURLToPath39(import.meta.url));
+    const argv = fs81.realpathSync(path81.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+var _HERE21, ROOT4, QUIET, OPTION_LINE_RE, REC_LINE_RE, TAG_RE, CODESPAN_RE, HEADING_RE, FENCE_RE2, REC_ADJACENCY_WINDOW, USAGE3, _IN_BUNDLE;
+var init_check_reply_consistency = __esm({
+  "src/scripts/check_reply_consistency.ts"() {
+    "use strict";
+    init_agent_src();
+    init_scan_scope();
+    _HERE21 = fileURLToPath39(import.meta.url);
+    ROOT4 = path81.resolve(path81.dirname(_HERE21), "..", "..");
+    QUIET = process.argv.slice(2).includes("--quiet");
+    OPTION_LINE_RE = /^\s*>?\s*(\d+)\.\s+\S/;
+    REC_LINE_RE = /(?:Recommendation|Empfehlung)\s*:\s*(\d+)\b/i;
+    TAG_RE = /\((?:recommended|rec|empfohlen)\)/i;
+    CODESPAN_RE = /`[^`\n]*`/g;
+    HEADING_RE = /^#{1,6}\s/;
+    FENCE_RE2 = /^\s*(```|~~~)/;
+    REC_ADJACENCY_WINDOW = 2;
+    USAGE3 = "usage: check_reply_consistency [-h] (--stdin | --file FILE | --scan-dir SCAN_DIR)\n                              [-v] [--quiet]\n";
+    _IN_BUNDLE = true;
+    if (!_IN_BUNDLE && (_isCliEntry19() || process.argv[1] === _HERE21)) {
+      process.exit(main27());
+    }
+  }
+});
+
+// src/scripts/_lib/dropped_decision.ts
+function detectDroppedDecision(assistantTurnTexts, closingFromPayload = false) {
+  if (assistantTurnTexts.length < 2) return null;
+  const asksIn = (text) => {
+    const blocks = find_option_blocks(text);
+    if (blocks.length === 0) return blocks;
+    const masked = splitAndMask(text);
+    return blocks.filter((b) => recommendationsUnder(text, b, masked).length > 0);
+  };
+  const closing = assistantTurnTexts[assistantTurnTexts.length - 1];
+  if (asksIn(closing).length > 0) return null;
+  for (let i = assistantTurnTexts.length - 2; i >= 0; i -= 1) {
+    const earlier = assistantTurnTexts[i];
+    const blocks = asksIn(earlier);
+    if (blocks.length === 0) continue;
+    const block = blocks[blocks.length - 1];
+    return {
+      detector: "pending-decision",
+      // The option NUMBERS and the line span, never the option text: the
+      // evidence is quoted into a refusal that reaches the transcript, and
+      // an options block can carry anything the reply carried.
+      evidence: `options ${block.numbers.join("/")} at lines ${block.startLine}-${block.endLine} of an earlier reply this turn (closing reply read from ${closingFromPayload ? "the stop payload" : "the transcript"})`,
+      reason: "an earlier reply in THIS turn put numbered options to the user and no user answer followed \u2014 this closing reply carries no options block, so the decision disappeared without being answered, cancelled or superseded. A hook nudge, a reviewer result or a task notification may ADD to a turn; it may not displace a question already asked (user-interaction Iron Law 3: a decision handed to the user outlives the turn). Re-present the block and its recommendation line at the end of this reply"
+    };
+  }
+  return null;
+}
+var init_dropped_decision = __esm({
+  "src/scripts/_lib/dropped_decision.ts"() {
+    "use strict";
+    init_check_reply_consistency();
+  }
+});
+
+// src/scripts/_lib/review_baseline.ts
+import { spawnSync as spawnSync13 } from "node:child_process";
+import * as fs82 from "node:fs";
+import * as path82 from "node:path";
+function currentHeadSha(cwd) {
+  try {
+    const r = spawnSync13("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" });
+    if (r.status !== 0) return null;
+    const out = (r.stdout ?? "").trim();
+    return out === "" ? null : out;
+  } catch {
+    return null;
+  }
+}
+function baselineStateDir(workspaceRoot) {
+  return path82.join(workspaceRoot, BASELINE_STATE_REL);
+}
+function baselineStateFile(workspaceRoot, sessionKey) {
+  return path82.join(baselineStateDir(workspaceRoot), `${sessionKey}.json`);
+}
+function parseBaseline(raw) {
+  let decoded;
+  try {
+    decoded = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+  const o = decoded;
+  const lines = o["baseline_lines"];
+  if (typeof lines !== "number" || !Number.isFinite(lines) || lines < 0) return null;
+  const written = o["written_at"];
+  if (typeof written !== "string") return null;
+  const head = o["head_sha"];
+  const measure = o["measure"];
+  return {
+    head_sha: typeof head === "string" && head !== "" ? head : null,
+    baseline_lines: lines,
+    ...measure === "exact" || measure === "capped_approximation" ? { measure } : {},
+    written_at: written
+  };
+}
+function readBaseline(workspaceRoot, sessionKey) {
+  const file = baselineStateFile(workspaceRoot, sessionKey);
+  let raw;
+  try {
+    raw = fs82.readFileSync(file, "utf-8");
+  } catch (exc) {
+    const code = exc?.code;
+    return code === "ENOENT" ? "absent" : "unreadable";
+  }
+  return parseBaseline(raw) ?? "unreadable";
+}
+function applyBaseline(measuredLines, baseline, headSha, measuredMeasure = "exact") {
+  if (baseline === "absent" || baseline === "unreadable") {
+    return { applied: false, fallback: baseline, lines: measuredLines };
+  }
+  if (baseline.measure !== "exact" || measuredMeasure !== "exact") {
+    return { applied: false, fallback: "mixed-measure", lines: measuredLines };
+  }
+  if (baseline.head_sha !== headSha()) {
+    return { applied: false, fallback: "head-moved", lines: measuredLines };
+  }
+  return {
+    applied: true,
+    baseline,
+    lines: Math.max(0, measuredLines - baseline.baseline_lines)
+  };
+}
+var BASELINE_STATE_REL;
+var init_review_baseline = __esm({
+  "src/scripts/_lib/review_baseline.ts"() {
+    "use strict";
+    BASELINE_STATE_REL = path82.join("agents", "runtime", "state", "review-baseline");
+  }
+});
+
 // src/scripts/_lib/audit_field_provenance.ts
 function appliedIds(values) {
   const out = [];
@@ -40787,6 +41254,9 @@ function buildReviewSkippedLine(input) {
   }
   if (!input.ts) errors.push("ts (ISO-8601 UTC) is required");
   if (!input.id) errors.push("id (ULID, UUID, or content hash) is required");
+  if (input.baseline !== void 0 && !BASELINE_APPLICATIONS.includes(input.baseline)) {
+    errors.push(`baseline must be one of ${BASELINE_APPLICATIONS.join(", ")}`);
+  }
   if (errors.length) return { line: null, errors };
   const line = {
     schema_version: 1,
@@ -40813,15 +41283,29 @@ function buildReviewSkippedLine(input) {
     persona: null,
     input_kind: "prompt",
     type: "note",
-    review_skipped: { diff_lines: input.diff_lines, mutation_measure: input.mutation_measure }
+    review_skipped: {
+      diff_lines: input.diff_lines,
+      mutation_measure: input.mutation_measure,
+      // Omitted, not defaulted, when the producer recorded nothing —
+      // audit-log-v1's absent-versus-present split is the same one
+      // `skills_applied` uses above, for the same reason.
+      ...input.baseline === void 0 ? {} : { baseline: input.baseline }
+    }
   };
   return { line, errors: [] };
 }
-var PRODUCER_PRIVACY_CLASS, HIGH_RISK_DIFF_LINES;
+var BASELINE_APPLICATIONS, PRODUCER_PRIVACY_CLASS, HIGH_RISK_DIFF_LINES;
 var init_review_skipped_record = __esm({
   "src/scripts/_lib/review_skipped_record.ts"() {
     "use strict";
     init_audit_field_provenance();
+    BASELINE_APPLICATIONS = [
+      "applied",
+      "absent",
+      "unreadable",
+      "head_moved",
+      "mixed_measure"
+    ];
     PRODUCER_PRIVACY_CLASS = "ids-only";
     HIGH_RISK_DIFF_LINES = 200;
   }
@@ -40888,24 +41372,24 @@ var init_envelope = __esm({
 });
 
 // src/scripts/hooks/end_review_nudge_hook.ts
-import { spawnSync as spawnSync13 } from "node:child_process";
+import { spawnSync as spawnSync14 } from "node:child_process";
 import * as crypto7 from "node:crypto";
-import * as fs81 from "node:fs";
+import * as fs83 from "node:fs";
 import * as os16 from "node:os";
-import * as path81 from "node:path";
-import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL24 } from "node:url";
+import * as path83 from "node:path";
+import { fileURLToPath as fileURLToPath40, pathToFileURL as pathToFileURL25 } from "node:url";
 function isSafeTranscriptPath(rawPath, opts = {}) {
   if (!rawPath || !/\.jsonl$/i.test(rawPath)) return false;
   const homeDir = opts.homeDir ?? os16.homedir();
   const maxBytes = opts.maxBytes ?? TRANSCRIPT_SCAN_MAX_BYTES;
   try {
-    const realHome = fs81.realpathSync(homeDir);
-    const realPath = fs81.realpathSync(rawPath);
-    const relative21 = path81.relative(realHome, realPath);
-    if (relative21 === "" || relative21.startsWith("..") || path81.isAbsolute(relative21)) {
+    const realHome = fs83.realpathSync(homeDir);
+    const realPath = fs83.realpathSync(rawPath);
+    const relative22 = path83.relative(realHome, realPath);
+    if (relative22 === "" || relative22.startsWith("..") || path83.isAbsolute(relative22)) {
       return false;
     }
-    const { size } = fs81.statSync(realPath);
+    const { size } = fs83.statSync(realPath);
     return size <= maxBytes;
   } catch {
     return false;
@@ -40934,7 +41418,7 @@ function nonDocMutatedLines(rows) {
 }
 function gitNumstatRows(cwd) {
   try {
-    const r = spawnSync13("git", ["diff", "--numstat", "HEAD"], {
+    const r = spawnSync14("git", ["diff", "--numstat", "HEAD"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -40947,7 +41431,7 @@ function gitNumstatRows(cwd) {
 }
 function untrackedNonDocFiles(cwd) {
   try {
-    const r = spawnSync13("git", ["ls-files", "--others", "--exclude-standard"], {
+    const r = spawnSync14("git", ["ls-files", "--others", "--exclude-standard"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 16 * 1024 * 1024
@@ -40960,13 +41444,13 @@ function untrackedNonDocFiles(cwd) {
 }
 function untrackedFileLineCount(cwd, relPath) {
   try {
-    const abs = path81.resolve(cwd, relPath);
-    const size = fs81.statSync(abs).size;
+    const abs = path83.resolve(cwd, relPath);
+    const size = fs83.statSync(abs).size;
     if (size === 0) return 0;
     if (size > UNTRACKED_FILE_READ_CAP_BYTES) {
       return MUTATION_LINE_THRESHOLD + 1;
     }
-    const buf = fs81.readFileSync(abs);
+    const buf = fs83.readFileSync(abs);
     if (buf.length === 0) return 0;
     const probe = buf.subarray(0, Math.min(buf.length, BINARY_PROBE_BYTES));
     if (probe.includes(0)) return 0;
@@ -41041,30 +41525,31 @@ function scanTranscriptForReviewer(transcriptText) {
 function buildAdvisoryLine(diffLines) {
   return `this session mutated ${diffLines} lines without a neutral review; spawn a cross-model reviewer before claiming done (delegation-policy / verify-budget)`;
 }
-function appendReviewSkippedTelemetry(workspaceRoot, diffLines, mutationMeasure) {
+function appendReviewSkippedTelemetry(workspaceRoot, diffLines, mutationMeasure, baseline) {
   if (is_replay_mode()) return;
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   const { line, errors } = buildReviewSkippedLine({
     diff_lines: diffLines,
     mutation_measure: mutationMeasure,
     ts,
-    id: crypto7.randomUUID()
+    id: crypto7.randomUUID(),
+    baseline
   });
   if (errors.length || line === null) return;
   try {
-    const dir = path81.join(workspaceRoot, "agents", "runtime", "state", "audit");
-    fs81.mkdirSync(dir, { recursive: true });
-    const file = path81.join(dir, `${ts.slice(0, 7)}.jsonl`);
-    fs81.appendFileSync(file, `${JSON.stringify(line)}
+    const dir = path83.join(workspaceRoot, "agents", "runtime", "state", "audit");
+    fs83.mkdirSync(dir, { recursive: true });
+    const file = path83.join(dir, `${ts.slice(0, 7)}.jsonl`);
+    fs83.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
 }
 function sessionStateDir(workspaceRoot) {
-  return path81.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
+  return path83.join(workspaceRoot, "agents", "runtime", "state", "end-review-nudge");
 }
 function sessionStateFile(workspaceRoot, sessionKey) {
-  return path81.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
+  return path83.join(sessionStateDir(workspaceRoot), `${sessionKey}.json`);
 }
 function deriveSessionKey(envelope, payload) {
   const raw = str2(envelope["session_id"]) || str2(payload["transcript_path"] ?? payload["transcriptPath"]);
@@ -41073,7 +41558,7 @@ function deriveSessionKey(envelope, payload) {
 }
 function hasFiredThisSession(workspaceRoot, sessionKey) {
   try {
-    return fs81.existsSync(sessionStateFile(workspaceRoot, sessionKey));
+    return fs83.existsSync(sessionStateFile(workspaceRoot, sessionKey));
   } catch {
     return false;
   }
@@ -41087,26 +41572,39 @@ function markFiredThisSession(workspaceRoot, sessionKey, ts) {
 function _read_stdin() {
   return readHookStdin();
 }
-function main27() {
+function main28() {
   const [envelope, payload] = unwrap(_read_stdin(), "claude");
   const event = String(envelope["event"] ?? "");
   if (event !== "" && event !== "stop") {
     return 0;
   }
   const workspace_root = String(envelope["workspace_root"] ?? "").trim() || process.cwd();
-  let diffLines;
+  let measuredLines;
   let mutationMeasure;
   try {
     const measured = totalNonDocMutatedLinesWithMeasure(workspace_root);
-    diffLines = measured.lines;
+    measuredLines = measured.lines;
     mutationMeasure = measured.measure;
   } catch {
     return 0;
   }
+  const sessionKey = deriveSessionKey(envelope, payload);
+  const baselineOutcome = applyBaseline(
+    measuredLines,
+    readBaseline(workspace_root, sessionKey),
+    // A THUNK, not a value: on the `absent` and `unreadable` branches the
+    // result is discarded, and those two are the steady state on every host
+    // without this nudge and on every session before its first baseline
+    // write. Passing the value eagerly spent an 11-14 ms `git rev-parse` on
+    // each of those stops for nothing.
+    () => currentHeadSha(workspace_root),
+    mutationMeasure
+  );
+  const diffLines = baselineOutcome.lines;
+  const baselineApplication = baselineOutcome.applied ? "applied" : FALLBACK_TO_TELEMETRY[baselineOutcome.fallback];
   if (diffLines <= MUTATION_LINE_THRESHOLD) {
     return 0;
   }
-  const sessionKey = deriveSessionKey(envelope, payload);
   if (hasFiredThisSession(workspace_root, sessionKey)) {
     return 0;
   }
@@ -41116,7 +41614,7 @@ function main27() {
   let reviewerRan = false;
   if (transcriptPath && isSafeTranscriptPath(transcriptPath)) {
     try {
-      reviewerRan = scanTranscriptForReviewer(fs81.readFileSync(transcriptPath, "utf-8"));
+      reviewerRan = scanTranscriptForReviewer(fs83.readFileSync(transcriptPath, "utf-8"));
     } catch {
       reviewerRan = false;
     }
@@ -41126,7 +41624,12 @@ function main27() {
   }
   markFiredThisSession(workspace_root, sessionKey, (/* @__PURE__ */ new Date()).toISOString());
   try {
-    appendReviewSkippedTelemetry(workspace_root, diffLines, mutationMeasure);
+    appendReviewSkippedTelemetry(
+      workspace_root,
+      diffLines,
+      mutationMeasure,
+      baselineApplication
+    );
   } catch {
   }
   process.stdout.write(
@@ -41139,29 +41642,30 @@ function main27() {
   );
   return EXIT_WARN2;
 }
-function _isCliEntry19() {
+function _isCliEntry20() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL24(path81.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL25(path83.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs81.realpathSync(fileURLToPath39(import.meta.url));
-    const argv = fs81.realpathSync(path81.resolve(process.argv[1]));
+    const here = fs83.realpathSync(fileURLToPath40(import.meta.url));
+    const argv = fs83.realpathSync(path83.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var MUTATION_LINE_THRESHOLD, UNTRACKED_FILE_CAP, TRANSCRIPT_SCAN_MAX_BYTES, EXIT_WARN2, DOC_PATH_RE, BINARY_PROBE_BYTES, UNTRACKED_FILE_READ_CAP_BYTES, DISPATCH_TOOL_RE, REVIEW_SHAPED_LABEL_RE, REVIEW_SHAPED_PROMPT_RE, REVIEW_SKILL_NAME_RE;
+var MUTATION_LINE_THRESHOLD, UNTRACKED_FILE_CAP, TRANSCRIPT_SCAN_MAX_BYTES, EXIT_WARN2, DOC_PATH_RE, BINARY_PROBE_BYTES, UNTRACKED_FILE_READ_CAP_BYTES, DISPATCH_TOOL_RE, REVIEW_SHAPED_LABEL_RE, REVIEW_SHAPED_PROMPT_RE, REVIEW_SKILL_NAME_RE, FALLBACK_TO_TELEMETRY;
 var init_end_review_nudge_hook = __esm({
   "src/scripts/hooks/end_review_nudge_hook.ts"() {
     "use strict";
+    init_review_baseline();
     init_review_skipped_record();
     init_envelope();
     init_hook_stdin();
@@ -41177,8 +41681,14 @@ var init_end_review_nudge_hook = __esm({
     REVIEW_SHAPED_LABEL_RE = /\b(review|judge|adversarial|critique|second[- ]opinion|blind\s+(pass|review)|cross-model)\b/i;
     REVIEW_SHAPED_PROMPT_RE = /\b(code\s+review|neutral\s+review|adversarial|judge|critique|second[- ]opinion|blind\s+(pass|review)|cross-model)\b/i;
     REVIEW_SKILL_NAME_RE = /^(review[-:]changes|judge[-:][a-z0-9-]+|adversarial-review|code-review)$/i;
-    if (_isCliEntry19()) {
-      process.exit(main27());
+    FALLBACK_TO_TELEMETRY = {
+      absent: "absent",
+      unreadable: "unreadable",
+      "head-moved": "head_moved",
+      "mixed-measure": "mixed_measure"
+    };
+    if (_isCliEntry20()) {
+      process.exit(main28());
     }
   }
 });
@@ -41331,9 +41841,9 @@ var init_subagent_response = __esm({
 
 // src/scripts/hooks/subagent_ledger_hook.ts
 import * as crypto8 from "node:crypto";
-import * as fs82 from "node:fs";
-import * as path82 from "node:path";
-import { fileURLToPath as fileURLToPath40, pathToFileURL as pathToFileURL25 } from "node:url";
+import * as fs84 from "node:fs";
+import * as path84 from "node:path";
+import { fileURLToPath as fileURLToPath41, pathToFileURL as pathToFileURL26 } from "node:url";
 function isObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -41424,10 +41934,10 @@ function _jsonObjectCandidates(message) {
   return out;
 }
 function openDir(root) {
-  return path82.join(root, LEDGER_DIR, OPEN_SUBDIR);
+  return path84.join(root, LEDGER_DIR, OPEN_SUBDIR);
 }
 function openFile(root, ref) {
-  return path82.join(openDir(root), `${ref}.json`);
+  return path84.join(openDir(root), `${ref}.json`);
 }
 function _asOpenRecord(value, expectedRef) {
   if (!isObject2(value)) return null;
@@ -41453,7 +41963,7 @@ function readOpenRecords(root) {
   const out = /* @__PURE__ */ new Map();
   let names;
   try {
-    names = fs82.readdirSync(openDir(root));
+    names = fs84.readdirSync(openDir(root));
   } catch {
     return out;
   }
@@ -41461,7 +41971,7 @@ function readOpenRecords(root) {
     if (!name.endsWith(".json")) continue;
     const expectedRef = name.slice(0, -".json".length);
     try {
-      const raw = fs82.readFileSync(path82.join(openDir(root), name), "utf8");
+      const raw = fs84.readFileSync(path84.join(openDir(root), name), "utf8");
       const rec = _asOpenRecord(JSON.parse(raw), expectedRef);
       if (rec) out.set(rec.ref, rec);
     } catch {
@@ -41476,13 +41986,13 @@ function resolveDepth(parentRef, open) {
   return { depth: parent.depth + 1, depth_basis: "observed" };
 }
 function ledgerFileFor2(root, ts) {
-  return path82.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
+  return path84.join(root, LEDGER_DIR, `${ts.slice(0, 7)}.jsonl`);
 }
 function appendLedgerLine(root, ts, line) {
   if (is_replay_mode()) return;
   const file = ledgerFileFor2(root, ts);
-  fs82.mkdirSync(path82.dirname(file), { recursive: true });
-  fs82.appendFileSync(file, `${JSON.stringify(line)}
+  fs84.mkdirSync(path84.dirname(file), { recursive: true });
+  fs84.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 function armsExceeded(elapsedMs) {
@@ -41490,7 +42000,7 @@ function armsExceeded(elapsedMs) {
   return WALL_CLOCK_ARMS_MS.filter((a) => elapsedMs >= a.ms).map((a) => a.label);
 }
 function openRecordStats(root, nowMs = Date.now()) {
-  const ledgerPresent = fs82.existsSync(path82.join(root, LEDGER_DIR));
+  const ledgerPresent = fs84.existsSync(path84.join(root, LEDGER_DIR));
   const open = readOpenRecords(root);
   let maxDepth = 0;
   let counted = 0;
@@ -41518,13 +42028,13 @@ function writeOpenRecord(root, rec) {
 function removeOpenRecord(root, ref) {
   if (is_replay_mode()) return;
   try {
-    fs82.unlinkSync(openFile(root, ref));
+    fs84.unlinkSync(openFile(root, ref));
   } catch {
   }
 }
 function countOpen(root) {
   try {
-    return fs82.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
+    return fs84.readdirSync(openDir(root)).filter((n) => n.endsWith(".json")).length;
   } catch {
     return 0;
   }
@@ -41675,7 +42185,7 @@ function resolveConsumerRoot(envelope) {
   }
   return process.cwd();
 }
-function main28() {
+function main29() {
   const raw = readHookStdin();
   let envelope = {};
   try {
@@ -41685,15 +42195,15 @@ function main28() {
   }
   return processEnvelope(envelope, resolveConsumerRoot(envelope));
 }
-function _isCliEntry20() {
+function _isCliEntry21() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL25(path82.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL26(path84.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs82.realpathSync(fileURLToPath40(import.meta.url)) === fs82.realpathSync(path82.resolve(process.argv[1]));
+    return fs84.realpathSync(fileURLToPath41(import.meta.url)) === fs84.realpathSync(path84.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -41706,7 +42216,7 @@ var init_subagent_ledger_hook = __esm({
     init_state_io();
     init_hook_stdin();
     EXIT_ALLOW3 = 0;
-    LEDGER_DIR = path82.join("agents", "runtime", "state", "subagent-ledger");
+    LEDGER_DIR = path84.join("agents", "runtime", "state", "subagent-ledger");
     OPEN_SUBDIR = "open";
     OPEN_RECORD_TTL_MS = 24 * 60 * 60 * 1e3;
     DEPTH_BASES = /* @__PURE__ */ new Set(["observed", "asserted-parent", "assumed-root"]);
@@ -41716,24 +42226,26 @@ var init_subagent_ledger_hook = __esm({
       { label: "30m", ms: 30 * 60 * 1e3 },
       { label: "2h", ms: 2 * 60 * 60 * 1e3 }
     ];
-    if (_isCliEntry20()) process.exit(main28());
+    if (_isCliEntry21()) process.exit(main29());
   }
 });
 
 // src/scripts/_lib/turn_end_refusals.ts
 import * as crypto9 from "node:crypto";
-import * as path83 from "node:path";
+import * as path85 from "node:path";
 function refusalStateDir(workspaceRoot) {
-  return path83.join(workspaceRoot, REFUSAL_STATE_REL);
+  return path85.join(workspaceRoot, REFUSAL_STATE_REL);
 }
 function deriveSessionKey2(sessionId) {
   return crypto9.createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
 }
 function sessionRefusalFile(workspaceRoot, sessionKey) {
-  return path83.join(refusalStateDir(workspaceRoot), `${sessionKey}.json`);
+  return path85.join(refusalStateDir(workspaceRoot), `${sessionKey}.json`);
 }
 function emptyCounts() {
-  return { promissory: 0, language: 0, verification: 0, completion: 0 };
+  const out = {};
+  for (const id of DETECTOR_IDS) out[id] = 0;
+  return out;
 }
 function isDetector(v) {
   return typeof v === "string" && DETECTOR_IDS.includes(v);
@@ -41759,6 +42271,9 @@ function parseRecord(raw) {
   if (typeof o["agent_config_version"] === "string") {
     rec.agent_config_version = o["agent_config_version"];
   }
+  if (typeof o["refused_prompt_id"] === "string") {
+    rec.refused_prompt_id = o["refused_prompt_id"];
+  }
   const counts2 = o["counts"];
   if (typeof counts2 === "object" && counts2 !== null && !Array.isArray(counts2)) {
     const parsed = {};
@@ -41802,6 +42317,9 @@ function foldRefusal(prev, input) {
   else if (prev?.agent_config_version !== void 0) {
     rec.agent_config_version = prev.agent_config_version;
   }
+  if (input.promptId !== void 0 && input.promptId !== "") {
+    rec.refused_prompt_id = input.promptId;
+  }
   return rec;
 }
 function readInstallBoundary() {
@@ -41825,16 +42343,18 @@ var init_turn_end_refusals = __esm({
       "promissory",
       "language",
       "verification",
-      "completion"
+      "completion",
+      "pending-decision",
+      "untested"
     ];
-    REFUSAL_STATE_REL = path83.join("agents", "runtime", "state", "turn-end-gate");
+    REFUSAL_STATE_REL = path85.join("agents", "runtime", "state", "turn-end-gate");
   }
 });
 
 // src/scripts/hooks/turn_end_gate_hook.ts
-import * as fs83 from "node:fs";
-import * as path84 from "node:path";
-import { fileURLToPath as fileURLToPath41, pathToFileURL as pathToFileURL26 } from "node:url";
+import * as fs85 from "node:fs";
+import * as path86 from "node:path";
+import { fileURLToPath as fileURLToPath42, pathToFileURL as pathToFileURL27 } from "node:url";
 function stripFencedBlocks(text) {
   const out = [];
   let open = null;
@@ -41891,7 +42411,7 @@ function detectPromissory(reply) {
 function readCiSettled(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return { seen: false, settled: false };
   try {
-    const raw = fs83.readFileSync(path84.join(workspaceRoot, statePathFor2(session_id)), "utf-8");
+    const raw = fs85.readFileSync(path86.join(workspaceRoot, statePathFor2(session_id)), "utf-8");
     const decoded = JSON.parse(raw);
     if (!owns_session_state(decoded, session_id)) return { seen: false, settled: false };
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
@@ -41925,8 +42445,8 @@ function detectCompletionClaim(reply, ci) {
 function readLanguagePin(workspaceRoot, session_id) {
   if (!hasStableSessionId(session_id)) return "und";
   try {
-    const raw = fs83.readFileSync(
-      path84.join(workspaceRoot, statePathFor(session_id)),
+    const raw = fs85.readFileSync(
+      path86.join(workspaceRoot, statePathFor(session_id)),
       "utf-8"
     );
     const decoded = JSON.parse(raw);
@@ -41975,12 +42495,34 @@ function detectUnverifiedEdit(toolCalls) {
     reason: "this turn changed a file and then ran no verification command \u2014 no test, type-check, lint or build call follows the last edit (verify-before-complete: a claim without a fresh run is unverified)"
   };
 }
+function _isTestPath(p) {
+  return _TEST_PATH_RE.test(p) || _TEST_FILE_RE.test(p);
+}
+function _isProductionSource(p) {
+  return _SOURCE_RE.test(p) && !_isTestPath(p);
+}
+function detectUntestedChange(reply, toolCalls) {
+  const edited = toolCalls.filter((c) => _EDIT_TOOLS.has(c.name) && c.path !== void 0).map((c) => c.path);
+  const source = edited.filter(_isProductionSource);
+  if (source.length === 0) return null;
+  if (edited.some(_isTestPath)) return null;
+  const prose = visibleProse(reply);
+  const m = _COMPLETION_RE.exec(prose);
+  if (!m) return null;
+  if (_NEGATED_CLAIM_RE.test(_lineAround(prose, m.index))) return null;
+  const shown = source.slice(0, 3).join(", ");
+  return {
+    detector: "untested",
+    evidence: shown + (source.length > 3 ? ` (+${String(source.length - 3)} more)` : ""),
+    reason: "a completion claim over production code this turn changed, with NO test file touched anywhere in the turn \u2014 running a linter is not evidence the change works. Write the test that would have caught the failure, and enumerate the states the change actually has (every view, every CRUD path, the empty and error states) rather than the happy one. If a test genuinely does not belong here, say which file carries the coverage instead"
+  };
+}
 function sessionStateFile2(workspaceRoot, sessionKey) {
   return sessionRefusalFile(workspaceRoot, sessionKey);
 }
 function alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal) {
   try {
-    const raw = fs83.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
+    const raw = fs85.readFileSync(sessionStateFile2(workspaceRoot, sessionKey), "utf-8");
     const decoded = JSON.parse(raw);
     if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
       return decoded["refused_turn"] === turnOrdinal;
@@ -41989,12 +42531,12 @@ function alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal) {
   }
   return false;
 }
-function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors) {
+function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors, promptId) {
   if (is_replay_mode()) return;
   const file = sessionStateFile2(workspaceRoot, sessionKey);
   let prev = null;
   try {
-    prev = parseRecord(fs83.readFileSync(file, "utf-8"));
+    prev = parseRecord(fs85.readFileSync(file, "utf-8"));
   } catch {
   }
   let version;
@@ -42010,27 +42552,34 @@ function markRefusedTurn(workspaceRoot, sessionKey, turnOrdinal, detectors) {
         detectors,
         turnOrdinal,
         at: (/* @__PURE__ */ new Date()).toISOString(),
-        version
+        version,
+        promptId
       })
     );
   } catch {
   }
 }
 function readTranscriptTail(transcriptPath, opts = {}) {
-  const empty = { lastAssistant: "", turnOrdinal: 0, toolCalls: [] };
+  const empty = {
+    lastAssistant: "",
+    turnOrdinal: 0,
+    toolCalls: [],
+    assistantTurnTexts: []
+  };
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
-    if (opts.maxBytes !== void 0 && fs83.statSync(transcriptPath).size > opts.maxBytes) {
+    if (opts.maxBytes !== void 0 && fs85.statSync(transcriptPath).size > opts.maxBytes) {
       return empty;
     }
-    lines = fs83.readFileSync(transcriptPath, "utf-8").split("\n");
+    lines = fs85.readFileSync(transcriptPath, "utf-8").split("\n");
   } catch {
     return empty;
   }
   let lastAssistant = "";
   let turnOrdinal = 0;
   let toolCalls = [];
+  let assistantTurnTexts = [];
   for (const rawLine of lines) {
     const line = rawLine.trim();
     if (!line) continue;
@@ -42049,20 +42598,27 @@ function readTranscriptTail(transcriptPath, opts = {}) {
     if (typeof msg !== "object" || msg === null || Array.isArray(msg)) continue;
     const content = msg["content"];
     if (role === "assistant") {
-      toolCalls.push(..._toolCalls(content));
+      toolCalls.push(...extractToolCalls(content));
     }
     const text = _messageText(content);
     if (text === null) continue;
     if (role === "assistant") {
       lastAssistant = text;
+      assistantTurnTexts.push(text);
     } else if (!isSyntheticPrompt(text)) {
       turnOrdinal += 1;
       toolCalls = [];
+      assistantTurnTexts = [];
     }
   }
-  return { lastAssistant: lastAssistant.trim(), turnOrdinal, toolCalls };
+  return {
+    lastAssistant: lastAssistant.trim(),
+    turnOrdinal,
+    toolCalls,
+    assistantTurnTexts
+  };
 }
-function _toolCalls(content) {
+function extractToolCalls(content) {
   if (!Array.isArray(content)) return [];
   const out = [];
   for (const blk of content) {
@@ -42100,7 +42656,7 @@ function _messageText(content) {
 function str4(v) {
   return typeof v === "string" ? v : "";
 }
-function main29() {
+function main30() {
   let envelope;
   let payload;
   try {
@@ -42118,10 +42674,19 @@ function main29() {
   const transcriptPath = str4(
     payload["transcript_path"] ?? payload["transcriptPath"]
   );
-  const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
-    maxBytes: TRANSCRIPT_READ_MAX_BYTES
-  });
+  const { lastAssistant, turnOrdinal, toolCalls, assistantTurnTexts } = readTranscriptTail(
+    transcriptPath,
+    { maxBytes: TRANSCRIPT_READ_MAX_BYTES }
+  );
   if (!lastAssistant) return EXIT_ALLOW4;
+  const payloadClosing = str4(
+    payload["last_assistant_message"] ?? payload["lastAssistantMessage"]
+  );
+  const closingFromPayload = payloadClosing !== "" && !assistantTurnTexts.includes(payloadClosing);
+  const turnTexts = closingFromPayload ? [...assistantTurnTexts, payloadClosing] : assistantTurnTexts;
+  const promptId = str4(
+    payload["prompt_id"] ?? payload["promptId"]
+  );
   const rawSessionId = str4(envelope["session_id"]) || "";
   const sessionKey = deriveSessionKey2(rawSessionId || "unknown-session");
   if (alreadyRefusedTurn(workspaceRoot, sessionKey, turnOrdinal)) return EXIT_ALLOW4;
@@ -42143,7 +42708,23 @@ function main29() {
     // gating is where the comment above says gating belongs — inside the
     // detector: no CI observed, or a settled read, or no completion claim
     // ⇒ no finding.
-    dispatchOpen ? null : detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot, rawSessionId))
+    dispatchOpen ? null : detectCompletionClaim(lastAssistant, readCiSettled(workspaceRoot, rawSessionId)),
+    // Detector E is UNCONDITIONAL, and that is the opposite choice from A
+    // and D one line above rather than an oversight. An open dispatch
+    // excuses a promissory closing because the work is genuinely still
+    // running; it excuses nothing about a question the user was already
+    // asked. Worse: a dispatch — or the `end-review-nudge` stop concern
+    // that produced the measured failure — IS the continuation that drops
+    // the decision, so narrowing E the same way would silence it in exactly
+    // the case it exists for.
+    detectDroppedDecision(turnTexts, closingFromPayload),
+    // Detector F takes the OTHER side of that same question, and the two
+    // sitting adjacent is the clearest place to say why. E fires on a
+    // question already asked, which an open dispatch cannot excuse. F fires
+    // on a completion CLAIM, and a turn waiting on a subagent has not
+    // finished — so its closing is not the claim F is about. Same slot,
+    // opposite trigger, opposite treatment of `dispatchOpen`.
+    dispatchOpen ? null : detectUntestedChange(lastAssistant, toolCalls)
   ]) {
     if (f) findings.push(f);
   }
@@ -42152,7 +42733,8 @@ function main29() {
     workspaceRoot,
     sessionKey,
     turnOrdinal,
-    findings.map((f) => f.detector)
+    findings.map((f) => f.detector),
+    promptId
   );
   const lines = findings.map(
     (f) => `  \xB7 ${f.detector}: ${f.reason}
@@ -42161,37 +42743,38 @@ function main29() {
   process.stderr.write(
     `turn-end-gate: REFUSED \u2014 this turn is not finished.
 ${lines.join("\n")}
-  Do the promised work now, correct the language, run the verification the edit needs, or read the CI verdict before claiming it \u2014 then end the turn.
+  Do the promised work now, correct the language, run the verification the edit needs, read the CI verdict before claiming it, or re-present the options block this turn dropped \u2014 then end the turn.
   This turn will not be refused a second time.
 `
   );
   return EXIT_BLOCK;
 }
-function _isCliEntry21() {
+function _isCliEntry22() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL26(path84.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL27(path86.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs83.realpathSync(fileURLToPath41(import.meta.url));
-    const argv = fs83.realpathSync(path84.resolve(process.argv[1]));
+    const here = fs85.realpathSync(fileURLToPath42(import.meta.url));
+    const argv = fs85.realpathSync(path86.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var EXIT_BLOCK, EXIT_ALLOW4, TRANSCRIPT_READ_MAX_BYTES, PROMISSORY, HANDBACK, _COMPLETION_RE, _NEGATED_CLAIM_RE, _EDIT_TOOLS, _VERIFY_RE;
+var EXIT_BLOCK, EXIT_ALLOW4, TRANSCRIPT_READ_MAX_BYTES, PROMISSORY, HANDBACK, _COMPLETION_RE, _NEGATED_CLAIM_RE, _EDIT_TOOLS, _VERIFY_RE, _SOURCE_RE, _TEST_PATH_RE, _TEST_FILE_RE;
 var init_turn_end_gate_hook = __esm({
   "src/scripts/hooks/turn_end_gate_hook.ts"() {
     "use strict";
     init_language_mirror_hook();
     init_before_complete_hook();
+    init_dropped_decision();
     init_end_review_nudge_hook();
     init_envelope();
     init_hook_stdin();
@@ -42252,17 +42835,20 @@ var init_turn_end_gate_hook = __esm({
     _NEGATED_CLAIM_RE = /\b(noch nicht|nicht fertig|nicht durch|wäre verfrüht|ist verfrüht|not yet|not done|isn'?t done|nein)\b/i;
     _EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
     _VERIFY_RE = /\b(test|tests|vitest|jest|pytest|phpunit|pest|tsc|eslint|ruff|mypy|pyright|clippy|phpstan|typecheck|lint[-_:a-z]*|build|ci|preflight|smoke[-_:a-z]*|check[-_:a-z]*|validate[-_:a-z]*)\b|\b(task|npm|pnpm|yarn|composer|cargo|go|make|php artisan|bun)\s+(run\s+)?\S*(test|check|lint|build|ci|typecheck)/i;
-    if (_isCliEntry21()) {
-      process.exit(main29());
+    _SOURCE_RE = /\.(?:ts|tsx|js|jsx|mjs|cjs|vue|svelte|php|py|rb|go|rs|java|kt|swift|cs|scala|ex|exs)$/i;
+    _TEST_PATH_RE = /(?:^|\/)(?:tests?|specs?|__tests__|__specs__|e2e|cypress|playwright|features)\//i;
+    _TEST_FILE_RE = /(?:\.(?:test|spec)\.[a-z]+$)|(?:_test\.[a-z]+$)|(?:(?:^|\/)test_[^/]+$)|(?:Test\.php$)|(?:Spec\.php$)|(?:\.feature$)/i;
+    if (_isCliEntry22()) {
+      process.exit(main30());
     }
   }
 });
 
 // src/scripts/hooks/evidence_independence.ts
 import crypto10 from "node:crypto";
-import fs84 from "node:fs";
-import path85 from "node:path";
-import { fileURLToPath as fileURLToPath42, pathToFileURL as pathToFileURL27 } from "node:url";
+import fs86 from "node:fs";
+import path87 from "node:path";
+import { fileURLToPath as fileURLToPath43, pathToFileURL as pathToFileURL28 } from "node:url";
 function _isObject6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -42299,8 +42885,8 @@ function extractDispatch(envelope) {
 }
 function _ledgerStamp(consumer_root) {
   try {
-    const raw = fs84.readFileSync(
-      path85.join(consumer_root, "agents", "state", "git-authorization.json"),
+    const raw = fs86.readFileSync(
+      path87.join(consumer_root, "agents", "state", "git-authorization.json"),
       "utf8"
     );
     const d = JSON.parse(raw);
@@ -42311,7 +42897,7 @@ function _ledgerStamp(consumer_root) {
 }
 function _load2(target) {
   try {
-    const decoded = JSON.parse(fs84.readFileSync(target, "utf8"));
+    const decoded = JSON.parse(fs86.readFileSync(target, "utf8"));
     if (_isObject6(decoded) && Array.isArray(decoded["evaluations"])) {
       return decoded;
     }
@@ -42368,7 +42954,7 @@ function run4(stdin_text, options) {
       return EXIT_ALLOW5;
     }
   }
-  const target = path85.join(options.consumer_root, STATE_FILE4);
+  const target = path87.join(options.consumer_root, STATE_FILE4);
   const state = _load2(target);
   const session_id = typeof envelope["session_id"] === "string" ? envelope["session_id"] : "";
   const turnMarker = `${session_id}:${_ledgerStamp(options.consumer_root)}`;
@@ -42406,7 +42992,7 @@ function _errText3(err) {
   const t = err instanceof Error ? err.message : String(err);
   return t.replace(/\s+/g, " ").trim().slice(0, 200);
 }
-function main30(argv) {
+function main31(argv) {
   const args = argv ?? process.argv.slice(2);
   let consumer_root = process.cwd();
   for (let i = 0; i < args.length; i += 1) {
@@ -42420,20 +43006,20 @@ function main30(argv) {
   }
   return run4(readHookStdin(), { consumer_root });
 }
-function _isCliEntry22() {
+function _isCliEntry23() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL27(path85.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL28(path87.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs84.realpathSync(fileURLToPath42(import.meta.url));
-    const argv = fs84.realpathSync(path85.resolve(process.argv[1]));
+    const here = fs86.realpathSync(fileURLToPath43(import.meta.url));
+    const argv = fs86.realpathSync(path87.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -42447,7 +43033,7 @@ var init_evidence_independence = __esm({
     init_hook_stdin();
     EXIT_ALLOW5 = 0;
     EXIT_BLOCK2 = 1;
-    STATE_FILE4 = path85.join("agents", "state", "evidence-dispatch.json");
+    STATE_FILE4 = path87.join("agents", "state", "evidence-dispatch.json");
     DISPATCH_TOOLS = /* @__PURE__ */ new Set([
       "Agent",
       "Task",
@@ -42480,8 +43066,8 @@ var init_evidence_independence = __esm({
     ];
     SELF_SCOPE_RE = /\b(my (work|change|diff|implementation|code|fix|patch|branch|pr)|this (diff|change|pr|delta|implementation|patch)|the delta|the change i|what i (wrote|built|changed|implemented)|i just (wrote|built|changed|implemented))\b/i;
     WARN_TEXT = "First evaluation dispatch this turn. Two shapes fabricated a binding honest-null in the audited sessions \u2014 check your prompt for both before it goes out: (1) a verdict pre-loaded into the prompt, and (2) a scope narrowed to files you chose. A review you commissioned on your own work is admissible as gate evidence only when the prompt is recorded alongside the verdict.";
-    if (_isCliEntry22()) {
-      process.exit(main30());
+    if (_isCliEntry23()) {
+      process.exit(main31());
     }
   }
 });
@@ -42782,9 +43368,9 @@ var init_subagent_routing = __esm({
 });
 
 // src/scripts/hooks/delegation_nudge_hook.ts
-import fs85 from "node:fs";
-import path86 from "node:path";
-import { fileURLToPath as fileURLToPath43, pathToFileURL as pathToFileURL28 } from "node:url";
+import fs87 from "node:fs";
+import path88 from "node:path";
+import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL29 } from "node:url";
 function _isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -42950,7 +43536,7 @@ function _workspaceRoot(envelope) {
   }
   return process.cwd();
 }
-function main31() {
+function main32() {
   let envelope = {};
   try {
     const raw = readHookStdin();
@@ -42989,20 +43575,20 @@ function main31() {
   );
   return EXIT_WARN3;
 }
-function _isCliEntry23() {
+function _isCliEntry24() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL28(path86.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL29(path88.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs85.realpathSync(fileURLToPath43(import.meta.url));
-    const argv = fs85.realpathSync(path86.resolve(process.argv[1]));
+    const here = fs87.realpathSync(fileURLToPath44(import.meta.url));
+    const argv = fs87.realpathSync(path88.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -43029,18 +43615,18 @@ var init_delegation_nudge_hook = __esm({
     STEP_LINE_RE = /^\s*\d+[.)]\s+\S/gm;
     ORDERED_LINE_FLOOR = 3;
     ORDERED_WORD_FLOOR = 2;
-    if (_isCliEntry23()) {
-      process.exit(main31());
+    if (_isCliEntry24()) {
+      process.exit(main32());
     }
   }
 });
 
 // src/scripts/conformance_scan.ts
 import { createHash as createHash14 } from "node:crypto";
-import fs86 from "node:fs";
+import fs88 from "node:fs";
 import os17 from "node:os";
-import path87 from "node:path";
-import { fileURLToPath as fileURLToPath44, pathToFileURL as pathToFileURL29 } from "node:url";
+import path89 from "node:path";
+import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL30 } from "node:url";
 function spansCarrierChange(firstAts) {
   const stamps = firstAts.filter((s) => s !== "").sort();
   if (stamps.length === 0) {
@@ -43382,7 +43968,7 @@ function scanSession(sessionId, lines) {
 }
 function defaultStore(projectDir) {
   const slug = projectStoreSlug(projectDir);
-  return path87.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
+  return path89.join(process.env["HOME"] ?? "", ".claude", "projects", slug);
 }
 function _tokens(chars) {
   return Math.round(chars / 4);
@@ -43393,13 +43979,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   return {
     project: {
       dir: projectRulesDir,
-      present: fs86.existsSync(projectRulesDir),
+      present: fs88.existsSync(projectRulesDir),
       files: p.files,
       tokens: _tokens(p.chars)
     },
     global: {
       dir: globalRulesDir,
-      present: fs86.existsSync(globalRulesDir),
+      present: fs88.existsSync(globalRulesDir),
       files: g.files,
       tokens: _tokens(g.chars)
     },
@@ -43407,13 +43993,13 @@ function measureDelivered(projectRulesDir, globalRulesDir) {
   };
 }
 function storeKey(store) {
-  return createHash14("sha256").update(path87.resolve(store)).digest("hex").slice(0, 12);
+  return createHash14("sha256").update(path89.resolve(store)).digest("hex").slice(0, 12);
 }
 function scanStore(store, limit) {
-  const files = fs86.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs86.statSync(path87.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
+  const files = fs88.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, m: fs88.statSync(path89.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.f);
   const per_session = [];
   for (const f of files) {
-    const lines = fs86.readFileSync(path87.join(store, f), "utf8").split("\n");
+    const lines = fs88.readFileSync(path89.join(store, f), "utf8").split("\n");
     const r = scanSession(f.replace(/\.jsonl$/, "").slice(0, 8), lines);
     if (r.assistant_turns > 0) {
       per_session.push(r);
@@ -43441,10 +44027,10 @@ function scanStore(store, limit) {
   const task_completeness_rate_pct = completeness_windows === 0 ? 0 : Number((100 * task_completeness / completeness_windows).toFixed(1));
   const era = spansCarrierChange(per_session.map((s) => s.first_at));
   const delivered = measureDelivered(
-    path87.join(REPO_ROOT7, ".claude", "rules"),
-    path87.join(process.env["HOME"] ?? os17.homedir(), ".claude", "rules")
+    path89.join(REPO_ROOT7, ".claude", "rules"),
+    path89.join(process.env["HOME"] ?? os17.homedir(), ".claude", "rules")
   );
-  const ownStore = path87.resolve(store) === path87.resolve(defaultStore(REPO_ROOT7));
+  const ownStore = path89.resolve(store) === path89.resolve(defaultStore(REPO_ROOT7));
   return {
     scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
     store,
@@ -43474,8 +44060,8 @@ function scanStore(store, limit) {
   };
 }
 function recordRate(file, scanned_at, rate) {
-  fs86.mkdirSync(path87.dirname(file), { recursive: true });
-  fs86.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
+  fs88.mkdirSync(path89.dirname(file), { recursive: true });
+  fs88.appendFileSync(file, `${JSON.stringify({ measured_at: scanned_at, ...rate })}
 `, "utf8");
 }
 function render3(report2) {
@@ -43574,7 +44160,7 @@ function render3(report2) {
   lines.push("    checkbox batching                     \u2014 measured NOWHERE. ~5 low-severity findings.");
   return lines.join("\n");
 }
-function main32(argv) {
+function main33(argv) {
   const args = argv ?? process.argv.slice(2);
   let store = null;
   let limit = 30;
@@ -43606,14 +44192,14 @@ function main32(argv) {
     return 2;
   }
   const resolved = store ?? defaultStore(process.cwd());
-  if (!fs86.existsSync(resolved)) {
+  if (!fs88.existsSync(resolved)) {
     process.stderr.write(`conformance:behavior: no transcript store at ${resolved}
 `);
     return 1;
   }
   const report2 = scanStore(resolved, Number.isFinite(limit) && limit > 0 ? limit : 30);
   if (out) {
-    fs86.writeFileSync(out, `${JSON.stringify(report2, null, 2)}
+    fs88.writeFileSync(out, `${JSON.stringify(report2, null, 2)}
 `, "utf8");
   }
   if (record) {
@@ -43621,7 +44207,7 @@ function main32(argv) {
   }
   if (why !== null) {
     const id = why;
-    fs86.writeSync(
+    fs88.writeSync(
       1,
       json ? `${JSON.stringify(
         {
@@ -43641,25 +44227,25 @@ function main32(argv) {
     );
     return 0;
   }
-  fs86.writeSync(1, json ? `${JSON.stringify(report2, null, 2)}
+  fs88.writeSync(1, json ? `${JSON.stringify(report2, null, 2)}
 ` : `${render3(report2)}
 `);
   return 0;
 }
-function _isCliEntry24() {
+function _isCliEntry25() {
   if (true) {
     return false;
   }
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL29(path87.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL30(path89.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs86.realpathSync(fileURLToPath44(import.meta.url));
-    const argv = fs86.realpathSync(path87.resolve(process.argv[1]));
+    const here = fs88.realpathSync(fileURLToPath45(import.meta.url));
+    const argv = fs88.realpathSync(path89.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -43680,7 +44266,7 @@ var init_conformance_scan = __esm({
     init_turn_end_gate_hook();
     init_evidence_independence();
     init_delegation_nudge_hook();
-    REPO_ROOT7 = path87.resolve(path87.dirname(fileURLToPath44(import.meta.url)), "..", "..");
+    REPO_ROOT7 = path89.resolve(path89.dirname(fileURLToPath45(import.meta.url)), "..", "..");
     OBSERVED_BAND = { low: 9.1, high: 39.2 };
     BAND_MIN_TURNS = 1978;
     CARRIER_CHANGES = [
@@ -43707,28 +44293,28 @@ var init_conformance_scan = __esm({
     };
     HARNESS_TEXT = /^(API Error:|Request (timed out|was aborted)|\[Request interrupted|Error: |Credit balance is too low|You've hit your|Prompt is too long)/i;
     EN_OPENER = /^(let me|i'?ll |i'?m |found it|ok[,. ]|okay|alright|here'?s|now[,. ]|looking|checking|reading|running|the |this |that |there |we |you |good |right[,. ]|perfect|done[.,]|all |confirmed|correct)/i;
-    DEFAULT_RATE_SERIES = path87.join(
+    DEFAULT_RATE_SERIES = path89.join(
       REPO_ROOT7,
       "agents",
       "runtime",
       "state",
       "conformance-rates.jsonl"
     );
-    if (_isCliEntry24()) {
-      process.exit(main32());
+    if (_isCliEntry25()) {
+      process.exit(main33());
     }
   }
 });
 
 // src/scripts/report_carrier_divergence.ts
-import * as fs87 from "node:fs";
+import * as fs89 from "node:fs";
 import * as os18 from "node:os";
-import * as path88 from "node:path";
+import * as path90 from "node:path";
 import process20 from "node:process";
-import { fileURLToPath as fileURLToPath45, pathToFileURL as pathToFileURL30 } from "node:url";
+import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL31 } from "node:url";
 function _listRules(dir) {
   try {
-    return fs87.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    return fs89.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -43736,7 +44322,7 @@ function _listRules(dir) {
 function _ruleType(file) {
   let text;
   try {
-    text = fs87.readFileSync(file, "utf-8");
+    text = fs89.readFileSync(file, "utf-8");
   } catch {
     return "";
   }
@@ -43747,8 +44333,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
   const out = {
     projectDir,
     globalDir,
-    globalPresent: fs87.existsSync(globalDir),
-    projectPresent: fs87.existsSync(projectDir),
+    globalPresent: fs89.existsSync(globalDir),
+    projectPresent: fs89.existsSync(projectDir),
     shared: 0,
     identical: [],
     provenanceOnly: [],
@@ -43771,7 +44357,7 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     }
     if (!inP && inG) {
       out.globalOnly.push(rule);
-      if (sourceDir !== void 0 && _ruleType(path88.join(sourceDir, rule)) === "manual") {
+      if (sourceDir !== void 0 && _ruleType(path90.join(sourceDir, rule)) === "manual") {
         out.manualOnlyGlobal.push(rule);
       }
       continue;
@@ -43781,8 +44367,8 @@ function compareCarriers(projectDir, globalDir, sourceDir) {
     let projectCopy;
     let globalCopy;
     try {
-      projectCopy = fs87.readFileSync(path88.join(projectDir, rule));
-      globalCopy = fs87.readFileSync(path88.join(globalDir, rule));
+      projectCopy = fs89.readFileSync(path90.join(projectDir, rule));
+      globalCopy = fs89.readFileSync(path90.join(globalDir, rule));
       verdict = comparePair(projectCopy, globalCopy);
     } catch {
       out.shared -= 1;
@@ -43927,11 +44513,11 @@ function render4(d) {
   }
   return lines.join("\n");
 }
-function main33(argv) {
+function main34(argv) {
   const args = argv ?? process20.argv.slice(2);
-  let projectDir = path88.join(REPO_ROOT8, PROJECT_RULES);
-  let globalDir = path88.join(os18.homedir(), GLOBAL_RULES);
-  let sourceDir = path88.join(REPO_ROOT8, PROJECTION_SOURCE);
+  let projectDir = path90.join(REPO_ROOT8, PROJECT_RULES);
+  let globalDir = path90.join(os18.homedir(), GLOBAL_RULES);
+  let sourceDir = path90.join(REPO_ROOT8, PROJECTION_SOURCE);
   const value = (i) => {
     const v = args[i + 1];
     return v === void 0 || v.startsWith("-") ? null : v;
@@ -43945,7 +44531,7 @@ function main33(argv) {
 `);
         return 1;
       }
-      const resolved = path88.resolve(v);
+      const resolved = path90.resolve(v);
       if (a === "--project") projectDir = resolved;
       else if (a === "--global") globalDir = resolved;
       else sourceDir = resolved;
@@ -43965,36 +44551,36 @@ function main33(argv) {
 `);
   return 0;
 }
-function _isCliEntry25() {
+function _isCliEntry26() {
   if (process20.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL30(path88.resolve(process20.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL31(path90.resolve(process20.argv[1])).href) return true;
   try {
-    return fs87.realpathSync(_HERE21) === fs87.realpathSync(path88.resolve(process20.argv[1]));
+    return fs89.realpathSync(_HERE22) === fs89.realpathSync(path90.resolve(process20.argv[1]));
   } catch {
     return false;
   }
 }
-var _HERE21, REPO_ROOT8, PROJECT_RULES, PROJECTION_SOURCE, GLOBAL_RULES;
+var _HERE22, REPO_ROOT8, PROJECT_RULES, PROJECTION_SOURCE, GLOBAL_RULES;
 var init_report_carrier_divergence = __esm({
   "src/scripts/report_carrier_divergence.ts"() {
     "use strict";
     init_carrier_divergence();
-    _HERE21 = fileURLToPath45(import.meta.url);
-    REPO_ROOT8 = path88.resolve(path88.dirname(_HERE21), "..", "..");
-    PROJECT_RULES = path88.join(".claude", "rules");
-    PROJECTION_SOURCE = path88.join("dist", "agent-src", "rules");
-    GLOBAL_RULES = path88.join(".claude", "rules");
-    if (_isCliEntry25()) {
-      process20.exit(main33());
+    _HERE22 = fileURLToPath46(import.meta.url);
+    REPO_ROOT8 = path90.resolve(path90.dirname(_HERE22), "..", "..");
+    PROJECT_RULES = path90.join(".claude", "rules");
+    PROJECTION_SOURCE = path90.join("dist", "agent-src", "rules");
+    GLOBAL_RULES = path90.join(".claude", "rules");
+    if (_isCliEntry26()) {
+      process20.exit(main34());
     }
   }
 });
 
 // src/scripts/report_skill_activation.ts
-import * as fs88 from "node:fs";
+import * as fs90 from "node:fs";
 import * as os19 from "node:os";
-import * as path89 from "node:path";
-import { fileURLToPath as fileURLToPath46, pathToFileURL as pathToFileURL31 } from "node:url";
+import * as path91 from "node:path";
+import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL32 } from "node:url";
 function censusSkills(root) {
   const out = {
     total: 0,
@@ -44002,25 +44588,25 @@ function censusSkills(root) {
     withTriggerCorpus: [],
     withDeterministicObligation: []
   };
-  if (!fs88.existsSync(root)) {
+  if (!fs90.existsSync(root)) {
     return out;
   }
-  for (const entry of fs88.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+  for (const entry of fs90.readdirSync(root, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const file = path89.join(root, entry.name, "SKILL.md");
-    if (!fs88.existsSync(file)) {
+    const file = path91.join(root, entry.name, "SKILL.md");
+    if (!fs90.existsSync(file)) {
       continue;
     }
     out.total += 1;
-    const text = fs88.readFileSync(file, "utf8");
+    const text = fs90.readFileSync(file, "utf8");
     const fmEnd = text.startsWith("---") ? text.indexOf("\n---", 3) : -1;
     const fm = fmEnd === -1 ? "" : text.slice(0, fmEnd);
     if (TRIGGER_KEYS.some((k) => new RegExp(`^${k}`, "m").test(fm))) {
       out.withTriggerKey.push(entry.name);
     }
-    if (fs88.existsSync(path89.join(root, entry.name, "evals", "triggers.json"))) {
+    if (fs90.existsSync(path91.join(root, entry.name, "evals", "triggers.json"))) {
       out.withTriggerCorpus.push(entry.name);
     }
     const body = fmEnd === -1 ? text : text.slice(fmEnd + 4);
@@ -44031,17 +44617,17 @@ function censusSkills(root) {
   return out;
 }
 function defaultStore2(cwd) {
-  return path89.join(os19.homedir(), ".claude", "projects", projectStoreSlug(cwd));
+  return path91.join(os19.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function measureUsage(store, limit) {
   const rep = { store, sessions: 0, assistantTurns: 0, invocations: 0, bySkill: {} };
-  if (!fs88.existsSync(store)) {
+  if (!fs90.existsSync(store)) {
     return rep;
   }
-  const files = fs88.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path89.join(store, f)).sort((a, b) => fs88.statSync(b).mtimeMs - fs88.statSync(a).mtimeMs).slice(0, limit);
+  const files = fs90.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => path91.join(store, f)).sort((a, b) => fs90.statSync(b).mtimeMs - fs90.statSync(a).mtimeMs).slice(0, limit);
   rep.sessions = files.length;
   for (const file of files) {
-    for (const line of fs88.readFileSync(file, "utf8").split("\n")) {
+    for (const line of fs90.readFileSync(file, "utf8").split("\n")) {
       if (!line.trim()) {
         continue;
       }
@@ -44113,15 +44699,15 @@ function buildRecord(census, usage, today) {
     assistant_turns: usage.reduce((a, u) => a + u.assistantTurns, 0),
     invocations: usage.reduce((a, u) => a + u.invocations, 0),
     distinct_skills_invoked: distinct.size,
-    stores: usage.map((u) => path89.basename(u.store))
+    stores: usage.map((u) => path91.basename(u.store))
   };
 }
 function readRecord(repoRoot) {
-  const file = path89.join(repoRoot, RECORD_PATH);
-  if (!fs88.existsSync(file)) {
+  const file = path91.join(repoRoot, RECORD_PATH);
+  if (!fs90.existsSync(file)) {
     return null;
   }
-  return JSON.parse(fs88.readFileSync(file, "utf8"));
+  return JSON.parse(fs90.readFileSync(file, "utf8"));
 }
 function render5(census, usage, published = null) {
   const lines = [];
@@ -44156,7 +44742,7 @@ function render5(census, usage, published = null) {
     }
     totalInv += u.invocations;
     lines.push(
-      `  ${path89.basename(u.store).slice(-38).padEnd(38)} sessions=${String(u.sessions).padStart(3)} asst=${String(u.assistantTurns).padStart(6)} Skill calls=${String(u.invocations).padStart(3)}`
+      `  ${path91.basename(u.store).slice(-38).padEnd(38)} sessions=${String(u.sessions).padStart(3)} asst=${String(u.assistantTurns).padStart(6)} Skill calls=${String(u.invocations).padStart(3)}`
     );
   }
   lines.push("");
@@ -44226,7 +44812,7 @@ function render5(census, usage, published = null) {
   lines.push("  catalogue once per session, then count descriptions against bare names.");
   return lines.join("\n");
 }
-function main34(argv) {
+function main35(argv) {
   let limit = 30;
   let emit2 = false;
   let allowEmpty = false;
@@ -44248,7 +44834,7 @@ function main34(argv) {
     } else if (a === "--allow-empty-store") {
       allowEmpty = true;
     } else if (a === "--help" || a === "-h") {
-      process.stdout.write(USAGE3);
+      process.stdout.write(USAGE4);
       return 0;
     }
   }
@@ -44259,7 +44845,7 @@ function main34(argv) {
   if (stores.length === 0) {
     stores.push(defaultStore2(REPO_ROOT9));
   }
-  const census = censusSkills(path89.join(root, SKILLS_ROOT));
+  const census = censusSkills(path91.join(root, SKILLS_ROOT));
   const usage = stores.map((s) => measureUsage(s, limit));
   process.stdout.write(`${render5(census, usage, readRecord(root))}
 `);
@@ -44280,40 +44866,40 @@ function main34(argv) {
     return 1;
   }
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const file = path89.join(root, RECORD_PATH);
-  fs88.mkdirSync(path89.dirname(file), { recursive: true });
-  fs88.writeFileSync(file, `${JSON.stringify(buildRecord(census, usage, today), null, 2)}
+  const file = path91.join(root, RECORD_PATH);
+  fs90.mkdirSync(path91.dirname(file), { recursive: true });
+  fs90.writeFileSync(file, `${JSON.stringify(buildRecord(census, usage, today), null, 2)}
 `);
   process.stdout.write(`
 wrote ${RECORD_PATH} (measured ${today})
 `);
   return 0;
 }
-var _HERE22, REPO_ROOT9, SKILLS_ROOT, TRIGGER_KEYS, DETERMINISTIC_RE, RECORD_PATH, USAGE3;
+var _HERE23, REPO_ROOT9, SKILLS_ROOT, TRIGGER_KEYS, DETERMINISTIC_RE, RECORD_PATH, USAGE4;
 var init_report_skill_activation = __esm({
   "src/scripts/report_skill_activation.ts"() {
     "use strict";
     init_cc_transcript();
     init_scan_scope();
-    _HERE22 = fileURLToPath46(import.meta.url);
-    REPO_ROOT9 = path89.resolve(path89.dirname(_HERE22), "..", "..");
+    _HERE23 = fileURLToPath47(import.meta.url);
+    REPO_ROOT9 = path91.resolve(path91.dirname(_HERE23), "..", "..");
     SKILLS_ROOT = "src/skills";
     TRIGGER_KEYS = ["triggers:", "trigger_description:", "file_pattern:", "path_prefix:"];
     DETERMINISTIC_RE = /^\s*(?:[-*]\s*)?(?:\*\*)?(MUST|NEVER|ALWAYS)\b/m;
     RECORD_PATH = "agents/evidence/metrics/skill-activation-census.json";
-    USAGE3 = "usage: report_skill_activation [--root DIR] [--limit N] [--store PATH]... [--emit] [--allow-empty-store]\n";
-    if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL31(path89.resolve(process.argv[1])).href) {
-      process.exit(main34(process.argv.slice(2)));
+    USAGE4 = "usage: report_skill_activation [--root DIR] [--limit N] [--store PATH]... [--emit] [--allow-empty-store]\n";
+    if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL32(path91.resolve(process.argv[1])).href) {
+      process.exit(main35(process.argv.slice(2)));
     }
   }
 });
 
 // src/scripts/report_skill_obligation_violations.ts
-import * as fs89 from "node:fs";
+import * as fs91 from "node:fs";
 import * as os20 from "node:os";
-import * as path90 from "node:path";
+import * as path92 from "node:path";
 import process21 from "node:process";
-import { fileURLToPath as fileURLToPath47, pathToFileURL as pathToFileURL32 } from "node:url";
+import { fileURLToPath as fileURLToPath48, pathToFileURL as pathToFileURL33 } from "node:url";
 function _verb(line) {
   const m = /\b(NEVER|MUST|ALWAYS)\b/.exec(line);
   return m?.[1] ?? "NEVER";
@@ -44332,7 +44918,7 @@ function _artefacts(line) {
   return out;
 }
 function extractObligations(repoRoot) {
-  const skillsRoot = path90.join(repoRoot, SKILLS_ROOT);
+  const skillsRoot = path92.join(repoRoot, SKILLS_ROOT);
   const census = censusSkills(skillsRoot);
   const out = {
     skills: census.withDeterministicObligation,
@@ -44346,7 +44932,7 @@ function extractObligations(repoRoot) {
   for (const skill of census.withDeterministicObligation) {
     let text;
     try {
-      text = fs89.readFileSync(path90.join(skillsRoot, skill, "SKILL.md"), "utf-8");
+      text = fs91.readFileSync(path92.join(skillsRoot, skill, "SKILL.md"), "utf-8");
     } catch {
       continue;
     }
@@ -44448,7 +45034,7 @@ function scanSessionForViolations(session, lines, forbidden, parsed) {
   return flags;
 }
 function defaultStore3(cwd) {
-  return path90.join(os20.homedir(), ".claude", "projects", projectStoreSlug(cwd));
+  return path92.join(os20.homedir(), ".claude", "projects", projectStoreSlug(cwd));
 }
 function scanStore2(repoRoot, store, limit) {
   const census = extractObligations(repoRoot);
@@ -44461,14 +45047,14 @@ function scanStore2(repoRoot, store, limit) {
   };
   let files;
   try {
-    files = fs89.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path90.join(store, f), m: fs89.statSync(path90.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
+    files = fs91.readdirSync(store).filter((f) => f.endsWith(".jsonl")).map((f) => ({ p: path92.join(store, f), m: fs91.statSync(path92.join(store, f)).mtimeMs })).sort((a, b) => b.m - a.m).slice(0, limit).map((x) => x.p);
   } catch {
     return report2;
   }
   report2.sessions = files.length;
   for (const file of files) {
-    const lines = fs89.readFileSync(file, "utf-8").split("\n");
-    const id = path90.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
+    const lines = fs91.readFileSync(file, "utf-8").split("\n");
+    const id = path92.basename(file).replace(/\.jsonl$/, "").slice(0, 8);
     const entries = _parseSession(lines);
     if (loadedSkillsFrom(entries).size > 0) report2.sessionsWithASkill += 1;
     report2.flags.push(...scanSessionForViolations(id, lines, census.forbidden, entries));
@@ -44538,7 +45124,7 @@ function render6(r) {
   lines.push("  ships as detection-only, and this one says so.");
   return lines.join("\n");
 }
-function main35(argv) {
+function main36(argv) {
   const args = argv ?? process21.argv.slice(2);
   let limit = 30;
   let json = false;
@@ -44591,24 +45177,24 @@ function main35(argv) {
   }
   return 0;
 }
-function _isCliEntry26() {
+function _isCliEntry27() {
   if (process21.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL32(path90.resolve(process21.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL33(path92.resolve(process21.argv[1])).href) return true;
   try {
-    return fs89.realpathSync(_HERE23) === fs89.realpathSync(path90.resolve(process21.argv[1]));
+    return fs91.realpathSync(_HERE24) === fs91.realpathSync(path92.resolve(process21.argv[1]));
   } catch {
     return false;
   }
 }
-var _HERE23, REPO_ROOT10, OBLIGATION_LINE_RE, PATH_RE2, CMD_RE, CMD_HEADS, PIVOT_RE, WRITE_TOOLS, SHELL_TOOLS, SKILL_BODY_RE, PATH_FIELDS, COMMAND_FIELDS;
+var _HERE24, REPO_ROOT10, OBLIGATION_LINE_RE, PATH_RE2, CMD_RE, CMD_HEADS, PIVOT_RE, WRITE_TOOLS, SHELL_TOOLS, SKILL_BODY_RE, PATH_FIELDS, COMMAND_FIELDS;
 var init_report_skill_obligation_violations = __esm({
   "src/scripts/report_skill_obligation_violations.ts"() {
     "use strict";
     init_cc_transcript();
     init_transcript_entry();
     init_report_skill_activation();
-    _HERE23 = fileURLToPath47(import.meta.url);
-    REPO_ROOT10 = path90.resolve(path90.dirname(_HERE23), "..", "..");
+    _HERE24 = fileURLToPath48(import.meta.url);
+    REPO_ROOT10 = path92.resolve(path92.dirname(_HERE24), "..", "..");
     OBLIGATION_LINE_RE = new RegExp(`${DETERMINISTIC_RE.source}.*`, "gm");
     PATH_RE2 = /`([A-Za-z0-9_./-]*\/[A-Za-z0-9_.-]+\.[a-z]{2,6})`/g;
     CMD_RE = /`([a-z][a-z0-9-]*(?: [a-z][a-z0-9:._-]*){1,3})`/g;
@@ -44642,31 +45228,31 @@ var init_report_skill_obligation_violations = __esm({
     SKILL_BODY_RE = /Base directory for this skill:\s*\S*?\/skills\/([A-Za-z0-9_-]+)/;
     PATH_FIELDS = ["file_path", "path", "filePath", "notebook_path", "target_file"];
     COMMAND_FIELDS = ["command", "cmd"];
-    if (_isCliEntry26()) {
-      process21.exit(main35());
+    if (_isCliEntry27()) {
+      process21.exit(main36());
     }
   }
 });
 
 // src/scripts/report_conformance_funnel.ts
-import * as fs90 from "node:fs";
+import * as fs92 from "node:fs";
 import * as os21 from "node:os";
-import * as path91 from "node:path";
+import * as path93 from "node:path";
 import process22 from "node:process";
-import { fileURLToPath as fileURLToPath48, pathToFileURL as pathToFileURL33 } from "node:url";
+import { fileURLToPath as fileURLToPath49, pathToFileURL as pathToFileURL34 } from "node:url";
 function buildFunnel(opts = {}) {
   const repoRoot = opts.repoRoot ?? REPO_ROOT11;
-  const projectRulesDir = opts.projectRulesDir ?? path91.join(repoRoot, PROJECT_RULES);
-  const globalRulesDir = opts.globalRulesDir ?? path91.join(os21.homedir(), GLOBAL_RULES);
-  const sourceDir = opts.sourceDir ?? path91.join(repoRoot, PROJECTION_SOURCE);
+  const projectRulesDir = opts.projectRulesDir ?? path93.join(repoRoot, PROJECT_RULES);
+  const globalRulesDir = opts.globalRulesDir ?? path93.join(os21.homedir(), GLOBAL_RULES);
+  const sourceDir = opts.sourceDir ?? path93.join(repoRoot, PROJECTION_SOURCE);
   const store = opts.store ?? defaultStore(repoRoot);
   const limit = opts.limit ?? 30;
   return {
     delivered: measureDelivered(projectRulesDir, globalRulesDir),
     divergence: compareCarriers(projectRulesDir, globalRulesDir, sourceDir),
-    skills: censusSkills(path91.join(repoRoot, SKILLS_ROOT)),
+    skills: censusSkills(path93.join(repoRoot, SKILLS_ROOT)),
     usage: measureUsage(store, limit),
-    storePresent: fs90.existsSync(store),
+    storePresent: fs92.existsSync(store),
     sk2: scanStore2(repoRoot, store, limit)
   };
 }
@@ -44791,7 +45377,7 @@ function render7(r) {
   lines.push("workflow without a measured false-positive rate first (locked policy).");
   return lines.join("\n");
 }
-function main36(argv) {
+function main37(argv) {
   const args = argv ?? process22.argv.slice(2);
   const opts = {};
   const value = (i) => {
@@ -44807,7 +45393,7 @@ function main36(argv) {
 `);
         return 1;
       }
-      const resolved = path91.resolve(v);
+      const resolved = path93.resolve(v);
       if (a === "--store") opts.store = resolved;
       else if (a === "--project") opts.projectRulesDir = resolved;
       else if (a === "--global") opts.globalRulesDir = resolved;
@@ -44837,16 +45423,16 @@ function main36(argv) {
 `);
   return 0;
 }
-function _isCliEntry27() {
+function _isCliEntry28() {
   if (process22.argv[1] === void 0) return false;
-  if (import.meta.url === pathToFileURL33(path91.resolve(process22.argv[1])).href) return true;
+  if (import.meta.url === pathToFileURL34(path93.resolve(process22.argv[1])).href) return true;
   try {
-    return fs90.realpathSync(_HERE24) === fs90.realpathSync(path91.resolve(process22.argv[1]));
+    return fs92.realpathSync(_HERE25) === fs92.realpathSync(path93.resolve(process22.argv[1]));
   } catch {
     return false;
   }
 }
-var _HERE24, REPO_ROOT11;
+var _HERE25, REPO_ROOT11;
 var init_report_conformance_funnel = __esm({
   "src/scripts/report_conformance_funnel.ts"() {
     "use strict";
@@ -44854,10 +45440,10 @@ var init_report_conformance_funnel = __esm({
     init_report_carrier_divergence();
     init_report_skill_activation();
     init_report_skill_obligation_violations();
-    _HERE24 = fileURLToPath48(import.meta.url);
-    REPO_ROOT11 = path91.resolve(path91.dirname(_HERE24), "..", "..");
-    if (_isCliEntry27()) {
-      process22.exit(main36());
+    _HERE25 = fileURLToPath49(import.meta.url);
+    REPO_ROOT11 = path93.resolve(path93.dirname(_HERE25), "..", "..");
+    if (_isCliEntry28()) {
+      process22.exit(main37());
     }
   }
 });
@@ -44878,16 +45464,16 @@ __export(cmd_conformance_exports, {
   conformanceLogPath: () => conformanceLogPath,
   detectSmokePlatform: () => detectSmokePlatform,
   installLogPath: () => installLogPath,
-  main: () => main37,
+  main: () => main38,
   routeTargetPaths: () => routeTargetPaths,
   runConformanceChecks: () => runConformanceChecks
 });
-import * as fs91 from "node:fs";
+import * as fs93 from "node:fs";
 import * as os22 from "node:os";
-import * as path92 from "node:path";
+import * as path94 from "node:path";
 import process23 from "node:process";
-import { spawnSync as spawnSync14 } from "node:child_process";
-import { fileURLToPath as fileURLToPath49, pathToFileURL as pathToFileURL34 } from "node:url";
+import { spawnSync as spawnSync15 } from "node:child_process";
+import { fileURLToPath as fileURLToPath50, pathToFileURL as pathToFileURL35 } from "node:url";
 function print3(s = "") {
   process23.stdout.write(`${s}
 `);
@@ -44901,17 +45487,17 @@ function conformanceLogPath() {
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path92.join(os22.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+  return path94.join(os22.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
 }
 function installLogPath() {
   const override = process23.env["AGENT_CONFIG_INSTALL_LOG"];
   if (override && override.trim().length > 0) {
     return override;
   }
-  return path92.join(os22.homedir(), ".event4u", "agent-config", "install-log.jsonl");
+  return path94.join(os22.homedir(), ".event4u", "agent-config", "install-log.jsonl");
 }
 function _check_txlog_clean(logPath = installLogPath()) {
-  if (!fs91.existsSync(logPath)) {
+  if (!fs93.existsSync(logPath)) {
     return {
       id: "txlog-clean",
       status: "ok",
@@ -44945,11 +45531,11 @@ function _check_txlog_clean(logPath = installLogPath()) {
   };
 }
 function routeTargetPaths(target) {
-  return routeTargetPathsPosix(target).map((rel) => path92.join(...rel.split("/")));
+  return routeTargetPathsPosix(target).map((rel) => path94.join(...rel.split("/")));
 }
 function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
-  const routerPath = path92.join(packageRoot, "dist", "router.json");
-  if (!fs91.existsSync(routerPath)) {
+  const routerPath = path94.join(packageRoot, "dist", "router.json");
+  if (!fs93.existsSync(routerPath)) {
     return {
       id: "router-pointers",
       status: "fail",
@@ -44959,7 +45545,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
   }
   let router;
   try {
-    router = JSON.parse(fs91.readFileSync(routerPath, "utf8"));
+    router = JSON.parse(fs93.readFileSync(routerPath, "utf8"));
   } catch (exc) {
     return {
       id: "router-pointers",
@@ -44968,13 +45554,13 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
       remedy: "reinstall the package \u2014 dist/router.json is corrupt"
     };
   }
-  const rulesDir = path92.join(packageRoot, "dist", "agent-src", "rules");
+  const rulesDir = path94.join(packageRoot, "dist", "agent-src", "rules");
   const broken = [];
   let ids = 0;
   let targets = 0;
   for (const kernelId of router["kernel"] ?? []) {
     ids += 1;
-    if (!fs91.existsSync(path92.join(rulesDir, `${kernelId}.md`))) {
+    if (!fs93.existsSync(path94.join(rulesDir, `${kernelId}.md`))) {
       broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
     }
   }
@@ -44982,7 +45568,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
     for (const entry of router[tier] ?? []) {
       const ruleId = String(entry["id"] ?? "");
       ids += 1;
-      if (!fs91.existsSync(path92.join(rulesDir, `${ruleId}.md`))) {
+      if (!fs93.existsSync(path94.join(rulesDir, `${ruleId}.md`))) {
         broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
       }
       for (const target of entry["routes_to"] ?? []) {
@@ -44992,7 +45578,7 @@ function _check_router_pointers(packageRoot = PACKAGE_ROOT2) {
           broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
           continue;
         }
-        if (!candidates.some((rel) => fs91.existsSync(path92.join(packageRoot, rel)))) {
+        if (!candidates.some((rel) => fs93.existsSync(path94.join(packageRoot, rel)))) {
           broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
         }
       }
@@ -45024,9 +45610,9 @@ function detectSmokePlatform(projectRoot) {
   return "claude";
 }
 function dispatcherRunner(packageRoot) {
-  const localTsx = path92.join(packageRoot, "node_modules", ".bin", "tsx");
-  const script = path92.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
-  if (fs91.existsSync(localTsx)) {
+  const localTsx = path94.join(packageRoot, "node_modules", ".bin", "tsx");
+  const script = path94.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
+  if (fs93.existsSync(localTsx)) {
     return [localTsx, script];
   }
   return ["npx", "tsx", script];
@@ -45043,7 +45629,7 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT2, opts =
       ...event === "stop" ? { stop_reason: "conformance-smoke" } : { source: "startup" }
     });
     const argv = [...runner, "--platform", platform, "--event", event];
-    const proc = spawnSync14(argv[0], argv.slice(1), {
+    const proc = spawnSync15(argv[0], argv.slice(1), {
       input: payload,
       cwd: projectRoot,
       encoding: "utf8",
@@ -45076,12 +45662,12 @@ function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT2, opts =
   };
 }
 function readSettingsMode(projectRoot) {
-  const settingsPath = path92.join(projectRoot, ".agent-settings.yml");
-  if (!fs91.existsSync(settingsPath)) {
+  const settingsPath = path94.join(projectRoot, ".agent-settings.yml");
+  if (!fs93.existsSync(settingsPath)) {
     return "eager-all";
   }
   try {
-    const parsed = YAML7.parse(fs91.readFileSync(settingsPath, "utf8"));
+    const parsed = YAML7.parse(fs93.readFileSync(settingsPath, "utf8"));
     const lean = parsed?.["lean_projection"] ?? null;
     const mode = lean?.["mode"];
     return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
@@ -45092,7 +45678,7 @@ function readSettingsMode(projectRoot) {
 function kernelIdsFromRouter(packageRoot) {
   try {
     const router = JSON.parse(
-      fs91.readFileSync(path92.join(packageRoot, "dist", "router.json"), "utf8")
+      fs93.readFileSync(path94.join(packageRoot, "dist", "router.json"), "utf8")
     );
     return new Set((router["kernel"] ?? []).map(String));
   } catch {
@@ -45109,8 +45695,8 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT2, projec
       remedy: "set lean_projection.mode to 'eager-all' or 'thin' in .agent-settings.yml"
     };
   }
-  const rulesDir = projectedRulesDir ?? path92.join(projectRoot, ".augment", "rules");
-  if (!fs91.existsSync(rulesDir)) {
+  const rulesDir = projectedRulesDir ?? path94.join(projectRoot, ".augment", "rules");
+  if (!fs93.existsSync(rulesDir)) {
     return {
       id: "lean-projection",
       status: "skipped",
@@ -45119,7 +45705,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT2, projec
     };
   }
   const kernel = kernelIdsFromRouter(packageRoot);
-  const files = fs91.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const files = fs93.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
   const nonKernel = files.filter((f) => !kernel.has(f.replace(/\.md$/, "")));
   if (nonKernel.length === 0) {
     return {
@@ -45133,7 +45719,7 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT2, projec
   for (const f of nonKernel) {
     let text = "";
     try {
-      text = fs91.readFileSync(path92.join(rulesDir, f), "utf8");
+      text = fs93.readFileSync(path94.join(rulesDir, f), "utf8");
     } catch {
       continue;
     }
@@ -45164,8 +45750,8 @@ function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT2, projec
 function _check_host_manifest(projectRoot) {
   const detected = Object.entries(detectToolPresence(projectRoot)).filter(([, v]) => v === true).map(([k]) => k);
   const detectedNote = detected.length > 0 ? `detected surfaces: ${detected.join(", ")}` : "no surfaces detected";
-  const settingsPath = path92.join(projectRoot, ".agent-settings.yml");
-  if (!fs91.existsSync(settingsPath)) {
+  const settingsPath = path94.join(projectRoot, ".agent-settings.yml");
+  if (!fs93.existsSync(settingsPath)) {
     return {
       id: "host-manifest",
       status: "ok",
@@ -45175,7 +45761,7 @@ function _check_host_manifest(projectRoot) {
   }
   let parsed = null;
   try {
-    parsed = YAML7.parse(fs91.readFileSync(settingsPath, "utf8"));
+    parsed = YAML7.parse(fs93.readFileSync(settingsPath, "utf8"));
   } catch (exc) {
     return {
       id: "host-manifest",
@@ -45242,7 +45828,7 @@ function _parse4(argv) {
   while (i < argv.length) {
     const a = argv[i];
     if (a === "-h" || a === "--help") {
-      process23.stdout.write(USAGE4);
+      process23.stdout.write(USAGE5);
       throw new ArgparseExit4(0);
     }
     if (a === "--json") {
@@ -45256,7 +45842,7 @@ function _parse4(argv) {
         opts.project = a.slice(a.indexOf("=") + 1);
       } else {
         if (i + 1 >= argv.length) {
-          process23.stderr.write(USAGE4);
+          process23.stderr.write(USAGE5);
           process23.stderr.write("agent-config conformance: error: --project expects a value\n");
           throw new ArgparseExit4(2);
         }
@@ -45264,7 +45850,7 @@ function _parse4(argv) {
         i += 1;
       }
     } else {
-      process23.stderr.write(USAGE4);
+      process23.stderr.write(USAGE5);
       process23.stderr.write(`agent-config conformance: error: unrecognized argument ${a}
 `);
       throw new ArgparseExit4(2);
@@ -45273,7 +45859,7 @@ function _parse4(argv) {
   }
   return opts;
 }
-function main37(argv = null) {
+function main38(argv = null) {
   const opts = _parse4(argv !== null ? Array.from(argv) : process23.argv.slice(2));
   if (opts.funnel) {
     print3(render7(buildFunnel()));
@@ -45344,23 +45930,23 @@ function main37(argv = null) {
   }
   return failed ? 1 : 0;
 }
-function _isCliEntry28() {
+function _isCliEntry29() {
   if (process23.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL34(path92.resolve(process23.argv[1])).href;
+  const argvUrl = pathToFileURL35(path94.resolve(process23.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs91.realpathSync(fileURLToPath49(import.meta.url));
-    const argv = fs91.realpathSync(path92.resolve(process23.argv[1]));
+    const here = fs93.realpathSync(fileURLToPath50(import.meta.url));
+    const argv = fs93.realpathSync(path94.resolve(process23.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var YAML7, _HERE25, PACKAGE_ROOT2, CONFORMANCE_CHECK_IDS, THIN_STUB_MARKER, USAGE4;
+var YAML7, _HERE26, PACKAGE_ROOT2, CONFORMANCE_CHECK_IDS, THIN_STUB_MARKER, USAGE5;
 var init_cmd_conformance = __esm({
   "src/scripts/_cli/cmd_conformance.ts"() {
     "use strict";
@@ -45373,7 +45959,7 @@ var init_cmd_conformance = __esm({
     init_router_target_paths();
     init_report_conformance_funnel();
     init_cmd_doctor();
-    _HERE25 = fileURLToPath49(import.meta.url);
+    _HERE26 = fileURLToPath50(import.meta.url);
     PACKAGE_ROOT2 = resolvePackageRoot(import.meta.url);
     CONFORMANCE_CHECK_IDS = [
       "txlog-clean",
@@ -45383,10 +45969,10 @@ var init_cmd_conformance = __esm({
       "host-manifest"
     ];
     THIN_STUB_MARKER = "Routed rule \u2014 load the body on trigger-match";
-    USAGE4 = "usage: agent-config conformance [-h] [--project PROJECT] [--json]\n                                [--skip-dispatcher] [--funnel]\n";
-    if (_isCliEntry28() || process23.argv[1] === _HERE25) {
+    USAGE5 = "usage: agent-config conformance [-h] [--project PROJECT] [--json]\n                                [--skip-dispatcher] [--funnel]\n";
+    if (_isCliEntry29() || process23.argv[1] === _HERE26) {
       try {
-        process23.exitCode = main37(process23.argv.slice(2));
+        process23.exitCode = main38(process23.argv.slice(2));
       } catch (e) {
         if (e instanceof ArgparseExit4) {
           process23.exitCode = e.code;
@@ -45421,7 +46007,7 @@ __export(settings_exports, {
   read_tier_usage_settings: () => read_tier_usage_settings
 });
 import { createRequire as createRequire7 } from "node:module";
-import * as fs92 from "node:fs";
+import * as fs94 from "node:fs";
 function _isPlainObject8(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date);
 }
@@ -45458,7 +46044,7 @@ function _coerce_path(value, def) {
 }
 function _isFile15(p) {
   try {
-    return fs92.statSync(p).isFile();
+    return fs94.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -45469,7 +46055,7 @@ function _read_telemetry_section(p, key) {
   }
   let raw = {};
   try {
-    raw = YAML8.parse(fs92.readFileSync(p, "utf-8"), { version: "1.1" });
+    raw = YAML8.parse(fs94.readFileSync(p, "utf-8"), { version: "1.1" });
     if (raw === null || raw === void 0) {
       raw = {};
     }
@@ -46113,7 +46699,7 @@ __export(aggregator_exports, {
   aggregate: () => aggregate2,
   rank_artefacts: () => rank_artefacts
 });
-import * as fs93 from "node:fs";
+import * as fs95 from "node:fs";
 function _key(kind, artId) {
   return `${kind}\0${artId}`;
 }
@@ -46150,7 +46736,7 @@ function* _iter_events(log_path) {
   if (!_isFile16(log_path)) {
     return;
   }
-  const text = fs93.readFileSync(log_path, "utf-8");
+  const text = fs95.readFileSync(log_path, "utf-8");
   const lines = _pyFileLines(text);
   let lineNo = 0;
   for (const line of lines) {
@@ -46184,7 +46770,7 @@ function _pyFileLines(text) {
 }
 function _isFile16(p) {
   try {
-    return fs93.statSync(p).isFile();
+    return fs95.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -46772,14 +47358,14 @@ var init_report_renderer = __esm({
 });
 
 // src/scripts/ai_council/bundler.ts
-import * as fs94 from "node:fs";
+import * as fs96 from "node:fs";
 function _context(mode, text, manifest = [], excluded = []) {
   return { mode, text, manifest, excluded };
 }
 function _utf8Len(s) {
   return Buffer.byteLength(s, "utf-8");
 }
-function _splitlines8(s) {
+function _splitlines9(s) {
   if (s === "") {
     return [];
   }
@@ -46791,7 +47377,7 @@ function _splitlines8(s) {
 }
 function redact(text) {
   const out = [];
-  for (const line of _splitlines8(text)) {
+  for (const line of _splitlines9(text)) {
     let replaced = line;
     for (const [pattern, placeholder] of _REDACTION_LINE_PATTERNS) {
       if (pattern.test(replaced)) {
@@ -46830,10 +47416,10 @@ function bundle_prompt(text) {
   return _context("prompt", _enforceSize(redacted, "prompt"), ["<inline prompt>"]);
 }
 function bundle_roadmap(p) {
-  if (!fs94.existsSync(p)) {
+  if (!fs96.existsSync(p)) {
     throw new FileNotFoundError2(`Roadmap not found: ${p}`);
   }
-  const raw = fs94.readFileSync(p, { encoding: "utf-8" });
+  const raw = fs96.readFileSync(p, { encoding: "utf-8" });
   const redacted = redact(raw);
   return _context(
     "roadmap",
@@ -47011,8 +47597,8 @@ function aggregate_scores(findings, scores) {
     by_id.get(s.finding_id).push(s);
   }
   const out = /* @__PURE__ */ new Map();
-  for (const [fid, fs106] of by_id) {
-    if (fs106.length === 0) {
+  for (const [fid, fs108] of by_id) {
+    if (fs108.length === 0) {
       out.set(
         fid,
         new ConsensusMetadata({
@@ -47028,13 +47614,13 @@ function aggregate_scores(findings, scores) {
       );
       continue;
     }
-    const mean2 = fs106.reduce((acc, s) => acc + s.score, 0) / fs106.length;
-    const agree_rate = fs106.filter((s) => s.agree).length / fs106.length;
+    const mean2 = fs108.reduce((acc, s) => acc + s.score, 0) / fs108.length;
+    const agree_rate = fs108.filter((s) => s.agree).length / fs108.length;
     const strength = mean2 / 10 * agree_rate;
-    const dissent = fs106.filter((s) => !s.agree).length;
-    const concur = fs106.filter((s) => s.agree).length;
-    const scorers = fs106.map((s) => s.scorer);
-    const dissent_reasons = fs106.filter((s) => !s.agree).map((s) => [s.scorer, s.reason]);
+    const dissent = fs108.filter((s) => !s.agree).length;
+    const concur = fs108.filter((s) => s.agree).length;
+    const scorers = fs108.map((s) => s.scorer);
+    const dissent_reasons = fs108.filter((s) => !s.agree).map((s) => [s.scorer, s.reason]);
     const mean_rounded = pyRound(mean2, 2);
     out.set(
       fid,
@@ -47474,26 +48060,26 @@ One sentence, and the single strongest reason.`;
 });
 
 // src/scripts/ai_council/recouncil_guard.ts
-import * as fs95 from "node:fs";
-import * as path93 from "node:path";
+import * as fs97 from "node:fs";
+import * as path95 from "node:path";
 function configFingerprint(members, rounds) {
   return `${[...members].sort().join(",")}|rounds=${String(rounds)}`;
 }
 function readPriorRuns(responsesDir, repoRoot) {
   let names;
   try {
-    names = fs95.readdirSync(responsesDir).filter((f) => f.endsWith(".md"));
+    names = fs97.readdirSync(responsesDir).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
   const out = [];
   for (const name of names) {
-    const abs = path93.join(responsesDir, name);
+    const abs = path95.join(responsesDir, name);
     let head;
     let stat;
     try {
-      stat = fs95.statSync(abs);
-      const text = fs95.readFileSync(abs, "utf8");
+      stat = fs97.statSync(abs);
+      const text = fs97.readFileSync(abs, "utf8");
       const json = _leadingJson(text);
       if (json === null) continue;
       head = JSON.parse(json);
@@ -47507,7 +48093,7 @@ function readPriorRuns(responsesDir, repoRoot) {
     let questionText = null;
     if (questionPath !== "") {
       try {
-        const q = fs95.readFileSync(path93.join(repoRoot, questionPath), "utf8");
+        const q = fs97.readFileSync(path95.join(repoRoot, questionPath), "utf8");
         questionHash = _sha256_hex(q);
         questionText = q;
       } catch {
@@ -47588,14 +48174,14 @@ function warnIfRecounciled(repoRoot, questionFile, fallbackText, members, rounds
   try {
     let text = fallbackText;
     try {
-      text = fs95.readFileSync(path93.resolve(repoRoot, questionFile), "utf8");
+      text = fs97.readFileSync(path95.resolve(repoRoot, questionFile), "utf8");
     } catch {
     }
     const v = checkRecouncil(
       text,
       // `name/model` — the SAME shape the artefact writer records.
       configFingerprint(members.map((m) => `${m.name}/${m.model}`), rounds),
-      readPriorRuns(path93.join(repoRoot, "agents/runtime/council/responses"), repoRoot)
+      readPriorRuns(path95.join(repoRoot, "agents/runtime/council/responses"), repoRoot)
     );
     if (v !== null) write(renderRecouncilWarning(v));
   } catch {
@@ -47707,7 +48293,7 @@ function _pyReprStr2(s) {
 function _pyRepr9(value) {
   return value === null ? "None" : _pyReprStr2(value);
 }
-function _splitlines9(text) {
+function _splitlines10(text) {
   if (text === "") {
     return [];
   }
@@ -47787,7 +48373,7 @@ function _strip_host_identity(text) {
     return text;
   }
   const kept = [];
-  for (const line of _splitlines9(text)) {
+  for (const line of _splitlines10(text)) {
     const low = line.toLowerCase();
     if (HOST_AGENT_IDENTITY_PATTERNS.some((needle) => low.includes(needle))) {
       continue;
@@ -47816,7 +48402,7 @@ function handoff_preamble(project, original_ask) {
   }
   const cleaned_ask = _pyStrip3(_strip_host_identity(original_ask || ""));
   if (cleaned_ask) {
-    const quoted = _splitlines9(cleaned_ask).map((ln) => `> ${ln}`).join("\n");
+    const quoted = _splitlines10(cleaned_ask).map((ln) => `> ${ln}`).join("\n");
     blocks.push(`The user originally asked:
 ${quoted}`);
   }
@@ -48224,8 +48810,8 @@ not. Cite the peer-reviewer label and the targeted response label
 });
 
 // src/scripts/ai_council/advisors.ts
-import * as fs96 from "node:fs";
-import * as path94 from "node:path";
+import * as fs98 from "node:fs";
+import * as path96 from "node:path";
 function _split_frontmatter2(raw) {
   const match = _FRONTMATTER_RE2.exec(raw);
   if (!match) {
@@ -48253,12 +48839,12 @@ function _display_name_from(advisor_name, frontmatter) {
 }
 function resolve_persona_text(persona_path, repo_root2) {
   const candidates = [
-    path94.join(repo_root2, "dist/agent-src", persona_path),
-    path94.join(repo_root2, ".agent-src.uncondensed", persona_path)
+    path96.join(repo_root2, "dist/agent-src", persona_path),
+    path96.join(repo_root2, ".agent-src.uncondensed", persona_path)
   ];
   for (const candidate of candidates) {
-    if (fs96.existsSync(candidate)) {
-      const raw = fs96.readFileSync(candidate, "utf-8");
+    if (fs98.existsSync(candidate)) {
+      const raw = fs98.readFileSync(candidate, "utf-8");
       const [meta, body] = _split_frontmatter2(raw);
       return [body.trim(), meta];
     }
@@ -49066,15 +49652,15 @@ var init_qualification = __esm({
 });
 
 // src/scripts/ai_council/probe_store.ts
-import fs97 from "node:fs";
-import path95 from "node:path";
+import fs99 from "node:fs";
+import path97 from "node:path";
 function probeStorePath(root) {
-  return path95.join(root, PROBE_STORE_RELPATH);
+  return path97.join(root, PROBE_STORE_RELPATH);
 }
 function readProbeStore(root) {
   let raw;
   try {
-    raw = fs97.readFileSync(probeStorePath(root), "utf8");
+    raw = fs99.readFileSync(probeStorePath(root), "utf8");
   } catch {
     return EMPTY;
   }
@@ -49124,8 +49710,8 @@ function recordProbes(root, entries) {
       members[e.name] = { at: e.at, outcome: e.outcome };
     }
     const target = probeStorePath(root);
-    fs97.mkdirSync(path95.dirname(target), { recursive: true });
-    fs97.writeFileSync(target, `${JSON.stringify({ schema: 1, members }, null, 2)}
+    fs99.mkdirSync(path97.dirname(target), { recursive: true });
+    fs99.writeFileSync(target, `${JSON.stringify({ schema: 1, members }, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -49139,7 +49725,7 @@ var init_probe_store = __esm({
     "use strict";
     init_env_kill_switch();
     _KILL_SWITCH_ENV2 = "AGENT_CONFIG_NO_EVENTS_LOG";
-    PROBE_STORE_RELPATH = path95.join("agents", "runtime", "state", "council-probes.json");
+    PROBE_STORE_RELPATH = path97.join("agents", "runtime", "state", "council-probes.json");
     EMPTY = { schema: 1, members: {} };
     VALID_OUTCOMES = /* @__PURE__ */ new Set([
       "ok",
@@ -49443,10 +50029,10 @@ var init_council_fallback_posture = __esm({
 });
 
 // src/scripts/_lib/billing_grant.ts
-import * as fs98 from "node:fs";
-import * as path96 from "node:path";
+import * as fs100 from "node:fs";
+import * as path98 from "node:path";
 function grantFile(repoRoot, runId) {
-  return path96.join(
+  return path98.join(
     repoRoot,
     BILLING_GRANT_DIR_REL,
     `${runId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`
@@ -49457,8 +50043,8 @@ function issueBillingGrant(repoRoot, runId, now = () => /* @__PURE__ */ new Date
   const existing = _read(file);
   if (existing !== null && existing.run_id === runId) return existing;
   const grant = { run_id: runId, issued_at: now().toISOString() };
-  fs98.mkdirSync(path96.dirname(file), { recursive: true });
-  fs98.writeFileSync(file, `${JSON.stringify(grant, null, 2)}
+  fs100.mkdirSync(path98.dirname(file), { recursive: true });
+  fs100.writeFileSync(file, `${JSON.stringify(grant, null, 2)}
 `, "utf8");
   return grant;
 }
@@ -49476,13 +50062,13 @@ function hasBillingGrant(repoRoot, env = process.env, now = () => /* @__PURE__ *
 }
 function revokeBillingGrant(repoRoot, runId) {
   try {
-    fs98.unlinkSync(grantFile(repoRoot, runId));
+    fs100.unlinkSync(grantFile(repoRoot, runId));
   } catch {
   }
 }
 function _read(file) {
   try {
-    const raw = JSON.parse(fs98.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs100.readFileSync(file, "utf8"));
     if (raw === null || typeof raw !== "object") return null;
     const o = raw;
     if (typeof o.run_id !== "string" || typeof o.issued_at !== "string") return null;
@@ -49503,7 +50089,7 @@ var init_billing_grant = __esm({
   "src/scripts/_lib/billing_grant.ts"() {
     "use strict";
     BILLING_GRANT_ENV = "AC_BILLING_GRANT";
-    BILLING_GRANT_DIR_REL = path96.join("agents", "runtime", "billing-grants");
+    BILLING_GRANT_DIR_REL = path98.join("agents", "runtime", "billing-grants");
     BILLING_GRANT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -49592,10 +50178,10 @@ var init_council_fallback_wiring = __esm({
 });
 
 // src/scripts/_lib/quota_parked.ts
-import * as fs99 from "node:fs";
-import * as path97 from "node:path";
+import * as fs101 from "node:fs";
+import * as path99 from "node:path";
 function markerFile(repoRoot, runId) {
-  return path97.join(
+  return path99.join(
     repoRoot,
     QUOTA_PARKED_DIR_REL,
     `${runId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`
@@ -49610,14 +50196,14 @@ function writeQuotaParked(repoRoot, runId, providers, now = () => /* @__PURE__ *
     providers: merged,
     parked_at: existing?.parked_at ?? now().toISOString()
   };
-  fs99.mkdirSync(path97.dirname(file), { recursive: true });
-  fs99.writeFileSync(file, `${JSON.stringify(marker, null, 2)}
+  fs101.mkdirSync(path99.dirname(file), { recursive: true });
+  fs101.writeFileSync(file, `${JSON.stringify(marker, null, 2)}
 `, "utf8");
   return marker;
 }
 function readMarker(file) {
   try {
-    const raw = JSON.parse(fs99.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs101.readFileSync(file, "utf8"));
     if (raw === null || typeof raw !== "object") return null;
     const o = raw;
     if (typeof o["run_id"] !== "string" || typeof o["parked_at"] !== "string") return null;
@@ -49632,7 +50218,7 @@ var QUOTA_PARKED_DIR_REL;
 var init_quota_parked = __esm({
   "src/scripts/_lib/quota_parked.ts"() {
     "use strict";
-    QUOTA_PARKED_DIR_REL = path97.join("agents", "runtime", "state", "quota-parked");
+    QUOTA_PARKED_DIR_REL = path99.join("agents", "runtime", "state", "quota-parked");
   }
 });
 
@@ -49702,7 +50288,7 @@ __export(low_impact_corpus_exports, {
   load_validated_phrases: () => load_validated_phrases,
   parse_corpus_strict: () => parse_corpus_strict
 });
-import * as fs100 from "node:fs";
+import * as fs102 from "node:fs";
 function _entry(phrase, normalised, section, line_no, trailing_metadata = "") {
   return { phrase, normalised, section, line_no, trailing_metadata };
 }
@@ -49749,7 +50335,7 @@ function _lineNoAt(text, offset) {
   }
   return count + 1;
 }
-function _splitlines10(s) {
+function _splitlines11(s) {
   if (s === "") {
     return [];
   }
@@ -49764,7 +50350,7 @@ function _scanSection(text, section, bodyStart, bodyEnd, strict) {
   const warnings = [];
   const body = text.slice(bodyStart, bodyEnd);
   const baseLine = _lineNoAt(text, bodyStart);
-  const bodyLines = _splitlines10(body);
+  const bodyLines = _splitlines11(body);
   for (let offset = 0; offset < bodyLines.length; offset += 1) {
     const rawLine = bodyLines[offset];
     const lineNo = baseLine + offset;
@@ -49875,10 +50461,10 @@ function _checkHeadingDrift(text, title) {
 }
 function parse_corpus_strict(corpusPath) {
   const p = corpusPath;
-  if (!fs100.existsSync(p)) {
+  if (!fs102.existsSync(p)) {
     return new CorpusParseResult();
   }
-  const text = fs100.readFileSync(p, { encoding: "utf-8" });
+  const text = fs102.readFileSync(p, { encoding: "utf-8" });
   const allTitles = _SECTION_KEYS.map((k) => _SECTION_TITLES[k]);
   const resultSections = {
     validated: [],
@@ -49941,10 +50527,10 @@ function load_anti_example_phrases(corpusPath) {
 }
 function load_corpus_lock(yamlPath) {
   const p = yamlPath;
-  if (!fs100.existsSync(p)) {
+  if (!fs102.existsSync(p)) {
     return new CorpusParseResult();
   }
-  const parsed = (0, import_yaml8.parse)(fs100.readFileSync(p, { encoding: "utf-8" }), { version: "1.1" });
+  const parsed = (0, import_yaml8.parse)(fs102.readFileSync(p, { encoding: "utf-8" }), { version: "1.1" });
   const doc = parsed === null || parsed === void 0 ? {} : parsed;
   const schemaVersion = doc["schema_version"];
   if (schemaVersion !== 1) {
@@ -50006,7 +50592,7 @@ function _deriveLockPath(corpusPath) {
 }
 function _loadSectionFromLock(corpusPath, section) {
   const lockPath = _deriveLockPath(corpusPath);
-  if (!fs100.existsSync(lockPath)) {
+  if (!fs102.existsSync(lockPath)) {
     return null;
   }
   try {
@@ -50018,10 +50604,10 @@ function _loadSectionFromLock(corpusPath, section) {
 }
 function _loadSectionLenient(corpusPath, section) {
   const p = corpusPath;
-  if (!fs100.existsSync(p)) {
+  if (!fs102.existsSync(p)) {
     return [];
   }
-  const text = fs100.readFileSync(p, { encoding: "utf-8" });
+  const text = fs102.readFileSync(p, { encoding: "utf-8" });
   const allTitles = _SECTION_KEYS.map((k) => _SECTION_TITLES[k]);
   const bounds = _sectionBounds(text, _SECTION_TITLES[section], allTitles);
   if (bounds === null) {
@@ -51149,8 +51735,8 @@ var init_consensus_round = __esm({
 });
 
 // src/scripts/ai_council/budget_guard.ts
-import * as fs101 from "node:fs";
-import * as path98 from "node:path";
+import * as fs103 from "node:fs";
+import * as path100 from "node:path";
 function _resolveLedgerPath(p) {
   if (p !== null) {
     return p;
@@ -51165,18 +51751,18 @@ function _nowUtcMs() {
   return Date.now();
 }
 function _ensureLedgerDir(p) {
-  const parent = path98.dirname(p);
+  const parent = path100.dirname(p);
   try {
-    fs101.mkdirSync(parent, { recursive: true });
+    fs103.mkdirSync(parent, { recursive: true });
     let mode;
     try {
-      mode = fs101.statSync(parent).mode & 511;
+      mode = fs103.statSync(parent).mode & 511;
     } catch {
       mode = 448;
     }
     if (mode !== 448) {
       try {
-        fs101.chmodSync(parent, 448);
+        fs103.chmodSync(parent, 448);
       } catch {
       }
     }
@@ -51188,18 +51774,18 @@ function _ensureLedgerDir(p) {
   }
 }
 function _ensureLedgerFileMode(p) {
-  if (!fs101.existsSync(p)) {
+  if (!fs103.existsSync(p)) {
     return;
   }
   let current;
   try {
-    current = fs101.statSync(p).mode & 511;
+    current = fs103.statSync(p).mode & 511;
   } catch {
     return;
   }
   if (current !== 384) {
     try {
-      fs101.chmodSync(p, 384);
+      fs103.chmodSync(p, 384);
     } catch {
     }
   }
@@ -51351,11 +51937,11 @@ function pyNumToStr(n) {
 }
 function read_entries2(p = null) {
   const resolved = _resolveLedgerPath(p);
-  if (!fs101.existsSync(resolved)) {
+  if (!fs103.existsSync(resolved)) {
     return [];
   }
   const out = [];
-  const text = fs101.readFileSync(resolved, "utf-8");
+  const text = fs103.readFileSync(resolved, "utf-8");
   for (const rawLine of text.split(/\r\n|\r|\n/u)) {
     const line = rawLine.trim();
     if (line === "") {
@@ -51458,7 +52044,7 @@ function record_spend(usd, provider, model, options = {}) {
   )}
 `;
   try {
-    fs101.appendFileSync(p, entry, { encoding: "utf-8" });
+    fs103.appendFileSync(p, entry, { encoding: "utf-8" });
   } catch (exc) {
     process.stderr.write(`[council:budget_guard] write failed: ${_errStr(exc)}
 `);
@@ -53119,18 +53705,18 @@ __export(project_context_exports, {
   REPO_PURPOSE_MAX_CHARS: () => REPO_PURPOSE_MAX_CHARS,
   detect_project_context: () => detect_project_context
 });
-import * as fs102 from "node:fs";
-import * as path99 from "node:path";
+import * as fs104 from "node:fs";
+import * as path101 from "node:path";
 function _isPlainObject11(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function _read_json(p) {
-  if (!fs102.existsSync(p)) {
+  if (!fs104.existsSync(p)) {
     return null;
   }
   let raw;
   try {
-    raw = fs102.readFileSync(p, "utf-8");
+    raw = fs104.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -53152,7 +53738,7 @@ function _name_from(composer, pkg, root) {
     }
   }
   try {
-    const base = path99.basename(root);
+    const base = path101.basename(root);
     return base || null;
   } catch {
     return null;
@@ -53210,7 +53796,7 @@ function _stack_from(composer, pkg) {
   }
   return parts.join(" \xB7 ");
 }
-function _splitlines11(text) {
+function _splitlines12(text) {
   if (text === "") {
     return [];
   }
@@ -53221,17 +53807,17 @@ function _splitlines11(text) {
   return parts;
 }
 function _purpose_from_readme(p) {
-  if (!fs102.existsSync(p)) {
+  if (!fs104.existsSync(p)) {
     return null;
   }
   let text;
   try {
-    text = fs102.readFileSync(p, "utf-8");
+    text = fs104.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
   const paragraph = [];
-  for (const raw of _splitlines11(text)) {
+  for (const raw of _splitlines12(text)) {
     const stripped = raw.trim();
     if (!stripped) {
       if (paragraph.length > 0) {
@@ -53310,13 +53896,13 @@ function _rfind(haystack, needle) {
   return -1;
 }
 function detect_project_context(root) {
-  const resolvedRoot = path99.resolve(root ?? process.cwd());
-  const composer = _read_json(path99.join(resolvedRoot, "composer.json"));
-  const pkg = _read_json(path99.join(resolvedRoot, "package.json"));
+  const resolvedRoot = path101.resolve(root ?? process.cwd());
+  const composer = _read_json(path101.join(resolvedRoot, "composer.json"));
+  const pkg = _read_json(path101.join(resolvedRoot, "package.json"));
   return new ProjectContext(
     _name_from(composer, pkg, resolvedRoot),
     _stack_from(composer, pkg),
-    _purpose_from_readme(path99.join(resolvedRoot, "README.md"))
+    _purpose_from_readme(path101.join(resolvedRoot, "README.md"))
   );
 }
 var REPO_PURPOSE_MAX_CHARS, _HEADING_RE, _BADGE_RE, _HTML_RE, ProjectContext;
@@ -53586,7 +54172,7 @@ __export(shadow_dispatch_exports, {
   slo_banner: () => slo_banner,
   slo_status: () => slo_status
 });
-import * as fs103 from "node:fs";
+import * as fs105 from "node:fs";
 import { createHash as createHash16 } from "node:crypto";
 function should_shadow(sampleRate, opts = {}) {
   const rate = Math.max(0, Math.min(1, sampleRate));
@@ -53624,7 +54210,7 @@ function record_shadow_decision(logPath, opts) {
     escalated,
     escalation_reason: escalationReason
   };
-  fs103.mkdirSync(_dirname2(logPath), { recursive: true });
+  fs105.mkdirSync(_dirname2(logPath), { recursive: true });
   const row = _pyJsonDumps2({
     timestamp: decision.timestamp,
     query_hash: decision.query_hash,
@@ -53634,7 +54220,7 @@ function record_shadow_decision(logPath, opts) {
     escalated: decision.escalated,
     escalation_reason: decision.escalation_reason
   }) + "\n";
-  fs103.appendFileSync(logPath, row, { encoding: "utf-8" });
+  fs105.appendFileSync(logPath, row, { encoding: "utf-8" });
   return decision;
 }
 function _isoNowSeconds() {
@@ -53643,11 +54229,11 @@ function _isoNowSeconds() {
   return `${pad(d.getUTCFullYear(), 4)}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}+00:00`;
 }
 function* _iterLog(logPath) {
-  if (!fs103.existsSync(logPath)) {
+  if (!fs105.existsSync(logPath)) {
     return;
   }
-  const content = fs103.readFileSync(logPath, { encoding: "utf-8" });
-  for (const rawLine of _splitlines12(content)) {
+  const content = fs105.readFileSync(logPath, { encoding: "utf-8" });
+  for (const rawLine of _splitlines13(content)) {
     const line = _strip8(rawLine);
     if (!line) {
       continue;
@@ -53842,7 +54428,7 @@ function _dirname2(p) {
 function _strip8(s) {
   return s.trim();
 }
-function _splitlines12(s) {
+function _splitlines13(s) {
   if (s === "") {
     return [];
   }
@@ -54001,7 +54587,7 @@ function _pySlice3(s, n) {
 function _pyStrip8(s) {
   return s.trim();
 }
-function _splitlines13(s) {
+function _splitlines14(s) {
   if (s === "") {
     return [];
   }
@@ -54063,7 +54649,7 @@ function _aborted_marker(reason, members) {
   return `> Low-impact council aborted (${reason}) \u2014 escalating to user: members tried: ${names}.`;
 }
 function _split_marker(answers) {
-  const parts = answers.filter((a) => a.ok).map((a) => `${a.member}: ${_pySlice3(_pyStrip8(_splitlines13(a.text)[0] ?? ""), 80)}`).join(" / ");
+  const parts = answers.filter((a) => a.ok).map((a) => `${a.member}: ${_pySlice3(_pyStrip8(_splitlines14(a.text)[0] ?? ""), 80)}`).join(" / ");
   return `> Low-impact council split \u2014 escalating to user (${parts}):`;
 }
 function _unavailable_marker() {
@@ -54079,7 +54665,7 @@ function _resolved_marker(ok_answers) {
   return `> Resolved via low-impact council fast-path: ${verdict}.`;
 }
 function _answer_line(text) {
-  for (const line of _splitlines13(text)) {
+  for (const line of _splitlines14(text)) {
     const stripped = _pyStrip8(line);
     if (stripped !== "") {
       return stripped;
@@ -54307,7 +54893,7 @@ function parse_low_impact_log(text) {
   const by_member = /* @__PURE__ */ new Map();
   let total = 0;
   let total_cost = 0;
-  for (const raw of _splitlines13(text)) {
+  for (const raw of _splitlines14(text)) {
     const m = _LOG_LINE_RE.exec(_pyStrip8(raw));
     if (!m) {
       continue;
@@ -54571,11 +55157,11 @@ __export(council_cli_exports, {
   cmd_status: () => cmd_status,
   format_estimate_table: () => format_estimate_table,
   load_settings: () => load_settings,
-  main: () => main38
+  main: () => main39
 });
-import * as fs104 from "node:fs";
-import * as path100 from "node:path";
-import { fileURLToPath as fileURLToPath50, pathToFileURL as pathToFileURL35 } from "node:url";
+import * as fs106 from "node:fs";
+import * as path102 from "node:path";
+import { fileURLToPath as fileURLToPath51, pathToFileURL as pathToFileURL36 } from "node:url";
 function _pyFixed6(x, ndigits) {
   if (!Number.isFinite(x)) {
     return String(x);
@@ -54783,7 +55369,7 @@ function _stderr2(s) {
 function load_settings(p = SETTINGS_FILE2, opts = {}) {
   const ai_council_path = opts.ai_council_path ?? AI_COUNCIL_FILE;
   const settings = load_agent_settings({ project_path: p });
-  if (fs104.existsSync(ai_council_path)) {
+  if (fs106.existsSync(ai_council_path)) {
     const cfg = load_council_config(ai_council_path);
     settings["ai_council"] = synthesizeAiCouncilBlock(cfg);
   }
@@ -55149,7 +55735,7 @@ function build_question(opts) {
   let ctx;
   let artefact;
   if (input_mode === "prompt") {
-    const text = fs104.readFileSync(input_path, "utf-8");
+    const text = fs106.readFileSync(input_path, "utf-8");
     ctx = bundle_prompt(text);
     artefact = String(input_path);
   } else if (input_mode === "roadmap") {
@@ -55293,9 +55879,9 @@ function _maybe_write_decision_replay(opts) {
       include_member_arguments: include_args
     })
   );
-  const target = path100.join(path100.dirname(opts.out_path), "decision-replay.md");
-  fs104.mkdirSync(path100.dirname(target), { recursive: true });
-  fs104.writeFileSync(target, replay, { encoding: "utf-8" });
+  const target = path102.join(path102.dirname(opts.out_path), "decision-replay.md");
+  fs106.mkdirSync(path102.dirname(target), { recursive: true });
+  fs106.writeFileSync(target, replay, { encoding: "utf-8" });
   return target;
 }
 function _peer_review_active(ai_cfg, args) {
@@ -55968,7 +56554,7 @@ function cmd_status(args, opts = {}) {
   const env = opts.env ?? process.env;
   const override = env[COUNCIL_CONFIG_ENV];
   const path_ = resolve_config_path(REPO_ROOT12, { env });
-  const exists3 = fs104.existsSync(String(path_));
+  const exists3 = fs106.existsSync(String(path_));
   const provenance = override ? `${COUNCIL_CONFIG_ENV} override` : "user-global";
   let cfg = null;
   let parse_error = null;
@@ -56436,8 +57022,8 @@ function cmd_run(args, opts = {}) {
     kind: "responses",
     subcommand: "run"
   });
-  fs104.mkdirSync(path100.dirname(_resolveTarget(out_path)), { recursive: true });
-  fs104.writeFileSync(_resolveTarget(out_path), _jsonDumpsIndent2(payload) + "\n", { encoding: "utf-8" });
+  fs106.mkdirSync(path102.dirname(_resolveTarget(out_path)), { recursive: true });
+  fs106.writeFileSync(_resolveTarget(out_path), _jsonDumpsIndent2(payload) + "\n", { encoding: "utf-8" });
   const _all_subscription = allSeatsNonBillable(all_responses);
   _stdout2(
     `
@@ -56463,7 +57049,7 @@ function _debate_round_filename(round_number) {
   return `debate-round-${round_number}.json`;
 }
 function _write_debate_round(out_dir, round_number, responses, opts) {
-  fs104.mkdirSync(_resolveTarget(out_dir), { recursive: true });
+  fs106.mkdirSync(_resolveTarget(out_dir), { recursive: true });
   const actual_total = sumBillableCost(responses, opts.table);
   const payload = {
     schema_version: SCHEMA_VERSION9,
@@ -56480,15 +57066,15 @@ function _write_debate_round(out_dir, round_number, responses, opts) {
     prompt_cache_round_gap_ms: opts.cache_gap_ms_since_previous_round ?? null,
     responses: serializeResponses(responses)
   };
-  const out_path = path100.join(_resolveTarget(out_dir), _debate_round_filename(round_number));
-  fs104.writeFileSync(out_path, _jsonDumpsIndent2(payload) + "\n", { encoding: "utf-8" });
+  const out_path = path102.join(_resolveTarget(out_dir), _debate_round_filename(round_number));
+  fs106.writeFileSync(out_path, _jsonDumpsIndent2(payload) + "\n", { encoding: "utf-8" });
   return out_path;
 }
 function _load_debate_seed(p, expected_members) {
-  if (!fs104.existsSync(p)) {
+  if (!fs106.existsSync(p)) {
     throw new FileNotFoundError3(`--continue-as-debate path not found: ${p}`);
   }
-  const payload = JSON.parse(fs104.readFileSync(p, "utf-8"));
+  const payload = JSON.parse(fs106.readFileSync(p, "utf-8"));
   const source_members = (payload["members"] || []).slice();
   const expected_labels = expected_members.map((m) => `${m.name}/${m.model}`);
   if (!_listEq(source_members, expected_labels)) {
@@ -56534,7 +57120,7 @@ function _readStdinLine() {
   try {
     const buf = Buffer.alloc(4096);
     const fd = 0;
-    const n = fs104.readSync(fd, buf, 0, buf.length, null);
+    const n = fs106.readSync(fd, buf, 0, buf.length, null);
     return buf.toString("utf-8", 0, n).split("\n")[0]?.trim().toLowerCase() ?? "";
   } catch {
     return "";
@@ -56762,7 +57348,7 @@ council:debate \xB7 ${all_rounds.length} round(s) complete \xB7 actual $${_pyFix
   return errors_last.length > 0 && errors_last.length === last.length ? 1 : 0;
 }
 function cmd_render(args) {
-  const payload = JSON.parse(fs104.readFileSync(args.responses, "utf-8"));
+  const payload = JSON.parse(fs106.readFileSync(args.responses, "utf-8"));
   const items = payload["responses"] || [];
   const explicit = _getattr3(args, "prompt_mode", null);
   const mode = explicit || payload["prompt_mode"] || payload["mode"];
@@ -56791,8 +57377,8 @@ function cmd_render(args) {
       kind: "sessions",
       subcommand: "render"
     });
-    fs104.mkdirSync(path100.dirname(_resolveTarget(out_path)), { recursive: true });
-    fs104.writeFileSync(_resolveTarget(out_path), body + "\n", { encoding: "utf-8" });
+    fs106.mkdirSync(path102.dirname(_resolveTarget(out_path)), { recursive: true });
+    fs106.writeFileSync(_resolveTarget(out_path), body + "\n", { encoding: "utf-8" });
     _stdout2(`council:render \xB7 wrote ${out_path}
 `);
     return 0;
@@ -56803,15 +57389,15 @@ function cmd_render(args) {
 function _cmd_replay_low_impact_stats(args) {
   const li = low_impact_exports;
   const responses_path = args.responses;
-  const log_path = path100.join(path100.dirname(responses_path), "low-impact-resolutions.md");
-  if (!fs104.existsSync(log_path)) {
+  const log_path = path102.join(path102.dirname(responses_path), "low-impact-resolutions.md");
+  if (!fs106.existsSync(log_path)) {
     _stdout2(
       `council:replay \xB7 no low-impact-resolutions.md alongside ${responses_path} \u2014 session had no fast-path entries.
 `
     );
     return 0;
   }
-  const body = fs104.readFileSync(log_path, "utf-8");
+  const body = fs106.readFileSync(log_path, "utf-8");
   const stats = li.parse_low_impact_log(body);
   const out = li.render_low_impact_stats(stats);
   if (_getattr3(args, "output", null)) {
@@ -56819,8 +57405,8 @@ function _cmd_replay_low_impact_stats(args) {
       kind: "sessions",
       subcommand: "replay"
     });
-    fs104.mkdirSync(path100.dirname(_resolveTarget(target)), { recursive: true });
-    fs104.writeFileSync(_resolveTarget(target), out, { encoding: "utf-8" });
+    fs106.mkdirSync(path102.dirname(_resolveTarget(target)), { recursive: true });
+    fs106.writeFileSync(_resolveTarget(target), out, { encoding: "utf-8" });
     _stdout2(`council:replay \xB7 wrote ${target}
 `);
     return 0;
@@ -56832,7 +57418,7 @@ function cmd_replay(args) {
   if (_getattr3(args, "low_impact_stats", false)) {
     return _cmd_replay_low_impact_stats(args);
   }
-  const payload = JSON.parse(fs104.readFileSync(args.responses, "utf-8"));
+  const payload = JSON.parse(fs106.readFileSync(args.responses, "utf-8"));
   const consensus = _deserialise_consensus(payload["consensus"]);
   if (consensus === null) {
     _stderr2(
@@ -56857,8 +57443,8 @@ function cmd_replay(args) {
       kind: "sessions",
       subcommand: "replay"
     });
-    fs104.mkdirSync(path100.dirname(_resolveTarget(out_path)), { recursive: true });
-    fs104.writeFileSync(_resolveTarget(out_path), body, { encoding: "utf-8" });
+    fs106.mkdirSync(path102.dirname(_resolveTarget(out_path)), { recursive: true });
+    fs106.writeFileSync(_resolveTarget(out_path), body, { encoding: "utf-8" });
     _stdout2(`council:replay \xB7 wrote ${out_path}
 `);
   } else {
@@ -56915,8 +57501,8 @@ function cmd_quota(args, opts = {}) {
 }
 function _validate_council_output_path(path_str, opts) {
   const expected_rel = COUNCIL_CANONICAL_DIRS[opts.kind];
-  const expected_abs = _resolveReal(path100.join(REPO_ROOT12, expected_rel));
-  const target = path100.isAbsolute(path_str) ? path_str : path100.join(REPO_ROOT12, path_str);
+  const expected_abs = _resolveReal(path102.join(REPO_ROOT12, expected_rel));
+  const target = path102.isAbsolute(path_str) ? path_str : path102.join(REPO_ROOT12, path_str);
   const target_resolved = _resolveReal(target);
   if (!_isRelativeTo(target_resolved, expected_abs)) {
     throw new ArgumentTypeError(
@@ -56926,12 +57512,12 @@ function _validate_council_output_path(path_str, opts) {
   return path_str;
 }
 function _resolveTarget(path_str) {
-  return path100.isAbsolute(path_str) ? path_str : path100.join(REPO_ROOT12, path_str);
+  return path102.isAbsolute(path_str) ? path_str : path102.join(REPO_ROOT12, path_str);
 }
 function _resolveReal(p) {
-  const abs = path100.resolve(p);
+  const abs = path102.resolve(p);
   try {
-    return fs104.realpathSync(abs);
+    return fs106.realpathSync(abs);
   } catch {
     return abs;
   }
@@ -56940,8 +57526,8 @@ function _isRelativeTo(target, base) {
   if (target === base) {
     return true;
   }
-  const rel = path100.relative(base, target);
-  return rel !== "" && !rel.startsWith("..") && !path100.isAbsolute(rel);
+  const rel = path102.relative(base, target);
+  return rel !== "" && !rel.startsWith("..") && !path102.isAbsolute(rel);
 }
 function _topError(message) {
   _stderr2(_TOP_USAGE2);
@@ -57266,7 +57852,7 @@ function _parse_siblings_overrides(items) {
 function _isFileNotFound(exc) {
   return exc instanceof FileNotFoundError3 || exc instanceof Error && exc.code === "ENOENT";
 }
-function main38(argv = null) {
+function main39(argv = null) {
   const args = _parseArgs7(argv ?? process.argv.slice(2));
   try {
     if (args.cmd === "estimate") {
@@ -57310,23 +57896,23 @@ function main38(argv = null) {
   }
   return 1;
 }
-function _isCliEntry29() {
+function _isCliEntry30() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL35(path100.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL36(path102.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs104.realpathSync(fileURLToPath50(import.meta.url));
-    const argv = fs104.realpathSync(path100.resolve(process.argv[1]));
+    const here = fs106.realpathSync(fileURLToPath51(import.meta.url));
+    const argv = fs106.realpathSync(path102.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
   }
 }
-var _ArgExit2, ArgumentTypeError, _PROG9, SCHEMA_VERSION9, _API_PROVIDERS, _CLI_PROVIDERS, _HERE26, REPO_ROOT12, SETTINGS_FILE2, AI_COUNCIL_FILE, COUNCIL_CANONICAL_DIRS, CouncilDisabledError, _CLI_FACTORY, ValueError4, _VALID_ABSENT_REASONS, FileNotFoundError3, _SUBCOMMANDS, _TOP_USAGE2;
+var _ArgExit2, ArgumentTypeError, _PROG9, SCHEMA_VERSION9, _API_PROVIDERS, _CLI_PROVIDERS, _HERE27, REPO_ROOT12, SETTINGS_FILE2, AI_COUNCIL_FILE, COUNCIL_CANONICAL_DIRS, CouncilDisabledError, _CLI_FACTORY, ValueError4, _VALID_ABSENT_REASONS, FileNotFoundError3, _SUBCOMMANDS, _TOP_USAGE2;
 var init_council_cli = __esm({
   "src/scripts/council_cli.ts"() {
     "use strict";
@@ -57392,7 +57978,7 @@ var init_council_cli = __esm({
       "xai",
       "perplexity"
     ]);
-    _HERE26 = path100.dirname(fileURLToPath50(import.meta.url));
+    _HERE27 = path102.dirname(fileURLToPath51(import.meta.url));
     [REPO_ROOT12] = resolve_project_root(null);
     SETTINGS_FILE2 = project_settings_path(REPO_ROOT12);
     AI_COUNCIL_FILE = resolve_config_path(REPO_ROOT12);
@@ -57425,9 +58011,9 @@ var init_council_cli = __esm({
                             {estimate,run,debate,render,replay,quota,shadow-report,status}
                             ...
 `;
-    if (_isCliEntry29()) {
+    if (_isCliEntry30()) {
       try {
-        process.exitCode = main38(process.argv.slice(2));
+        process.exitCode = main39(process.argv.slice(2));
       } catch (err) {
         if (!(err instanceof _ArgExit2)) {
           throw err;
@@ -57456,7 +58042,7 @@ function run_enveloped(spec) {
   if (cmd === void 0) {
     throw new Error("envelope argv must not be empty");
   }
-  return new Promise((resolve56) => {
+  return new Promise((resolve57) => {
     execFile(
       cmd,
       args,
@@ -57479,7 +58065,7 @@ function run_enveloped(spec) {
         }
         const [out, outTrunc] = _truncate(String(stdout ?? ""), spec.max_output_bytes);
         const [err, errTrunc] = _truncate(String(stderr ?? ""), spec.max_output_bytes);
-        resolve56({
+        resolve57({
           exit_code: timedOut ? null : exitCode,
           timed_out: timedOut,
           stdout: out,
@@ -57500,8 +58086,8 @@ var init_safety_envelope = __esm({
 });
 
 // src/scripts/mcp_server/__main__.ts
-import * as path102 from "node:path";
-import { fileURLToPath as fileURLToPath52 } from "node:url";
+import * as path104 from "node:path";
+import { fileURLToPath as fileURLToPath53 } from "node:url";
 
 // src/scripts/mcp_server/index.ts
 var __version__ = "0.1.0";
@@ -57548,9 +58134,9 @@ init_prompts();
 init_resources();
 
 // src/scripts/mcp_server/tools.ts
-import * as fs105 from "node:fs";
-import * as path101 from "node:path";
-import { fileURLToPath as fileURLToPath51 } from "node:url";
+import * as fs107 from "node:fs";
+import * as path103 from "node:path";
+import { fileURLToPath as fileURLToPath52 } from "node:url";
 
 // src/scripts/chat_history.ts
 init_memory_lookup();
@@ -60969,8 +61555,8 @@ function buildGraph(files, extracts, resolution = EMPTY_RESOLUTION_CONFIG) {
   }
   function resolveRawEdge(r, ex) {
     if (r.relation === "member") {
-      const sep20 = r.sourceId.includes("#") ? "::" : "#";
-      const target = `${r.sourceId}${sep20}${r.targetName}`;
+      const sep21 = r.sourceId.includes("#") ? "::" : "#";
+      const target = `${r.sourceId}${sep21}${r.targetName}`;
       emit2({
         source: r.sourceId,
         target: nodeIds.has(target) ? target : `symbol:${r.targetName}`,
@@ -62780,14 +63366,14 @@ function _resolveConsumerRoot(override) {
   return resolvePath(process.cwd());
 }
 function _relativeUnder(target, root) {
-  const rel = path101.relative(root, target);
+  const rel = path103.relative(root, target);
   if (rel === "") {
     return "";
   }
-  if (rel.startsWith("..") || path101.isAbsolute(rel)) {
+  if (rel.startsWith("..") || path103.isAbsolute(rel)) {
     return null;
   }
-  return rel.split(path101.sep).join("/");
+  return rel.split(path103.sep).join("/");
 }
 function _reprStrList(values) {
   return `[${values.map((v) => `'${v}'`).join(", ")}]`;
@@ -62796,11 +63382,11 @@ function _validateInTreePath(raw, consumerRoot) {
   const root = resolvePath(consumerRoot);
   let target;
   if (raw === null || raw === void 0 || raw === "") {
-    target = path101.join(root, "agents", "runtime", ".agent-chat-history");
-  } else if (path101.isAbsolute(raw)) {
+    target = path103.join(root, "agents", "runtime", ".agent-chat-history");
+  } else if (path103.isAbsolute(raw)) {
     target = resolvePath(raw);
   } else {
-    target = resolvePath(path101.join(root, raw));
+    target = resolvePath(path103.join(root, raw));
   }
   const rel = _relativeUnder(target, root);
   if (rel === null) {
@@ -62838,11 +63424,11 @@ async function _lintSkillsHandler(args, consumerRoot) {
       if (typeof raw !== "string") {
         throw new Error("'paths' entries must be strings");
       }
-      const resolved = path101.isAbsolute(raw) ? resolvePath(raw) : resolvePath(path101.join(root, raw));
+      const resolved = path103.isAbsolute(raw) ? resolvePath(raw) : resolvePath(path103.join(root, raw));
       if (_relativeUnder(resolved, root) === null) {
         throw new Error(`path escapes consumer_root: ${resolved}`);
       }
-      if (fs105.existsSync(resolved)) {
+      if (fs107.existsSync(resolved)) {
         paths.push(resolved);
       }
     }
@@ -62879,7 +63465,7 @@ async function _chatHistoryAppendHandler(args, consumerRoot) {
     if (typeof minSchema !== "number" || !Number.isInteger(minSchema) || typeof minSchema === "boolean") {
       throw new Error("'min_schema_version' must be an integer");
     }
-    const existingHeader = fs105.existsSync(target) ? _chReadHeader(target) : null;
+    const existingHeader = fs107.existsSync(target) ? _chReadHeader(target) : null;
     const observed = existingHeader !== null && typeof existingHeader === "object" ? _pyInt7(existingHeader.v ?? 0) : SCHEMA_VERSION3;
     if (observed < minSchema) {
       throw new Error(`chat-history schema ${observed} below required ${minSchema}`);
@@ -62894,8 +63480,8 @@ async function _chatHistoryAppendHandler(args, consumerRoot) {
       session: session === void 0 ? null : session
     };
   }
-  if (!fs105.existsSync(target) || _chReadHeader(target) === null) {
-    fs105.mkdirSync(path101.dirname(target), { recursive: true });
+  if (!fs107.existsSync(target) || _chReadHeader(target) === null) {
+    fs107.mkdirSync(path103.dirname(target), { recursive: true });
     _chInit(target);
   }
   _chAppend(entry, target, session ?? null);
@@ -62939,7 +63525,7 @@ async function _chatHistoryReadHandler(args, consumerRoot) {
   if (detail !== "full" && detail !== "index") {
     throw new Error("'detail' must be 'index' or 'full'");
   }
-  if (!fs105.existsSync(target)) {
+  if (!fs107.existsSync(target)) {
     return { path: target, entries: [], count: 0 };
   }
   if (around !== void 0 && around !== null) {
@@ -63041,8 +63627,8 @@ async function _memoryStatusHandler(_args, consumerRoot) {
   }
   return result;
 }
-var _PACKAGE_ROOT3 = path101.resolve(
-  path101.dirname(fileURLToPath51(import.meta.url)),
+var _PACKAGE_ROOT3 = path103.resolve(
+  path103.dirname(fileURLToPath52(import.meta.url)),
   "..",
   "..",
   ".."
@@ -63086,10 +63672,10 @@ async function _memorySignalHandler(args, consumerRoot) {
 async function _roadmapProgressHandler(args, consumerRoot) {
   const dryRun = _pyTruthy6(args.dry_run ?? false);
   const root = resolvePath(consumerRoot);
-  const roadmapRoot = path101.join(root, "agents", "roadmaps");
-  const target = path101.join(root, "agents", "roadmaps-progress.md");
+  const roadmapRoot = path103.join(root, "agents", "roadmaps");
+  const target = path103.join(root, "agents", "roadmaps-progress.md");
   const urp = await Promise.resolve().then(() => (init_update_roadmap_progress(), update_roadmap_progress_exports));
-  if (!fs105.existsSync(roadmapRoot)) {
+  if (!fs107.existsSync(roadmapRoot)) {
     return {
       written: false,
       path: target,
@@ -63104,7 +63690,7 @@ async function _roadmapProgressHandler(args, consumerRoot) {
   const stepsDone = roadmaps.reduce((s, r) => s + r.done, 0);
   const stepsTotal = roadmaps.reduce((s, r) => s + r.total_active, 0);
   if (!dryRun) {
-    fs105.writeFileSync(target, content, "utf-8");
+    fs107.writeFileSync(target, content, "utf-8");
   }
   return {
     written: !dryRun,
@@ -63125,11 +63711,11 @@ async function _roadmapArchiveHandler(_args, consumerRoot) {
   let dashboardRegenerated = false;
   if (archived.length > 0) {
     const urp = await Promise.resolve().then(() => (init_update_roadmap_progress(), update_roadmap_progress_exports));
-    const roadmapRoot = path101.join(root, "agents", "roadmaps");
-    if (fs105.existsSync(roadmapRoot)) {
+    const roadmapRoot = path103.join(root, "agents", "roadmaps");
+    if (fs107.existsSync(roadmapRoot)) {
       const roadmaps = urp.collect(roadmapRoot);
-      fs105.writeFileSync(
-        path101.join(root, "agents", "roadmaps-progress.md"),
+      fs107.writeFileSync(
+        path103.join(root, "agents", "roadmaps-progress.md"),
         urp.render(roadmaps, urp.collect_bundles(root), roadmapRoot),
         "utf-8"
       );
@@ -63145,9 +63731,9 @@ async function _roadmapArchiveHandler(_args, consumerRoot) {
 async function _capabilitiesIndexHandler(args, consumerRoot) {
   const check = _pyTruthy6(args.check ?? false);
   const cap = await Promise.resolve().then(() => (init_generate_capabilities_index(), generate_capabilities_index_exports));
-  const out = path101.join(_PACKAGE_ROOT3, "CAPABILITIES.yaml");
+  const out = path103.join(_PACKAGE_ROOT3, "CAPABILITIES.yaml");
   const content = cap.build();
-  const onDisk = fs105.existsSync(out) ? fs105.readFileSync(out, "utf-8") : "";
+  const onDisk = fs107.existsSync(out) ? fs107.readFileSync(out, "utf-8") : "";
   const drift = onDisk !== content;
   if (check) {
     return { check: true, written: false, drift, path: out };
@@ -63158,7 +63744,7 @@ async function _capabilitiesIndexHandler(args, consumerRoot) {
       `CAPABILITIES.yaml path escapes consumer_root: ${out} not under ${root}`
     );
   }
-  fs105.writeFileSync(out, content, "utf-8");
+  fs107.writeFileSync(out, content, "utf-8");
   return { check: false, written: true, drift, path: out };
 }
 async function _runDoctorLeg(consumerRoot) {
@@ -63258,11 +63844,11 @@ async function _councilEstimateHandler(args, consumerRoot) {
     throw new Error("'depth' must be 'shallow' or 'deep' when provided");
   }
   const root = resolvePath(consumerRoot);
-  const target = path101.isAbsolute(inputRaw) ? resolvePath(inputRaw) : resolvePath(path101.join(root, inputRaw));
+  const target = path103.isAbsolute(inputRaw) ? resolvePath(inputRaw) : resolvePath(path103.join(root, inputRaw));
   if (_relativeUnder(target, root) === null) {
     throw new Error(`path escapes consumer_root: ${target}`);
   }
-  if (!fs105.existsSync(target)) {
+  if (!fs107.existsSync(target)) {
     throw new Error(`input_path not found: ${target}`);
   }
   const cli = await Promise.resolve().then(() => (init_council_cli(), council_cli_exports));
@@ -63324,18 +63910,18 @@ async function _runTestsHandler(args, consumerRoot) {
     if (typeof relPathRaw !== "string" || !strip(relPathRaw)) {
       throw new Error("'path' must be a non-empty string when provided");
     }
-    const resolved = path101.isAbsolute(relPathRaw) ? resolvePath(relPathRaw) : resolvePath(path101.join(root, relPathRaw));
+    const resolved = path103.isAbsolute(relPathRaw) ? resolvePath(relPathRaw) : resolvePath(path103.join(root, relPathRaw));
     const rel = _relativeUnder(resolved, root);
     if (rel === null) {
       throw new Error(`path escapes consumer_root: ${resolved}`);
     }
-    if (!fs105.existsSync(resolved)) {
+    if (!fs107.existsSync(resolved)) {
       throw new Error(`path not found: ${resolved}`);
     }
     relArg = rel;
   }
-  const vitestEntry = path101.join(root, "node_modules", "vitest", "vitest.mjs");
-  if (!fs105.existsSync(vitestEntry)) {
+  const vitestEntry = path103.join(root, "node_modules", "vitest", "vitest.mjs");
+  if (!fs107.existsSync(vitestEntry)) {
     throw new Error(
       "run_tests pilot supports vitest projects only \u2014 node_modules/vitest/vitest.mjs not found under consumer_root"
     );
@@ -63965,8 +64551,8 @@ function _strCmp3(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 function _pathlibCompare3(a, b) {
-  const pa = a.split(path101.sep);
-  const pb = b.split(path101.sep);
+  const pa = a.split(path103.sep);
+  const pb = b.split(path103.sep);
   const n = Math.min(pa.length, pb.length);
   for (let i = 0; i < n; i++) {
     const c = _strCmp3(pa[i], pb[i]);
@@ -64185,18 +64771,18 @@ async function _serveOverSdk(server) {
   const transport = new StdioServerTransport();
   await sdkServer.connect(transport);
 }
-function main39() {
+function main40() {
   void run_stdio();
 }
 
 // src/scripts/mcp_server/__main__.ts
-var _selfPath = fileURLToPath52(import.meta.url);
-var _invokedDirectly3 = globalThis.__AC_MCP_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path102.resolve(process.argv[1]) === path102.resolve(_selfPath);
+var _selfPath = fileURLToPath53(import.meta.url);
+var _invokedDirectly3 = globalThis.__AC_MCP_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path104.resolve(process.argv[1]) === path104.resolve(_selfPath);
 if (_invokedDirectly3) {
-  main39();
+  main40();
 }
 export {
-  main39 as main
+  main40 as main
 };
 /*! Bundled license information: