@event4u/agent-config 14.22.0 → 14.23.0

package/dist/hooks/dispatch.js

@@ -112,17 +112,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path110) {
-      const ctrl = callVisitor(key, node, visitor, path110);
+    function visit_(key, node, visitor, path111) {
+      const ctrl = callVisitor(key, node, visitor, path111);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path110, ctrl);
-        return visit_(key, ctrl, visitor, path110);
+        replaceNode(key, path111, ctrl);
+        return visit_(key, ctrl, visitor, path111);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path110 = Object.freeze(path110.concat(node));
+          path111 = Object.freeze(path111.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path110);
+            const ci = visit_(i, node.items[i], visitor, path111);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -133,13 +133,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path110 = Object.freeze(path110.concat(node));
-          const ck = visit_("key", node.key, visitor, path110);
+          path111 = Object.freeze(path111.concat(node));
+          const ck = visit_("key", node.key, visitor, path111);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path110);
+          const cv = visit_("value", node.value, visitor, path111);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -160,17 +160,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path110) {
-      const ctrl = await callVisitor(key, node, visitor, path110);
+    async function visitAsync_(key, node, visitor, path111) {
+      const ctrl = await callVisitor(key, node, visitor, path111);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path110, ctrl);
-        return visitAsync_(key, ctrl, visitor, path110);
+        replaceNode(key, path111, ctrl);
+        return visitAsync_(key, ctrl, visitor, path111);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path110 = Object.freeze(path110.concat(node));
+          path111 = Object.freeze(path111.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path110);
+            const ci = await visitAsync_(i, node.items[i], visitor, path111);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -181,13 +181,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path110 = Object.freeze(path110.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path110);
+          path111 = Object.freeze(path111.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path111);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path110);
+          const cv = await visitAsync_("value", node.value, visitor, path111);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -214,23 +214,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path110) {
+    function callVisitor(key, node, visitor, path111) {
       if (typeof visitor === "function")
-        return visitor(key, node, path110);
+        return visitor(key, node, path111);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path110);
+        return visitor.Map?.(key, node, path111);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path110);
+        return visitor.Seq?.(key, node, path111);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path110);
+        return visitor.Pair?.(key, node, path111);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path110);
+        return visitor.Scalar?.(key, node, path111);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path110);
+        return visitor.Alias?.(key, node, path111);
       return void 0;
     }
-    function replaceNode(key, path110, node) {
-      const parent = path110[path110.length - 1];
+    function replaceNode(key, path111, node) {
+      const parent = path111[path111.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -840,10 +840,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path110, value) {
+    function collectionFromPath(schema, path111, value) {
       let v = value;
-      for (let i = path110.length - 1; i >= 0; --i) {
-        const k = path110[i];
+      for (let i = path111.length - 1; i >= 0; --i) {
+        const k = path111[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -862,7 +862,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path110) => path110 == null || typeof path110 === "object" && !!path110[Symbol.iterator]().next().done;
+    var isEmptyPath = (path111) => path111 == null || typeof path111 === "object" && !!path111[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -892,11 +892,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path110, value) {
-        if (isEmptyPath(path110))
+      addIn(path111, value) {
+        if (isEmptyPath(path111))
           this.add(value);
         else {
-          const [key, ...rest] = path110;
+          const [key, ...rest] = path111;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -910,8 +910,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path110) {
-        const [key, ...rest] = path110;
+      deleteIn(path111) {
+        const [key, ...rest] = path111;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -925,8 +925,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path110, keepScalar) {
-        const [key, ...rest] = path110;
+      getIn(path111, keepScalar) {
+        const [key, ...rest] = path111;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -944,8 +944,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path110) {
-        const [key, ...rest] = path110;
+      hasIn(path111) {
+        const [key, ...rest] = path111;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -955,8 +955,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path110, value) {
-        const [key, ...rest] = path110;
+      setIn(path111, value) {
+        const [key, ...rest] = path111;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3471,9 +3471,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path110, value) {
+      addIn(path111, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path110, value);
+          this.contents.addIn(path111, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3548,14 +3548,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path110) {
-        if (Collection.isEmptyPath(path110)) {
+      deleteIn(path111) {
+        if (Collection.isEmptyPath(path111)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path110) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path111) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3570,10 +3570,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path110, keepScalar) {
-        if (Collection.isEmptyPath(path110))
+      getIn(path111, keepScalar) {
+        if (Collection.isEmptyPath(path111))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path110, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path111, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3584,10 +3584,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path110) {
-        if (Collection.isEmptyPath(path110))
+      hasIn(path111) {
+        if (Collection.isEmptyPath(path111))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path110) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path111) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3604,13 +3604,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path110, value) {
-        if (Collection.isEmptyPath(path110)) {
+      setIn(path111, value) {
+        if (Collection.isEmptyPath(path111)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path110), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path111), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path110, value);
+          this.contents.setIn(path111, value);
         }
       }
       /**
@@ -5570,9 +5570,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path110) => {
+    visit.itemAtPath = (cst, path111) => {
       let item = cst;
-      for (const [field, index] of path110) {
+      for (const [field, index] of path111) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5581,23 +5581,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path110) => {
-      const parent = visit.itemAtPath(cst, path110.slice(0, -1));
-      const field = path110[path110.length - 1][0];
+    visit.parentCollection = (cst, path111) => {
+      const parent = visit.itemAtPath(cst, path111.slice(0, -1));
+      const field = path111[path111.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path110, item, visitor) {
-      let ctrl = visitor(item, path110);
+    function _visit(path111, item, visitor) {
+      let ctrl = visitor(item, path111);
       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(path110.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path111.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5608,10 +5608,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path110);
+            ctrl = ctrl(item, path111);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path110) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path111) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6913,14 +6913,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs107 = this.flowScalar(this.type);
+              const fs109 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs107, sep: [] });
+                map.items.push({ start, key: fs109, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs107);
+                this.stack.push(fs109);
               } else {
-                Object.assign(it, { key: fs107, sep: [] });
+                Object.assign(it, { key: fs109, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7048,13 +7048,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs107 = this.flowScalar(this.type);
+              const fs109 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs107, sep: [] });
+                fc.items.push({ start: [], key: fs109, sep: [] });
               else if (it.sep)
-                this.stack.push(fs107);
+                this.stack.push(fs109);
               else
-                Object.assign(it, { key: fs107, sep: [] });
+                Object.assign(it, { key: fs109, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7363,14 +7363,14 @@ var require_dist = __commonJS({
 });
 
 // src/scripts/hooks/dispatch_entry.ts
-import * as path109 from "node:path";
+import * as path110 from "node:path";
 import { fileURLToPath as fileURLToPath71 } from "node:url";
 
 // src/scripts/hooks/dispatch_hook.ts
 var import_yaml7 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync11 } from "node:child_process";
-import fs106 from "node:fs";
-import path108 from "node:path";
+import fs108 from "node:fs";
+import path109 from "node:path";
 import * as tty2 from "node:tty";
 import { fileURLToPath as fileURLToPath70, pathToFileURL as pathToFileURL61 } from "node:url";
 
@@ -18580,18 +18580,34 @@ function restore_hot_context(root, source, now = /* @__PURE__ */ new Date()) {
   ].join("\n");
   return { action: "inject", reason: `restored (source=${source || "startup"})`, context: block };
 }
-function _session_index_block_or_null(root) {
+function _session_index_block_or_null(root, sessionId3) {
   try {
     const req = createRequire4(import.meta.url);
     const mod = req("./session_memory_index.js");
     if (!mod.session_index_enabled(root)) return null;
+    const verdict2 = mod.session_index_trust(root);
+    if (!verdict2.ok) {
+      process7.stderr.write(`hot-context-hook: session index refused [${String(verdict2.code)}]: ${String(verdict2.detail)}
+`);
+      return null;
+    }
     const prev = process7.cwd();
+    let block;
     try {
       process7.chdir(root);
-      return mod.build_session_index_block();
+      block = mod.serve_session_index_block(verdict2);
     } finally {
       process7.chdir(prev);
     }
+    if (block === null) return null;
+    const trust = req("./_lib/session_index_trust.js");
+    const claim = trust.claimSessionOnce(root, sessionId3);
+    if (!claim.ok) {
+      process7.stderr.write(`hot-context-hook: session index already served [${String(claim.code)}]
+`);
+      return null;
+    }
+    return block;
   } catch (exc) {
     process7.stderr.write(`hot-context-hook: session index skipped: ${String(exc)}
 `);
@@ -18630,7 +18646,10 @@ function main7() {
       if (decision.action === "inject" && decision.context) {
         blocks.push(decision.context);
       }
-      const indexBlock = _session_index_block_or_null(root);
+      const sessionId3 = String(
+        envelope.session_id ?? payload.session_id ?? payload.sessionId ?? ""
+      );
+      const indexBlock = _session_index_block_or_null(root, sessionId3);
       if (indexBlock !== null) {
         blocks.push(indexBlock);
       }
@@ -19399,6 +19418,7 @@ var RECYCLE_CONSUMED_REL = path24.join(
   "recycle-envelope.consumed.json"
 );
 var RECYCLE_MAX_AGE_HOURS = 48;
+var RECYCLE_ENVELOPE_MAX_BYTES = 6144;
 var _STATE_REL = path24.join("agents", "runtime", "state");
 function recycle_envelope_rel(session_id) {
   return _sessionKeyed(session_id, RECYCLE_ENVELOPE_REL, "recycle-envelope", ".json");
@@ -19406,6 +19426,14 @@ function recycle_envelope_rel(session_id) {
 function recycle_consumed_rel(session_id) {
   return _sessionKeyed(session_id, RECYCLE_CONSUMED_REL, "recycle-envelope", ".consumed.json");
 }
+function recycle_quarantine_rel(session_id) {
+  return _sessionKeyed(
+    session_id,
+    path24.join(_STATE_REL, "recycle-envelope.quarantined.json"),
+    "recycle-envelope",
+    ".quarantined.json"
+  );
+}
 function _sessionKeyed(session_id, legacy, stem, suffix) {
   const id = String(session_id ?? "").trim();
   if (id === "") {
@@ -19432,22 +19460,35 @@ function listContinuityRecords(workspace_root) {
 }
 function resolveContinuityRecord(workspace_root, session_id) {
   const id = String(session_id ?? "").trim();
-  if (id !== "") {
-    const own = path24.join(workspace_root, recycle_envelope_rel(id));
-    return fs26.existsSync(own) ? { file: own, reason: `continuity record for this session (${safe_stem(id)})` } : { file: null, reason: `no continuity record for this session (${safe_stem(id)})` };
-  }
-  const candidates = listContinuityRecords(workspace_root);
+  const own = id === "" ? null : path24.join(workspace_root, recycle_envelope_rel(id));
+  const candidates = listContinuityRecords(workspace_root).filter((f) => f !== own);
   if (candidates.length === 0) {
-    return { file: null, reason: "no continuity record present" };
+    return {
+      file: null,
+      reason: id === "" ? "no continuity record present" : `no predecessor record in this workspace (own: ${safe_stem(id)})`
+    };
   }
   if (candidates.length === 1) {
-    return { file: candidates[0], reason: "one continuity record, no session id to key on" };
+    return {
+      file: candidates[0],
+      reason: id === "" ? "one continuity record, no session id to key on" : `predecessor record, one candidate (own: ${safe_stem(id)})`
+    };
   }
   return {
     file: null,
-    reason: `starting clean: ${candidates.length} continuity records in this workspace and no session id to tell them apart \u2014 resuming from the newest would resume a peer session, not this one`
+    reason: `starting clean: ${candidates.length} continuity records in this workspace and no way to tell which is the predecessor \u2014 resuming from the newest would resume a peer session, not this one`
   };
 }
+function resolvePredecessor(projectRoot, sessionId3) {
+  try {
+    const consumed = path24.join(projectRoot, recycle_consumed_rel(sessionId3));
+    const raw = JSON.parse(fs26.readFileSync(consumed, "utf-8"));
+    const prior = String(raw.session_id ?? "").trim();
+    return prior === "" ? "none" : prior;
+  } catch {
+    return "none";
+  }
+}
 function predecessorTracePresent(workspace_root, predecessor) {
   const id = String(predecessor ?? "").trim();
   if (id === "" || id === "none") {
@@ -19530,8 +19571,8 @@ function lockfile_path(env) {
   }
   return write_target("installed.lock", { env: env ?? null });
 }
-function read_lockfile(path110) {
-  const target = path110 ?? lockfile_path();
+function read_lockfile(path111) {
+  const target = path111 ?? lockfile_path();
   let text;
   try {
     text = fs27.readFileSync(target, { encoding: "utf-8" });
@@ -20657,6 +20698,7 @@ var EPISTEMIC = new Set(EPISTEMIC_STATES);
 var MAX_REF_CHARS = 200;
 var MAX_LINE_CHARS = 240;
 var MAX_ENTRIES = 40;
+var CAPSULE_SCHEMA_VERSION = 4;
 var ACCEPTED_CAPSULE_VERSIONS = [3, 4];
 var CAPSULE_VARIANTS = ["worker", "main_session", "continuity_record"];
 var CONTINUITY_RECORD_FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
@@ -21121,7 +21163,15 @@ function consume_recycle_envelope(root, now = /* @__PURE__ */ new Date(), sessio
       reason: `recycle envelope names predecessor "${predecessor}", which has no trace in this workspace`
     };
   }
-  const drift = describeDrift(envelope, collectRepoAnchor(root));
+  const anchor = collectRepoAnchor(root);
+  const envelopeBranch = String(envelope["branch"] ?? "").trim();
+  if (envelopeBranch !== "" && anchor.branch !== null && envelopeBranch !== anchor.branch) {
+    return {
+      action: "absent",
+      reason: `recycle envelope is for branch "${envelopeBranch}" and this tree is on "${anchor.branch}" \u2014 left unclaimed for a session on that branch rather than consumed`
+    };
+  }
+  const drift = describeDrift(envelope, anchor);
   const warnings = scanEnvelopeDirectives(envelope);
   const focus = (process10.env.AGENT_RESUME_FOCUS ?? "").trim();
   const block = wrapAsPriorSessionData(JSON.stringify(envelope, null, 2), {
@@ -24487,7 +24537,7 @@ A push is not a delivery. Per verify-before-complete, a completion claim needs f
 Before this turn ends:
   1. Settle it:
      ${settle}
-     Exit 0 = settled green \xB7 1 = settled, something failed \xB7 2 = NOT a verdict (timed out or unreadable \u2014 never report 2 as green).
+     Exit 0 = settled green, and the line names the head it is about \xB7 1 = settled, something failed \xB7 2 = NOT a verdict (timed out, unreadable, or the PR is merged / closed / head-diverged \u2014 never report 2 as green).
   2. Red? Read only the failing part:
      gh run view --job <id> --log-failed | grep -E '\xD7|FAIL|Error'
      then fix it and push again (fix-what-you-see: the author is irrelevant).
@@ -28107,6 +28157,83 @@ var COMMAND_OPS = [
   { op: "commit", re: new RegExp(`${P}git\\s+${G}commit\\b`, "i") },
   { op: "branch", re: new RegExp(`${P}git\\s+${G}(checkout\\s+-b|switch\\s+-c)\\b`, "i") }
 ];
+function splitOutsideQuotes(command) {
+  const parts = [];
+  let cur = "";
+  let quote = null;
+  for (let i = 0; i < command.length; i += 1) {
+    const ch = command[i];
+    if (quote !== null) {
+      if (quote === "$'" && ch === "\\" && i + 1 < command.length) {
+        cur += ch + command[i + 1];
+        i += 1;
+        continue;
+      }
+      cur += ch;
+      if (ch === (quote === "$'" ? "'" : quote)) {
+        quote = null;
+      } else if (ch === "\\" && quote === '"' && i + 1 < command.length) {
+        cur += command[i + 1];
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "$" && (command[i + 1] === "'" || command[i + 1] === '"')) {
+      quote = command[i + 1] === "'" ? "$'" : '"';
+      cur += ch + command[i + 1];
+      i += 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      cur += ch;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < command.length) {
+      cur += ch + command[i + 1];
+      i += 1;
+      continue;
+    }
+    if (ch === "\n" || ch === ";" || ch === "|" || ch === "&") {
+      if ((ch === "|" || ch === "&") && command[i + 1] === ch) {
+        i += 1;
+      }
+      parts.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  if (quote !== null) {
+    parts.push(...splitIgnoringQuotes(cur));
+    return parts;
+  }
+  parts.push(cur);
+  return parts;
+}
+function splitIgnoringQuotes(fragment) {
+  const parts = [];
+  let cur = "";
+  for (let i = 0; i < fragment.length; i += 1) {
+    const ch = fragment[i];
+    if (ch === "\\" && i + 1 < fragment.length) {
+      cur += ch + fragment[i + 1];
+      i += 1;
+      continue;
+    }
+    if (ch === "\n" || ch === ";" || ch === "|" || ch === "&") {
+      if ((ch === "|" || ch === "&") && fragment[i + 1] === ch) {
+        i += 1;
+      }
+      parts.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  parts.push(cur);
+  return parts;
+}
 function substitutionPayloads(segment) {
   const out = [];
   for (let i = 0; i < segment.length; i += 1) {
@@ -28141,6 +28268,38 @@ function substitutionPayloads(segment) {
   }
   return out;
 }
+function invokedSegments(command, depth = 0) {
+  if (depth > 3) {
+    return [];
+  }
+  const out = [];
+  const withoutHeredocs = command.replace(
+    /<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1[\s\S]*?^\s*\2\s*$/gm,
+    "<<HEREDOC"
+  );
+  for (const raw of splitOutsideQuotes(withoutHeredocs)) {
+    let seg = raw.trim();
+    if (!seg) {
+      continue;
+    }
+    seg = seg.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S*)\s+)+/, "");
+    for (const payload of substitutionPayloads(seg)) {
+      out.push(...invokedSegments(payload, depth + 1));
+    }
+    const wrapped = /^(?:\S*\/)?(?:ba|z|k)?sh\s+-[a-z]*c\s+(?:"([^"]*)"|'([^']*)'|(\S+))/.exec(seg);
+    if (wrapped) {
+      out.push(...invokedSegments(wrapped[1] ?? wrapped[2] ?? wrapped[3] ?? "", depth + 1));
+      continue;
+    }
+    const evaled = /^eval\s+(?:"([^"]*)"|'([^']*)'|(.+))$/.exec(seg);
+    if (evaled) {
+      out.push(...invokedSegments(evaled[1] ?? evaled[2] ?? evaled[3] ?? "", depth + 1));
+      continue;
+    }
+    out.push(seg.replace(/^(\S+)/, (w) => w.replace(/['"]/g, "")));
+  }
+  return out;
+}
 
 // src/scripts/hooks/block_no_verify.ts
 var _HERE4 = fileURLToPath38(import.meta.url);
@@ -29049,9 +29208,62 @@ var _PATH_KEYS3 = [
   "filePath",
   "notebook_path"
 ];
+var _READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
+  "read",
+  "grep",
+  "glob",
+  "notebookread",
+  "ls",
+  "view",
+  "search",
+  "codebase-retrieval",
+  "codebase_retrieval",
+  "file_search",
+  "grep_search",
+  "read_file",
+  "list_dir",
+  "semantic_search"
+]);
 function _isObject12(v) {
   return v !== null && v !== void 0 && typeof v === "object" && !Array.isArray(v);
 }
+function isGlobOverAcceptableInboxDir(name) {
+  if (!/[*?[\]]/.test(name)) {
+    return false;
+  }
+  const literal = name.replace(/[*?]|\[[^\]]*\]/g, "");
+  const trimmed = literal.replace(/-+$/, "");
+  return trimmed !== "" && isAcceptableInboxDir(trimmed);
+}
+function _redirectTargets(segment) {
+  const out = [];
+  const re = /(?:^|[^0-9<>&])[0-9]*>>?\s*([^\s|&;<>]+)/g;
+  let m = re.exec(segment);
+  while (m !== null) {
+    const target = (m[1] ?? "").replace(/^['"`]+|['"`]+$/g, "");
+    if (target) {
+      out.push(target);
+    }
+    m = re.exec(segment);
+  }
+  return out;
+}
+function creatableTokens(command) {
+  const out = [];
+  const segments = invokedSegments(command);
+  for (const seg of segments) {
+    out.push(..._redirectTargets(seg));
+  }
+  out.push(..._redirectTargets(command));
+  for (const text of [...segments, command]) {
+    for (const tok of text.split(/[\s"'`(){};|&<>]+/)) {
+      if (tok) {
+        out.push(tok);
+      }
+    }
+  }
+  return out;
+}
 var INBOX_RE = /(?:^|\/)agents\/tmp(?:\.old)?\/([^/]+)\/./;
 var INBOX_DIR_TERMINAL_RE = /(?:^|\/)agents\/tmp(?:\.old)?\/([^/.]+)\/?$/;
 function inboxDirName(filePath) {
@@ -29077,13 +29289,16 @@ function verdictFor(filePath, exists, repoRoot = "") {
   if (isAcceptableInboxDir(dir)) {
     return { block: false, dir, reason: "opaque round identifier or named working set" };
   }
+  if (isGlobOverAcceptableInboxDir(dir)) {
+    return { block: false, dir, reason: "glob over an acceptable name \u2014 not a creatable literal" };
+  }
   const normalized = filePath.replace(/\\/g, "/").replace(/^(\.\/)+/, "");
-  const m = /(?:^|\/)(agents\/tmp(?:\.old)?\/[^/]+)\//.exec(normalized) ?? /(?:^|\/)(agents\/tmp(?:\.old)?\/[^/.]+)\/?$/.exec(normalized);
+  const m = /^((?:.*?\/)??agents\/tmp(?:\.old)?\/[^/]+)\//.exec(normalized) ?? /^((?:.*?\/)??agents\/tmp(?:\.old)?\/[^/.]+)\/?$/.exec(normalized);
   if (m === null) {
     return { block: true, dir, reason: "new inbox directory with a speaking name (path not re-anchorable)" };
   }
   const upto = m[1];
-  const probe = repoRoot === "" ? upto : path63.join(repoRoot, upto);
+  const probe = repoRoot === "" || path63.isAbsolute(upto) ? upto : path63.join(repoRoot, upto);
   if (exists(probe)) {
     return { block: false, dir, reason: "directory already exists \u2014 rename, do not re-refuse" };
   }
@@ -29128,20 +29343,20 @@ function main37() {
       return 0;
     }
     const repoRoot = typeof envelope["project_dir"] === "string" ? envelope["project_dir"] : "";
+    const rawTool = payload["tool_name"] ?? envelope["tool_name"];
+    const toolName2 = typeof rawTool === "string" ? rawTool.trim().toLowerCase() : "";
     const candidates = [];
-    for (const key of _PATH_KEYS3) {
-      const v = ti[key];
-      if (typeof v === "string" && v) {
-        candidates.push(v);
+    if (!_READ_ONLY_TOOLS.has(toolName2)) {
+      for (const key of _PATH_KEYS3) {
+        const v = ti[key];
+        if (typeof v === "string" && v) {
+          candidates.push(v);
+        }
       }
     }
     const cmd = ti["command"] ?? (_isObject12(envelope["payload"]) ? envelope["payload"]["command"] : void 0);
     if (typeof cmd === "string" && cmd) {
-      for (const tok of cmd.split(/[\s"'`(){};|&<>]+/)) {
-        if (tok) {
-          candidates.push(tok);
-        }
-      }
+      candidates.push(...creatableTokens(cmd));
     }
     for (const v of candidates) {
       const verdict2 = verdictFor(v, (p) => fs64.existsSync(p), repoRoot);
@@ -30778,7 +30993,7 @@ import * as fs69 from "node:fs";
 import * as path68 from "node:path";
 
 // src/scripts/code_graph/validate.ts
-var RELATIONS = /* @__PURE__ */ new Set(["calls", "imports", "uses", "inherits", "member"]);
+var RELATIONS = /* @__PURE__ */ new Set(["calls", "imports", "uses", "inherits", "member", "tests"]);
 var CONFIDENCES = /* @__PURE__ */ new Set(["EXTRACTED", "INFERRED", "AMBIGUOUS"]);
 var RESOLVED_VIA = /* @__PURE__ */ new Set([
   "same-file",
@@ -30929,6 +31144,14 @@ function pickSource(verdicts) {
   if (native) return native;
   return verdicts.find((v) => v.kind === "consumer") ?? null;
 }
+var NATIVE_CACHE_REL = path68.join("agents", "runtime", "state", "code-graph-v1.json");
+function graphState(root, nativeCache) {
+  const picked = pickSource(detectSources(root, nativeCache ?? path68.join(root, NATIVE_CACHE_REL)));
+  if (!picked) return "absent";
+  if (picked.stale !== true) return "fresh";
+  const behind = picked.commits_behind;
+  return `behind:${typeof behind === "number" ? behind : 0}`;
+}
 
 // src/scripts/hooks/code_graph_context_hook.ts
 var EXIT_ALLOW17 = 0;
@@ -30979,14 +31202,6 @@ function latch(root, session) {
   } catch {
   }
 }
-var NATIVE_CACHE = path69.join("agents", "runtime", "state", "code-graph-v1.json");
-function graphState(root) {
-  const picked = pickSource(detectSources(root, path69.join(root, NATIVE_CACHE)));
-  if (!picked) return "absent";
-  if (picked.stale !== true) return "fresh";
-  const behind = picked.commits_behind;
-  return `behind:${typeof behind === "number" ? behind : 0}`;
-}
 function contextLine(state) {
   if (state === "fresh") {
     return "code-graph: fresh. For structure questions (who calls / where used / impact) `agent-config code-graph query|affected <symbol>` answers from the index; grep is the other path \u2014 say which one answered.";
@@ -31489,6 +31704,54 @@ function leanProjectionModeRaw(root) {
   }
   return "";
 }
+function leanProjectionHostsRaw(root) {
+  const file = path72.join(root, SETTINGS_FILE11);
+  let text;
+  try {
+    if (!fs73.statSync(file).isFile()) return [];
+    text = fs73.readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
+  const strip = (s) => s.trim().replace(/^["']|["']$/g, "");
+  let inSection = false;
+  let inBlock = false;
+  let blockIndent = -1;
+  const out = [];
+  for (const raw of text.split(/\r\n|\r|\n/)) {
+    const line = raw.replace(/\s+$/, "");
+    if (!line || line.replace(/^\s+/, "").startsWith("#")) continue;
+    if (!(line.startsWith(" ") || line.startsWith("	"))) {
+      inSection = /^lean_projection\s*:\s*$/.test(line);
+      inBlock = false;
+      continue;
+    }
+    if (!inSection) continue;
+    const indent = /^\s*/.exec(line)[0].length;
+    if (inBlock) {
+      const item = /^\s*-\s*(\S.*)$/.exec(line);
+      if (item !== null && indent >= blockIndent) {
+        const v = strip(item[1] ?? "");
+        if (v !== "") out.push(v);
+        continue;
+      }
+      inBlock = false;
+    }
+    const inline = /^\s+hosts\s*:\s*\[([^\]]*)\]\s*$/.exec(line);
+    if (inline !== null) {
+      for (const part of (inline[1] ?? "").split(",")) {
+        const v = strip(part);
+        if (v !== "") out.push(v);
+      }
+      continue;
+    }
+    if (/^\s+hosts\s*:\s*$/.test(line)) {
+      inBlock = true;
+      blockIndent = indent;
+    }
+  }
+  return out;
+}
 
 // src/scripts/hooks/ui_route_nudge_hook.ts
 var EXIT_ALLOW20 = 0;
@@ -33579,6 +33842,39 @@ function normalizeLeanProjectionMode(raw) {
 function deliversBodies(mode) {
   return mode === "delivery";
 }
+var THINNABLE_HOSTS = ["claude-code", "cursor", "cline"];
+var DEFAULT_LEAN_PROJECTION_HOSTS = ["claude-code"];
+function resolveLeanProjectionHosts(raw) {
+  const known = new Set(THINNABLE_HOSTS);
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return { hosts: [...DEFAULT_LEAN_PROJECTION_HOSTS], dropped: [], usedDefault: true };
+  }
+  const hosts = [];
+  const dropped = [];
+  for (const entry of raw) {
+    const id = typeof entry === "string" ? entry.trim().toLowerCase() : "";
+    if (id === "") {
+      dropped.push({ id: String(entry), reason: "unknown" });
+      continue;
+    }
+    if (!known.has(id)) {
+      dropped.push({ id, reason: KNOWN_NON_THINNABLE_HOSTS.has(id) ? "not-thinnable" : "unknown" });
+      continue;
+    }
+    if (!hosts.includes(id)) hosts.push(id);
+  }
+  hosts.sort();
+  return { hosts, dropped, usedDefault: false };
+}
+var KNOWN_NON_THINNABLE_HOSTS = /* @__PURE__ */ new Set([
+  "claude-desktop",
+  "augment",
+  "copilot",
+  "windsurf",
+  "gemini",
+  "codex",
+  "cowork"
+]);
 
 // src/scripts/_lib/rule_injection.ts
 import * as fs82 from "node:fs";
@@ -33850,7 +34146,7 @@ function selectForInjection(repoRoot, matches, capBytes, shortlist) {
 // src/scripts/hooks/rule_inject_hook.ts
 var EXIT_ALLOW25 = 0;
 var EXIT_WARN14 = 2;
-var CAP_BYTES = 20480;
+var CAP_BYTES = 16384;
 var FILE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "NotebookEdit", "Read", "MultiEdit"]);
 function isObject11(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -33928,8 +34224,11 @@ ${body.trim()}
   if (ids.length === 0) return null;
   return { rules: ids, bytes: sel.bytes, body: parts.join("\n\n") };
 }
+var DELIVERY_HOST = "claude-code";
 function gateOpen(root, cliEntry) {
-  if (deliversBodies(normalizeLeanProjectionMode(leanProjectionModeRaw(root)))) return true;
+  const mode = normalizeLeanProjectionMode(leanProjectionModeRaw(root));
+  const hosts = resolveLeanProjectionHosts(leanProjectionHostsRaw(root)).hosts;
+  if (deliversBodies(mode) && hosts.includes(DELIVERY_HOST)) return true;
   if (hookSectionEnabled(root, "rule_inject")) return true;
   return cliEntry && process13.env["AGENT_CONFIG_REPLAY"] !== "1";
 }
@@ -34070,8 +34369,8 @@ function isSafeTranscriptPath(rawPath, opts = {}) {
   try {
     const realHome = fs84.realpathSync(homeDir);
     const realPath = fs84.realpathSync(rawPath);
-    const relative13 = path83.relative(realHome, realPath);
-    if (relative13 === "" || relative13.startsWith("..") || path83.isAbsolute(relative13)) {
+    const relative14 = path83.relative(realHome, realPath);
+    if (relative14 === "" || relative14.startsWith("..") || path83.isAbsolute(relative14)) {
       return false;
     }
     const { size } = fs84.statSync(realPath);
@@ -36300,8 +36599,8 @@ if (_isCliEntry43()) {
 }
 
 // src/scripts/hooks/session_eol_hook.ts
-import * as fs95 from "node:fs";
-import * as path96 from "node:path";
+import * as fs97 from "node:fs";
+import * as path97 from "node:path";
 import process16 from "node:process";
 import { fileURLToPath as fileURLToPath63, pathToFileURL as pathToFileURL54 } from "node:url";
 
@@ -36444,6 +36743,16 @@ function eolStateFile(workspaceRoot3, sessionKey) {
 function eolSessionKey(raw) {
   return crypto13.createHash("sha256").update(raw || "unknown-session").digest("hex");
 }
+var SUBSTANTIVE_TOKEN_FLOOR = 1e4;
+function is_substantive(counters) {
+  if (counters === null) return true;
+  if (!Number.isFinite(counters.assistant_records)) return true;
+  if (counters.assistant_records < 1) return false;
+  if (!Number.isFinite(counters.tool_calls)) return true;
+  if (counters.tool_calls >= 1) return true;
+  if (!Number.isFinite(counters.final_context_tokens)) return true;
+  return counters.final_context_tokens >= SUBSTANTIVE_TOKEN_FLOOR;
+}
 function readNewCompleteLines(filePath, fromByte) {
   try {
     const { size } = fs91.statSync(filePath);
@@ -36705,10 +37014,273 @@ function writeCheckpoint(repoRoot, cp) {
   }
 }
 
+// src/scripts/_lib/continuity_writer.ts
+import * as fs95 from "node:fs";
+function auto_record_enabled(root) {
+  try {
+    const settings = load_agent_settings({ cwd: root });
+    const section = settings["continuity"];
+    if (section && typeof section === "object" && !Array.isArray(section)) {
+      const v = section["auto_record"];
+      return v === "on" || v === true;
+    }
+  } catch {
+  }
+  return false;
+}
+function run_checkpoints_enabled(root) {
+  try {
+    const settings = load_agent_settings({ cwd: root });
+    const section = settings["continuity"];
+    if (section && typeof section === "object" && !Array.isArray(section)) {
+      const v = section["run_checkpoints"];
+      if (v === "off" || v === false) return false;
+    }
+  } catch {
+  }
+  return true;
+}
+var LIST_CAP = 12;
+function _clip(line) {
+  const one = line.replace(/\s+/g, " ").trim();
+  return one.length <= MAX_LINE_CHARS ? one : `${one.slice(0, MAX_LINE_CHARS - 1)}\u2026`;
+}
+function roadmapShape(text) {
+  let done = 0;
+  let total = 0;
+  const open = [];
+  for (const raw of phaseLines(text)) {
+    const m = CHECKBOX_LINE.exec(raw);
+    if (m === null) continue;
+    total += 1;
+    const mark = m[1];
+    if (mark === "x" || mark === "X") {
+      done += 1;
+      continue;
+    }
+    if (mark === "~" || mark === "-") continue;
+    if (open.length < LIST_CAP) {
+      open.push(_clip((m[2] ?? "").replace(/\*\*/g, "")));
+    }
+  }
+  return { done, total, open };
+}
+function acceptanceCriteria(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let inside = false;
+  for (const raw of lines) {
+    const heading = /^(#{2,3})[ \t]+(.*?)[ \t]*$/.exec(raw);
+    if (heading !== null) {
+      inside = /^Acceptance[ \t]+Criteria\b/i.test(heading[2] ?? "");
+      continue;
+    }
+    if (!inside) continue;
+    const m = CHECKBOX_LINE.exec(raw);
+    if (m === null) continue;
+    if (out.length < LIST_CAP) {
+      out.push(_clip((m[2] ?? "").replace(/\*\*/g, "")));
+    }
+  }
+  return out;
+}
+function buildContinuityRecord(input) {
+  const { root, sessionId: sessionId3, slug, counters } = input;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  if (!is_substantive(counters)) {
+    return {
+      record: null,
+      reason: "no record \u2014 the session is not substantive by the committed floor"
+    };
+  }
+  if (slug === null || slug.trim() === "") {
+    return {
+      record: null,
+      reason: "no record \u2014 no claimed roadmap, so no deterministic acceptance criterion exists"
+    };
+  }
+  let text;
+  try {
+    text = fs95.readFileSync(roadmapPath(root, slug), "utf-8");
+  } catch {
+    return { record: null, reason: `no record \u2014 the claimed roadmap ${slug} is not readable` };
+  }
+  const shape = roadmapShape(text);
+  if (shape.total === 0) {
+    return { record: null, reason: `no record \u2014 ${slug} carries no phase checkboxes to count` };
+  }
+  const declared = acceptanceCriteria(text);
+  const criteria = declared.length > 0 ? declared : (
+    // A roadmap with no declared criteria still has one definitional
+    // completion condition, and it is derived from the artefact class
+    // rather than judged: every step closed. Anything richer would be
+    // a definition of done nobody wrote.
+    [`every phase step in agents/roadmaps/${slug}.md is closed`]
+  );
+  const record = {
+    capsule_version: CAPSULE_SCHEMA_VERSION,
+    variant: "continuity_record",
+    summary: _clip(`${slug}: ${shape.done} of ${shape.total} steps closed`),
+    task: _clip(slug),
+    workspace: root,
+    written_at: now.toISOString(),
+    acceptance_criteria: criteria.slice(0, MAX_ENTRIES),
+    remaining: shape.open.slice(0, MAX_ENTRIES),
+    predecessor: resolvePredecessor(root, sessionId3),
+    artifact_paths: [`agents/roadmaps/${slug}.md`]
+  };
+  if (sessionId3.trim() !== "") {
+    record["session_id"] = sessionId3.trim();
+  }
+  const head = readHead(root);
+  if (head !== null) {
+    record["head"] = head;
+  }
+  return { record, reason: `record built for ${slug} (${shape.done}/${shape.total} closed)` };
+}
+
+// src/scripts/_lib/continuity_slot.ts
+import * as fs96 from "node:fs";
+import * as path96 from "node:path";
+var MAX_AGE_MS = RECYCLE_MAX_AGE_HOURS * 3600 * 1e3;
+function _parse2(file) {
+  try {
+    const decoded = JSON.parse(fs96.readFileSync(file, "utf-8"));
+    if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+      return decoded;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function _ageMs(record, now) {
+  const raw = record["written_at"];
+  if (typeof raw !== "string") return null;
+  const at = Date.parse(raw);
+  if (Number.isNaN(at)) return null;
+  return now.getTime() - at;
+}
+function inspectSlot(workspace_root, session_id, now = /* @__PURE__ */ new Date()) {
+  const target = path96.join(workspace_root, recycle_envelope_rel(session_id));
+  if (!fs96.existsSync(target)) {
+    const consumed = path96.join(workspace_root, recycle_consumed_rel(session_id));
+    if (fs96.existsSync(consumed)) {
+      return { state: "consumed", reason: "the record for this session was consumed", target };
+    }
+    const quarantined = path96.join(workspace_root, recycle_quarantine_rel(session_id));
+    if (fs96.existsSync(quarantined)) {
+      return {
+        state: "quarantined",
+        reason: "the slot is free; an unusable record sits in quarantine",
+        target
+      };
+    }
+    return { state: "absent", reason: "no record in this slot", target };
+  }
+  const resident = _parse2(target);
+  if (resident === null) {
+    return { state: "quarantined", reason: "the resident record does not parse as an object", target };
+  }
+  const violations = validateRecycleEnvelope(resident);
+  if (violations.length > 0) {
+    return {
+      state: "quarantined",
+      reason: `the resident record fails validation (${violations.length} violation(s))`,
+      target,
+      resident
+    };
+  }
+  const age = _ageMs(resident, now);
+  if (age === null || age > MAX_AGE_MS) {
+    return {
+      state: "quarantined",
+      reason: age === null ? "the resident record carries no parseable written_at" : `the resident record is older than ${RECYCLE_MAX_AGE_HOURS} h`,
+      target,
+      resident
+    };
+  }
+  const owner = String(resident["session_id"] ?? "").trim();
+  const mine = String(session_id ?? "").trim();
+  if (owner !== "" && mine !== "" && owner !== mine) {
+    return {
+      state: "conflicting",
+      reason: `the slot holds an unconsumed record belonging to session ${owner}`,
+      target,
+      resident
+    };
+  }
+  return { state: "published", reason: "this session has an unconsumed record", target, resident };
+}
+function publishContinuityRecord(workspace_root, session_id, record, now = /* @__PURE__ */ new Date()) {
+  const violations = validateRecycleEnvelope(record);
+  if (violations.length > 0) {
+    return {
+      state: "absent",
+      wrote: false,
+      reason: `refused \u2014 the record to publish fails validation: ${violations[0]}`
+    };
+  }
+  const bytes = Buffer.byteLength(JSON.stringify(record, null, 2), "utf-8");
+  if (bytes > RECYCLE_ENVELOPE_MAX_BYTES) {
+    return {
+      state: "absent",
+      wrote: false,
+      reason: `refused \u2014 ${bytes} bytes exceeds the ${RECYCLE_ENVELOPE_MAX_BYTES} byte slot cap`
+    };
+  }
+  const target = path96.join(workspace_root, recycle_envelope_rel(session_id));
+  const before = inspectSlot(workspace_root, session_id, now);
+  if (before.state === "conflicting") {
+    return { state: "conflicting", wrote: false, reason: `refused \u2014 ${before.reason}` };
+  }
+  if (before.state === "published" && before.resident !== void 0) {
+    const residentAt = Date.parse(String(before.resident["written_at"] ?? ""));
+    const incomingAt = Date.parse(String(record["written_at"] ?? ""));
+    if (!Number.isNaN(residentAt) && !Number.isNaN(incomingAt) && incomingAt < residentAt) {
+      return {
+        state: "published",
+        wrote: false,
+        reason: "refused \u2014 the resident record is newer than the one offered"
+      };
+    }
+  }
+  let quarantined;
+  if (before.state === "quarantined" && fs96.existsSync(target)) {
+    const dest = path96.join(workspace_root, recycle_quarantine_rel(session_id));
+    try {
+      fs96.mkdirSync(path96.dirname(dest), { recursive: true });
+      fs96.renameSync(target, dest);
+      quarantined = dest;
+    } catch (exc) {
+      return {
+        state: "quarantined",
+        wrote: false,
+        reason: `refused \u2014 could not quarantine the unusable resident: ${String(exc)}`
+      };
+    }
+  }
+  const result = update_json_under_lock(target, () => record);
+  if (result !== "written") {
+    return {
+      state: before.state,
+      wrote: false,
+      reason: `refused \u2014 the slot write did not complete (${result})`,
+      ...quarantined !== void 0 ? { quarantined } : {}
+    };
+  }
+  return {
+    state: "published",
+    wrote: true,
+    reason: before.state === "published" ? "superseded this session\u2019s earlier record" : `published into a ${before.state} slot`,
+    ...quarantined !== void 0 ? { quarantined } : {}
+  };
+}
+
 // src/scripts/hooks/session_eol_hook.ts
 var EXIT_WARN19 = 2;
 var THRESHOLD_OVERRIDE_ENV = "AGENT_RECYCLE_THRESHOLD_TOKENS";
-var CONTEXT_FILL_REL = path96.join("agents", "runtime", "state", "context-fill.json");
+var CONTEXT_FILL_REL = path97.join("agents", "runtime", "state", "context-fill.json");
 function str12(value) {
   return typeof value === "string" ? value : "";
 }
@@ -36723,7 +37295,7 @@ function payloadSessionId(payload, envelope) {
 }
 function readState4(file) {
   try {
-    const parsed = JSON.parse(fs95.readFileSync(file, "utf-8"));
+    const parsed = JSON.parse(fs97.readFileSync(file, "utf-8"));
     if (parsed && typeof parsed === "object" && parsed.schema_version === 1 && parsed.counters && typeof parsed.counters.scanned_bytes === "number") {
       return {
         schema_version: 1,
@@ -36744,10 +37316,10 @@ function readState4(file) {
   };
 }
 function envelopeExists(workspaceRoot3, since = null, sessionId3 = null) {
-  const target = path96.join(workspaceRoot3, recycle_envelope_rel(sessionId3));
+  const target = path97.join(workspaceRoot3, recycle_envelope_rel(sessionId3));
   let raw;
   try {
-    raw = fs95.readFileSync(target, "utf-8");
+    raw = fs97.readFileSync(target, "utf-8");
   } catch (exc) {
     return exc?.code !== "ENOENT";
   }
@@ -36761,7 +37333,7 @@ function envelopeExists(workspaceRoot3, since = null, sessionId3 = null) {
   }
 }
 function buildMissingEnvelopeLine(workspaceRoot3, sessionId3 = null) {
-  return `recycle advised earlier, but no envelope exists at ${path96.join(workspaceRoot3, recycle_envelope_rel(sessionId3))} \u2014 /clear now starts the successor from nothing. Re-run \`agent-config session:recycle\` and check that it prints the absolute path it wrote before clearing.`;
+  return `recycle advised earlier, but no envelope exists at ${path97.join(workspaceRoot3, recycle_envelope_rel(sessionId3))} \u2014 /clear now starts the successor from nothing. Re-run \`agent-config session:recycle\` and check that it prints the absolute path it wrote before clearing.`;
 }
 function readThresholdTokens() {
   const override = process16.env[THRESHOLD_OVERRIDE_ENV];
@@ -36777,7 +37349,7 @@ function buildAdvisoryLine4(tokens, threshold) {
 }
 function writeContextFill(workspaceRoot3, tokens, threshold, ts) {
   try {
-    atomic_write_json(path96.join(workspaceRoot3, CONTEXT_FILL_REL), {
+    atomic_write_json(path97.join(workspaceRoot3, CONTEXT_FILL_REL), {
       schema_version: 1,
       final_context_tokens: tokens,
       recycle_threshold_tokens: threshold,
@@ -36837,7 +37409,7 @@ function main61() {
   }
   writeContextFill(workspaceRoot3, tokens, threshold, now);
   const checkpointRunId = payloadSessionId(payload, envelope);
-  if (shouldAdvise && checkpointRunId !== "") {
+  if (shouldAdvise && checkpointRunId !== "" && run_checkpoints_enabled(workspaceRoot3)) {
     try {
       const slug = read_claimed_slug(workspaceRoot3, checkpointRunId);
       if (slug !== null) {
@@ -36850,6 +37422,7 @@ function main61() {
     } catch {
     }
   }
+  writeContinuityRecord(workspaceRoot3, rawSessionId, counters, threshold, tokens);
   if (shouldAdvise && threshold !== null && tokens !== null) {
     process16.stdout.write(
       `${JSON.stringify({
@@ -36874,6 +37447,24 @@ function main61() {
   }
   return 0;
 }
+function writeContinuityRecord(workspaceRoot3, rawSessionId, counters, threshold, tokens) {
+  if (threshold === null || tokens === null || tokens < threshold) return;
+  const sessionId3 = String(rawSessionId ?? "").trim();
+  if (sessionId3 === "") return;
+  try {
+    if (!auto_record_enabled(workspaceRoot3)) return;
+    const slug = read_claimed_slug(workspaceRoot3, sessionId3);
+    const decision = buildContinuityRecord({
+      root: workspaceRoot3,
+      sessionId: sessionId3,
+      slug,
+      counters
+    });
+    if (decision.record === null) return;
+    publishContinuityRecord(workspaceRoot3, sessionId3, decision.record);
+  } catch {
+  }
+}
 function _isCliEntry44() {
   if (true) {
     return false;
@@ -36881,13 +37472,13 @@ function _isCliEntry44() {
   if (process16.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL54(path96.resolve(process16.argv[1])).href;
+  const argvUrl = pathToFileURL54(path97.resolve(process16.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs95.realpathSync(fileURLToPath63(import.meta.url));
-    const argv = fs95.realpathSync(path96.resolve(process16.argv[1]));
+    const here = fs97.realpathSync(fileURLToPath63(import.meta.url));
+    const argv = fs97.realpathSync(path97.resolve(process16.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -36898,14 +37489,14 @@ if (_isCliEntry44()) {
 }
 
 // src/scripts/hooks/tool_result_bytes_hook.ts
-import * as fs96 from "node:fs";
-import * as path97 from "node:path";
+import * as fs98 from "node:fs";
+import * as path98 from "node:path";
 import { fileURLToPath as fileURLToPath64, pathToFileURL as pathToFileURL55 } from "node:url";
 var EXIT_ALLOW31 = 0;
 function isObject17(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var CENSUS_FILE = path97.join("agents", "runtime", "state", "tool-result-census.jsonl");
+var CENSUS_FILE = path98.join("agents", "runtime", "state", "tool-result-census.jsonl");
 var RESULT_KEYS = ["tool_response", "toolResponse", "tool_result", "toolUseResult"];
 function _resultBytes(payload) {
   for (const key of RESULT_KEYS) {
@@ -36940,13 +37531,13 @@ function unwrapPayload4(envelope) {
   return isObject17(inner) ? inner : envelope;
 }
 function censusFile(consumerRoot) {
-  return path97.join(consumerRoot, CENSUS_FILE);
+  return path98.join(consumerRoot, CENSUS_FILE);
 }
 function _appendCensusLine(consumerRoot, line) {
   if (is_replay_mode()) return;
   const file = censusFile(consumerRoot);
-  fs96.mkdirSync(path97.dirname(file), { recursive: true });
-  fs96.appendFileSync(file, `${JSON.stringify(line)}
+  fs98.mkdirSync(path98.dirname(file), { recursive: true });
+  fs98.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
 }
 function processEnvelope4(envelope, consumerRoot) {
@@ -36992,10 +37583,10 @@ function _isCliEntry45() {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL55(path97.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL55(path98.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs96.realpathSync(fileURLToPath64(import.meta.url)) === fs96.realpathSync(path97.resolve(process.argv[1]));
+    return fs98.realpathSync(fileURLToPath64(import.meta.url)) === fs98.realpathSync(path98.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -37003,8 +37594,8 @@ function _isCliEntry45() {
 if (_isCliEntry45()) process.exit(main62());
 
 // src/scripts/hooks/spawn_guard_shadow_hook.ts
-import * as fs97 from "node:fs";
-import * as path98 from "node:path";
+import * as fs99 from "node:fs";
+import * as path99 from "node:path";
 import { fileURLToPath as fileURLToPath65, pathToFileURL as pathToFileURL56 } from "node:url";
 var EXIT_ALLOW32 = 0;
 function isObject18(v) {
@@ -37082,10 +37673,10 @@ function main63() {
 function _isCliEntry46() {
   if (true) return false;
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL56(path98.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL56(path99.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs97.realpathSync(fileURLToPath65(import.meta.url)) === fs97.realpathSync(path98.resolve(process.argv[1]));
+    return fs99.realpathSync(fileURLToPath65(import.meta.url)) === fs99.realpathSync(path99.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -37093,13 +37684,13 @@ function _isCliEntry46() {
 if (_isCliEntry46()) process.exit(main63());
 
 // src/scripts/hooks/source_first_gate_hook.ts
-import * as fs98 from "node:fs";
-import * as path99 from "node:path";
+import * as fs100 from "node:fs";
+import * as path100 from "node:path";
 import { fileURLToPath as fileURLToPath66, pathToFileURL as pathToFileURL57 } from "node:url";
 var EXIT_ALLOW33 = 0;
 var MAX_SHADOW_WARNS = 2;
-var SHADOW_LOG = path99.join("agents", "runtime", "state", "source-first-gate.jsonl");
-var STATE_FILE9 = path99.join("agents", "runtime", "state", "source-first-gate.json");
+var SHADOW_LOG = path100.join("agents", "runtime", "state", "source-first-gate.jsonl");
+var STATE_FILE9 = path100.join("agents", "runtime", "state", "source-first-gate.json");
 function isObject19(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -37173,7 +37764,7 @@ var EMPTY_STATE = { handoverSeen: false, sourceRead: false, wouldWarn: 0 };
 var MAX_SESSIONS2 = 50;
 function readState5(root, session) {
   try {
-    const all = JSON.parse(fs98.readFileSync(path99.join(root, STATE_FILE9), "utf-8"));
+    const all = JSON.parse(fs100.readFileSync(path100.join(root, STATE_FILE9), "utf-8"));
     const entry = all[session];
     if (entry && typeof entry.handoverSeen === "boolean" && typeof entry.sourceRead === "boolean" && typeof entry.wouldWarn === "number") {
       return entry;
@@ -37185,10 +37776,10 @@ function readState5(root, session) {
 function writeState4(root, session, state) {
   if (is_replay_mode()) return;
   try {
-    const file = path99.join(root, STATE_FILE9);
+    const file = path100.join(root, STATE_FILE9);
     let all = {};
     try {
-      all = JSON.parse(fs98.readFileSync(file, "utf-8"));
+      all = JSON.parse(fs100.readFileSync(file, "utf-8"));
     } catch {
     }
     if (!isObject19(all)) all = {};
@@ -37199,8 +37790,8 @@ function writeState4(root, session, state) {
       for (const key of keys.slice(keys.length - MAX_SESSIONS2)) pruned[key] = all[key];
       all = pruned;
     }
-    fs98.mkdirSync(path99.dirname(file), { recursive: true });
-    fs98.writeFileSync(file, JSON.stringify(all));
+    fs100.mkdirSync(path100.dirname(file), { recursive: true });
+    fs100.writeFileSync(file, JSON.stringify(all));
   } catch {
   }
 }
@@ -37221,7 +37812,7 @@ function evaluateCandidates2(handoverSeen, handoverOnDisk, sourceRead) {
 }
 function handoverPresentOnDisk(root) {
   try {
-    return fs98.statSync(path99.join(root, ".claude", "design-system")).isDirectory();
+    return fs100.statSync(path100.join(root, ".claude", "design-system")).isDirectory();
   } catch {
     return false;
   }
@@ -37229,9 +37820,9 @@ function handoverPresentOnDisk(root) {
 function appendShadowLine(root, line) {
   if (is_replay_mode()) return;
   try {
-    const file = path99.join(root, SHADOW_LOG);
-    fs98.mkdirSync(path99.dirname(file), { recursive: true });
-    fs98.appendFileSync(file, `${JSON.stringify(line)}
+    const file = path100.join(root, SHADOW_LOG);
+    fs100.mkdirSync(path100.dirname(file), { recursive: true });
+    fs100.appendFileSync(file, `${JSON.stringify(line)}
 `, "utf8");
   } catch {
   }
@@ -37307,10 +37898,10 @@ function main64() {
 function _isCliEntry47() {
   if (true) return false;
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL57(path99.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL57(path100.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs98.realpathSync(fileURLToPath66(import.meta.url)) === fs98.realpathSync(path99.resolve(process.argv[1]));
+    return fs100.realpathSync(fileURLToPath66(import.meta.url)) === fs100.realpathSync(path100.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -37318,12 +37909,12 @@ function _isCliEntry47() {
 if (_isCliEntry47()) process.exit(main64());
 
 // src/scripts/hooks/interruption_ledger_hook.ts
-import * as fs99 from "node:fs";
-import * as path100 from "node:path";
+import * as fs101 from "node:fs";
+import * as path101 from "node:path";
 import { fileURLToPath as fileURLToPath67, pathToFileURL as pathToFileURL58 } from "node:url";
 var EXIT_OK2 = 0;
 var TRANSCRIPT_READ_MAX_BYTES2 = 2 * 1024 * 1024;
-var LEDGER_RELPATH = path100.join("agents", "runtime", "state", "interruptions.jsonl");
+var LEDGER_RELPATH = path101.join("agents", "runtime", "state", "interruptions.jsonl");
 function hasNumberedOptions(reply) {
   let count = 0;
   for (const line of reply.split("\n")) {
@@ -37347,14 +37938,14 @@ function classifyReply(reply) {
 function readClaimedRoadmap(workspaceRoot3, sessionId3) {
   if (!sessionId3) return null;
   try {
-    const file = path100.join(
+    const file = path101.join(
       workspaceRoot3,
       "agents",
       "runtime",
       "state",
       `roadmap-claim-${sessionId3}.json`
     );
-    const parsed = JSON.parse(fs99.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs101.readFileSync(file, "utf8"));
     if (parsed === null || typeof parsed !== "object") return null;
     const slug = parsed["slug"];
     return typeof slug === "string" && slug.length > 0 ? slug : null;
@@ -37365,7 +37956,7 @@ function readClaimedRoadmap(workspaceRoot3, sessionId3) {
 function alreadyRecorded(ledgerPath, runId, turn) {
   let raw;
   try {
-    raw = fs99.readFileSync(ledgerPath, "utf8");
+    raw = fs101.readFileSync(ledgerPath, "utf8");
   } catch {
     return false;
   }
@@ -37409,7 +38000,7 @@ function main65() {
   if (!lastAssistant) return EXIT_OK2;
   const sessionId3 = str14(payload["session_id"]) || str14(envelope["session_id"]);
   const runId = sessionId3 ? derive_session_tag(sessionId3) : "unknown";
-  const ledgerPath = path100.join(workspaceRoot3, LEDGER_RELPATH);
+  const ledgerPath = path101.join(workspaceRoot3, LEDGER_RELPATH);
   if (alreadyRecorded(ledgerPath, runId, turnOrdinal)) return EXIT_OK2;
   const verdict2 = classifyReply(lastAssistant);
   const record = {
@@ -37421,8 +38012,8 @@ function main65() {
     at: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs99.mkdirSync(path100.dirname(ledgerPath), { recursive: true });
-    fs99.appendFileSync(ledgerPath, `${JSON.stringify(record)}
+    fs101.mkdirSync(path101.dirname(ledgerPath), { recursive: true });
+    fs101.appendFileSync(ledgerPath, `${JSON.stringify(record)}
 `, "utf8");
   } catch {
   }
@@ -37432,13 +38023,13 @@ function _isCliEntry48() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL58(path100.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL58(path101.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs99.realpathSync(fileURLToPath67(import.meta.url));
-    const argv = fs99.realpathSync(path100.resolve(process.argv[1]));
+    const here = fs101.realpathSync(fileURLToPath67(import.meta.url));
+    const argv = fs101.realpathSync(path101.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -37449,15 +38040,15 @@ if (_isCliEntry48()) {
 }
 
 // src/scripts/hooks/run_continuation_hook.ts
-import * as fs101 from "node:fs";
+import * as fs103 from "node:fs";
 
 // src/scripts/_lib/billing_grant.ts
-import * as fs100 from "node:fs";
-import * as path101 from "node:path";
-var BILLING_GRANT_DIR_REL = path101.join("agents", "runtime", "billing-grants");
+import * as fs102 from "node:fs";
+import * as path102 from "node:path";
+var BILLING_GRANT_DIR_REL = path102.join("agents", "runtime", "billing-grants");
 var BILLING_GRANT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function grantFile(repoRoot, runId) {
-  return path101.join(
+  return path102.join(
     repoRoot,
     BILLING_GRANT_DIR_REL,
     `${runId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`
@@ -37465,13 +38056,13 @@ function grantFile(repoRoot, runId) {
 }
 function revokeBillingGrant(repoRoot, runId) {
   try {
-    fs100.unlinkSync(grantFile(repoRoot, runId));
+    fs102.unlinkSync(grantFile(repoRoot, runId));
   } catch {
   }
 }
 
 // src/scripts/hooks/run_continuation_hook.ts
-import * as path102 from "node:path";
+import * as path103 from "node:path";
 import { fileURLToPath as fileURLToPath68, pathToFileURL as pathToFileURL59 } from "node:url";
 
 // src/scripts/_lib/outcome_vocabularies.ts
@@ -37562,13 +38153,13 @@ var EXIT_ALLOW34 = 0;
 var EXIT_BLOCK4 = 1;
 var BLOCKED_BY_MARKER = /<!--\s*blocked-by:\s*\S[^>]*-->/;
 var LEDGER_TAIL_MAX_BYTES = 512 * 1024;
-var EVENTS_RELPATH = path102.join(
+var EVENTS_RELPATH = path103.join(
   "agents",
   "runtime",
   "state",
   "run-continuation.jsonl"
 );
-var STATE_DIR_REL = path102.join("agents", "runtime", "state");
+var STATE_DIR_REL = path103.join("agents", "runtime", "state");
 var ABSENT_CONFIRM_FIRES = 2;
 var DUPLICATE_WINDOW_MS = 60 * 1e3;
 function isDuplicateFire(state, turnOrdinal, openCount, nowMs, roadmapSource) {
@@ -37640,20 +38231,20 @@ function extractVerify(stepText) {
 function stateRelPath(runId, slug) {
   const safeRun = runId.replace(/[^A-Za-z0-9_-]/g, "_");
   const safeSlug = slug.replace(/[^A-Za-z0-9_-]/g, "_");
-  return path102.join(STATE_DIR_REL, `run-continuation-${safeRun}-${safeSlug}.json`);
+  return path103.join(STATE_DIR_REL, `run-continuation-${safeRun}-${safeSlug}.json`);
 }
 function legacyStateRelPath(runId) {
   const safe = runId.replace(/[^A-Za-z0-9_-]/g, "_");
-  return path102.join(STATE_DIR_REL, `run-continuation-${safe}.json`);
+  return path103.join(STATE_DIR_REL, `run-continuation-${safe}.json`);
 }
 function readRunState(workspaceRoot3, runId, slug) {
-  const keyedFile = path102.join(workspaceRoot3, stateRelPath(runId, slug));
+  const keyedFile = path103.join(workspaceRoot3, stateRelPath(runId, slug));
   const keyed = readState6(keyedFile);
   if (keyed !== null) return { state: keyed, from: "keyed", keyedFile };
   if (fileExists(keyedFile)) {
     return { state: null, from: "keyed", keyedFile };
   }
-  const legacy = readState6(path102.join(workspaceRoot3, legacyStateRelPath(runId)));
+  const legacy = readState6(path103.join(workspaceRoot3, legacyStateRelPath(runId)));
   if (legacy === null) return { state: null, from: "none", keyedFile };
   if (legacy.roadmap !== void 0 && legacy.roadmap !== slug) {
     return { state: null, from: "none", keyedFile };
@@ -37666,25 +38257,25 @@ function writeState5(file, state) {
 function clearRunState(workspaceRoot3, runId, keyedFile, adoptedLegacy) {
   revokeBillingGrant(workspaceRoot3, runId);
   try {
-    fs101.rmSync(keyedFile, { force: true });
+    fs103.rmSync(keyedFile, { force: true });
   } catch {
   }
   if (!adoptedLegacy) return;
   try {
-    fs101.rmSync(path102.join(workspaceRoot3, legacyStateRelPath(runId)), { force: true });
+    fs103.rmSync(path103.join(workspaceRoot3, legacyStateRelPath(runId)), { force: true });
   } catch {
   }
 }
 function fileExists(p) {
   try {
-    return fs101.statSync(p).isFile();
+    return fs103.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function readState6(file) {
   try {
-    const parsed = JSON.parse(fs101.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs103.readFileSync(file, "utf8"));
     if (parsed === null || typeof parsed !== "object") return null;
     const o = parsed;
     if (typeof o["started_at"] !== "string") return null;
@@ -37725,16 +38316,16 @@ function readState6(file) {
   }
 }
 function normalizeDir(p) {
-  const abs = path102.resolve(p);
+  const abs = path103.resolve(p);
   try {
-    return fs101.realpathSync(abs);
+    return fs103.realpathSync(abs);
   } catch {
     return abs;
   }
 }
 function normalizeFile(p) {
-  const abs = path102.resolve(p);
-  return path102.join(normalizeDir(path102.dirname(abs)), path102.basename(abs));
+  const abs = path103.resolve(p);
+  return path103.join(normalizeDir(path103.dirname(abs)), path103.basename(abs));
 }
 function provenance(workspaceRoot3, claimPath, sessionRoot, sessionCwd) {
   const reader = normalizeDir(workspaceRoot3);
@@ -37761,36 +38352,36 @@ function provenance(workspaceRoot3, claimPath, sessionRoot, sessionCwd) {
   };
 }
 function resolveRoadmap(sessionRoot, workspaceRoot3, slug) {
-  const dirRel = path102.join("agents", "roadmaps");
+  const dirRel = path103.join("agents", "roadmaps");
   const stem = slug.trim().replace(/\.md$/, "");
-  const rel = path102.join(dirRel, `${stem}.md`);
-  const norm = path102.normalize(rel);
-  if (path102.dirname(norm) !== dirRel) return null;
-  if (sessionRoot !== workspaceRoot3 && isDirectory(path102.join(sessionRoot, dirRel))) {
-    return path102.join(sessionRoot, norm);
+  const rel = path103.join(dirRel, `${stem}.md`);
+  const norm = path103.normalize(rel);
+  if (path103.dirname(norm) !== dirRel) return null;
+  if (sessionRoot !== workspaceRoot3 && isDirectory(path103.join(sessionRoot, dirRel))) {
+    return path103.join(sessionRoot, norm);
   }
-  return path102.join(normalizeDir(workspaceRoot3), norm);
+  return path103.join(normalizeDir(workspaceRoot3), norm);
 }
 function isDirectory(p) {
   try {
-    return fs101.statSync(p).isDirectory();
+    return fs103.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function eventAlreadyLogged(workspaceRoot3, runId, slug, event) {
   try {
-    const file = path102.join(workspaceRoot3, EVENTS_RELPATH);
-    const size = fs101.statSync(file).size;
+    const file = path103.join(workspaceRoot3, EVENTS_RELPATH);
+    const size = fs103.statSync(file).size;
     const start = Math.max(0, size - LEDGER_TAIL_MAX_BYTES);
-    const fd = fs101.openSync(file, "r");
+    const fd = fs103.openSync(file, "r");
     let text;
     try {
       const buf = Buffer.alloc(size - start);
-      const read = fs101.readSync(fd, buf, 0, buf.length, start);
+      const read = fs103.readSync(fd, buf, 0, buf.length, start);
       text = buf.subarray(0, read).toString("utf8");
     } finally {
-      fs101.closeSync(fd);
+      fs103.closeSync(fd);
     }
     for (const line of text.split("\n")) {
       if (line === "") continue;
@@ -37813,9 +38404,9 @@ function eventAlreadyLogged(workspaceRoot3, runId, slug, event) {
 }
 function appendEvent2(workspaceRoot3, record) {
   try {
-    const file = path102.join(workspaceRoot3, EVENTS_RELPATH);
-    fs101.mkdirSync(path102.dirname(file), { recursive: true });
-    fs101.appendFileSync(file, `${JSON.stringify(record)}
+    const file = path103.join(workspaceRoot3, EVENTS_RELPATH);
+    fs103.mkdirSync(path103.dirname(file), { recursive: true });
+    fs103.appendFileSync(file, `${JSON.stringify(record)}
 `, "utf8");
   } catch {
   }
@@ -37823,7 +38414,7 @@ function appendEvent2(workspaceRoot3, record) {
 function refusedThisTurn(workspaceRoot3, sessionId3, turnOrdinal) {
   try {
     const file = sessionRefusalFile(workspaceRoot3, deriveSessionKey(sessionId3 || "unknown-session"));
-    const rec = parseRecord(fs101.readFileSync(file, "utf-8"));
+    const rec = parseRecord(fs103.readFileSync(file, "utf-8"));
     return rec !== null && rec.refused_turn === turnOrdinal;
   } catch {
     return false;
@@ -37857,7 +38448,7 @@ function main66() {
   let roadmapText = null;
   if (roadmapPath2 !== null) {
     try {
-      roadmapText = fs101.readFileSync(roadmapPath2, "utf8");
+      roadmapText = fs103.readFileSync(roadmapPath2, "utf8");
       roadmapFile = roadmapPath2;
     } catch {
       roadmapText = null;
@@ -37906,7 +38497,7 @@ function main66() {
   );
   if (!transcriptPath) return EXIT_ALLOW34;
   try {
-    if (fs101.statSync(transcriptPath).size > TRANSCRIPT_READ_MAX_BYTES) {
+    if (fs103.statSync(transcriptPath).size > TRANSCRIPT_READ_MAX_BYTES) {
       const inert = readRunState(workspaceRoot3, runId, slug);
       if (inert.state !== null && inert.state.inert_reported !== true) {
         const inertRoots = provenance(
@@ -38065,11 +38656,11 @@ function _isCliEntry49() {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL59(path102.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL59(path103.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    const here = fs101.realpathSync(fileURLToPath68(import.meta.url));
-    const argv = fs101.realpathSync(path102.resolve(process.argv[1]));
+    const here = fs103.realpathSync(fileURLToPath68(import.meta.url));
+    const argv = fs103.realpathSync(path103.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -38080,8 +38671,8 @@ if (_isCliEntry49()) {
 }
 
 // src/scripts/hooks/journal_record_hook.ts
-import * as fs103 from "node:fs";
-import * as path104 from "node:path";
+import * as fs105 from "node:fs";
+import * as path105 from "node:path";
 import { fileURLToPath as fileURLToPath69, pathToFileURL as pathToFileURL60 } from "node:url";
 
 // src/scripts/_lib/surface.ts
@@ -38112,8 +38703,8 @@ function readSurface(v) {
 
 // src/scripts/_lib/runtime_journal.ts
 import * as crypto14 from "node:crypto";
-import * as fs102 from "node:fs";
-import * as path103 from "node:path";
+import * as fs104 from "node:fs";
+import * as path104 from "node:path";
 
 // src/scripts/_lib/sqlite_schema.ts
 function addColumnIfMissing(db, table, column, decl) {
@@ -38215,7 +38806,7 @@ function requireId(name, id, optional) {
 }
 var JOURNAL_DIR_NAME = "agent-journal";
 var JOURNAL_FILE_NAME = "journal.sqlite";
-var JOURNAL_FALLBACK_REL = path103.join("agents", "runtime", "state", JOURNAL_FILE_NAME);
+var JOURNAL_FALLBACK_REL = path104.join("agents", "runtime", "state", JOURNAL_FILE_NAME);
 function digest(domain, input) {
   return crypto14.createHash("sha256").update(`${domain}\0${input}`).digest("hex").slice(0, 12);
 }
@@ -38226,20 +38817,20 @@ function resolveJournal(root) {
   if (common !== null) {
     const own = git_dir(root) ?? common;
     return {
-      path: path103.join(common, JOURNAL_DIR_NAME, JOURNAL_FILE_NAME),
+      path: path104.join(common, JOURNAL_DIR_NAME, JOURNAL_FILE_NAME),
       scope: "repo-shared",
       reason: "common git dir resolved \u2014 every worktree of this repo writes one database",
       repository_id: digest(REPO_DOMAIN, common),
       worktree_id: digest(WORKTREE_DOMAIN, own)
     };
   }
-  let real = path103.resolve(root);
+  let real = path104.resolve(root);
   try {
-    real = fs102.realpathSync(real);
+    real = fs104.realpathSync(real);
   } catch {
   }
   return {
-    path: path103.join(real, JOURNAL_FALLBACK_REL),
+    path: path104.join(real, JOURNAL_FALLBACK_REL),
     scope: "worktree-local",
     reason: "no common git dir \u2014 not inside a git repository; falling back to the tree-local path",
     repository_id: digest(REPO_DOMAIN, real),
@@ -38327,7 +38918,7 @@ function ensureWal(db) {
 function discard(dbPath) {
   for (const p of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
     try {
-      fs102.rmSync(p, { force: true });
+      fs104.rmSync(p, { force: true });
     } catch {
     }
   }
@@ -38339,9 +38930,9 @@ function openJournal(root) {
     );
   }
   const location = resolveJournal(root);
-  fs102.mkdirSync(path103.dirname(location.path), { recursive: true });
+  fs104.mkdirSync(path104.dirname(location.path), { recursive: true });
   const { DatabaseSync } = loadSqliteSync("runtime_journal");
-  if (fs102.existsSync(location.path)) {
+  if (fs104.existsSync(location.path)) {
     let drift = false;
     let probe = null;
     try {
@@ -38595,10 +39186,10 @@ function _isCliEntry50() {
     return false;
   }
   if (process.argv[1] === void 0) return false;
-  const argvUrl = pathToFileURL60(path104.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL60(path105.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) return true;
   try {
-    return fs103.realpathSync(fileURLToPath69(import.meta.url)) === fs103.realpathSync(path104.resolve(process.argv[1]));
+    return fs105.realpathSync(fileURLToPath69(import.meta.url)) === fs105.realpathSync(path105.resolve(process.argv[1]));
   } catch {
     return false;
   }
@@ -38667,7 +39258,7 @@ var CONCERN_REGISTRY = {
 };
 
 // src/scripts/hooks/category_a.ts
-import * as path105 from "node:path";
+import * as path106 from "node:path";
 var READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
   "Read",
   "Glob",
@@ -38846,10 +39437,10 @@ var SCRIPT_TAKING_SUBCOMMANDS = /* @__PURE__ */ new Set([
 ]);
 function isInsideWorkingTree(candidate, root) {
   if (!candidate.trim() || !root.trim()) return false;
-  const abs = path105.resolve(root, candidate);
-  const rel = path105.relative(path105.resolve(root), abs);
+  const abs = path106.resolve(root, candidate);
+  const rel = path106.relative(path106.resolve(root), abs);
   if (rel === "") return true;
-  return !rel.startsWith("..") && !path105.isAbsolute(rel);
+  return !rel.startsWith("..") && !path106.isAbsolute(rel);
 }
 function _argv(command) {
   return command.trim().split(/\s+/).filter((t) => t.length > 0);
@@ -38877,7 +39468,7 @@ function _gitSubcommand(argv) {
     if (!_isFlag(token)) return token;
     const [flag, inlineValue] = token.includes("=") ? [token.slice(0, token.indexOf("=")), token.slice(token.indexOf("=") + 1)] : [token, null];
     const value = inlineValue ?? (GIT_VALUE_FLAGS.has(flag) ? argv[++i] : void 0);
-    if (value !== void 0 && (path105.isAbsolute(value) || value.split("/").includes(".."))) {
+    if (value !== void 0 && (path106.isAbsolute(value) || value.split("/").includes(".."))) {
       return "";
     }
   }
@@ -39080,8 +39671,8 @@ function _py_json_dumps2(value, indent) {
 
 // src/scripts/_lib/collector_denominator.ts
 import crypto15 from "node:crypto";
-import fs105 from "node:fs";
-import path107 from "node:path";
+import fs107 from "node:fs";
+import path108 from "node:path";
 
 // src/scripts/_lib/collector_record.ts
 var COLLECTOR_EVENTS = [
@@ -39158,30 +39749,30 @@ var FIELD_PURPOSE = {
 var ALLOWED_FIELDS = new Set(Object.keys(FIELD_PURPOSE));
 
 // src/scripts/_lib/collector_store.ts
-import * as fs104 from "node:fs";
+import * as fs106 from "node:fs";
 import * as os13 from "node:os";
-import * as path106 from "node:path";
+import * as path107 from "node:path";
 var COLLECTOR_DIR_NAME = "agent-collector";
 var COLLECTOR_FILE_NAME = "collector.sqlite";
 var OPT_OUT_MARKER_NAME = "OPT-OUT";
 var MIGRATION_MARKER_NAME = "MIGRATION-IN-FLIGHT";
 var QUARANTINE_DIR_NAME = "quarantine";
 function defaultUserRoot() {
-  return path106.join(os13.homedir(), ".event4u", "agent-config");
+  return path107.join(os13.homedir(), ".event4u", "agent-config");
 }
 function resolveCollectorStore(userRoot = defaultUserRoot()) {
-  const dir = path106.join(userRoot, COLLECTOR_DIR_NAME);
+  const dir = path107.join(userRoot, COLLECTOR_DIR_NAME);
   return {
     userRoot,
     root: dir,
-    path: path106.join(dir, COLLECTOR_FILE_NAME),
-    optOutMarker: path106.join(dir, OPT_OUT_MARKER_NAME),
-    migrationMarker: path106.join(dir, MIGRATION_MARKER_NAME),
-    quarantineDir: path106.join(dir, QUARANTINE_DIR_NAME)
+    path: path107.join(dir, COLLECTOR_FILE_NAME),
+    optOutMarker: path107.join(dir, OPT_OUT_MARKER_NAME),
+    migrationMarker: path107.join(dir, MIGRATION_MARKER_NAME),
+    quarantineDir: path107.join(dir, QUARANTINE_DIR_NAME)
   };
 }
 function isOptedOut(userRoot = defaultUserRoot()) {
-  return fs104.existsSync(resolveCollectorStore(userRoot).optOutMarker);
+  return fs106.existsSync(resolveCollectorStore(userRoot).optOutMarker);
 }
 var MIGRATIONS = Object.freeze({
   // 0 → 1. No DDL: `user_version` 0 is the default SQLite assigns, and a
@@ -39198,24 +39789,24 @@ var SPOOL_DIR_NAME = "spool";
 var SPOOL_PENDING_NAME = "pending.jsonl";
 var ENABLED_MARKER_NAME = "ENABLED";
 function denominatorPath(userRoot) {
-  return path107.join(resolveCollectorStore(userRoot).root, DENOMINATOR_FILE_NAME);
+  return path108.join(resolveCollectorStore(userRoot).root, DENOMINATOR_FILE_NAME);
 }
 function spoolDir(userRoot) {
-  return path107.join(resolveCollectorStore(userRoot).root, SPOOL_DIR_NAME);
+  return path108.join(resolveCollectorStore(userRoot).root, SPOOL_DIR_NAME);
 }
 function spoolPendingPath(userRoot) {
-  return path107.join(spoolDir(userRoot), SPOOL_PENDING_NAME);
+  return path108.join(spoolDir(userRoot), SPOOL_PENDING_NAME);
 }
 function enabledMarkerPath(userRoot) {
-  return path107.join(resolveCollectorStore(userRoot).root, ENABLED_MARKER_NAME);
+  return path108.join(resolveCollectorStore(userRoot).root, ENABLED_MARKER_NAME);
 }
 function isCollectorEnabled(userRoot) {
   if (isOptedOut(userRoot)) return false;
-  if (fs105.existsSync(killSwitchPathLocal(userRoot))) return false;
-  return fs105.existsSync(enabledMarkerPath(userRoot));
+  if (fs107.existsSync(killSwitchPathLocal(userRoot))) return false;
+  return fs107.existsSync(enabledMarkerPath(userRoot));
 }
 function killSwitchPathLocal(userRoot) {
-  return path107.join(resolveCollectorStore(userRoot).root, "STOP");
+  return path108.join(resolveCollectorStore(userRoot).root, "STOP");
 }
 function utcDate(at = Date.now()) {
   return new Date(at).toISOString().slice(0, 10);
@@ -39227,8 +39818,8 @@ function recordOpportunity(event, platform, userRoot, at = Date.now(), opts = {}
     if (!COLLECTOR_EVENTS.includes(event)) return false;
     if (!COLLECTOR_PLATFORMS.includes(platform)) return false;
     const target = denominatorPath(userRoot);
-    fs105.mkdirSync(path107.dirname(target), { recursive: true });
-    fs105.appendFileSync(target, `${utcDate(at)}	${event}	${platform}
+    fs107.mkdirSync(path108.dirname(target), { recursive: true });
+    fs107.appendFileSync(target, `${utcDate(at)}	${event}	${platform}
 `);
     return true;
   } catch {
@@ -39242,19 +39833,19 @@ var MACHINE_ID_NAME = "machine-id";
 var EPISODE_DIR_NAME = "episodes";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function machineIdPath(userRoot) {
-  return path107.join(resolveCollectorStore(userRoot).root, MACHINE_ID_NAME);
+  return path108.join(resolveCollectorStore(userRoot).root, MACHINE_ID_NAME);
 }
 function machineId(userRoot) {
   const target = machineIdPath(userRoot);
   try {
-    const existing = fs105.readFileSync(target, "utf8").trim();
+    const existing = fs107.readFileSync(target, "utf8").trim();
     if (UUID_RE.test(existing)) return existing;
   } catch {
   }
   try {
     const minted = crypto15.randomUUID();
-    fs105.mkdirSync(path107.dirname(target), { recursive: true });
-    fs105.writeFileSync(target, `${minted}
+    fs107.mkdirSync(path108.dirname(target), { recursive: true });
+    fs107.writeFileSync(target, `${minted}
 `);
     return minted;
   } catch {
@@ -39278,17 +39869,17 @@ function episodeId(env = process.env) {
   ].join("-");
 }
 function nextSequence(episode, userRoot) {
-  const dir = path107.join(resolveCollectorStore(userRoot).root, EPISODE_DIR_NAME);
-  const target = path107.join(dir, `${episode}.seq`);
+  const dir = path108.join(resolveCollectorStore(userRoot).root, EPISODE_DIR_NAME);
+  const target = path108.join(dir, `${episode}.seq`);
   try {
-    fs105.mkdirSync(dir, { recursive: true });
+    fs107.mkdirSync(dir, { recursive: true });
     let current = 0;
     try {
-      const raw = Number.parseInt(fs105.readFileSync(target, "utf8").trim(), 10);
+      const raw = Number.parseInt(fs107.readFileSync(target, "utf8").trim(), 10);
       if (Number.isInteger(raw) && raw >= 0) current = raw + 1;
     } catch {
     }
-    fs105.writeFileSync(target, `${current}
+    fs107.writeFileSync(target, `${current}
 `);
     return current;
   } catch {
@@ -39327,12 +39918,12 @@ function spoolRecord(record, userRoot) {
   try {
     if (!isCollectorEnabled(userRoot)) return false;
     const target = spoolPendingPath(userRoot);
-    fs105.mkdirSync(path107.dirname(target), { recursive: true });
+    fs107.mkdirSync(path108.dirname(target), { recursive: true });
     try {
-      if (fs105.statSync(target).size >= SPOOL_MAX_BYTES) return false;
+      if (fs107.statSync(target).size >= SPOOL_MAX_BYTES) return false;
     } catch {
     }
-    fs105.appendFileSync(target, `${JSON.stringify(record)}
+    fs107.appendFileSync(target, `${JSON.stringify(record)}
 `);
     return true;
   } catch {
@@ -39342,11 +39933,11 @@ function spoolRecord(record, userRoot) {
 
 // src/scripts/hooks/dispatch_hook.ts
 var _IN_BUNDLE2 = true;
-var REPO_ROOT = path108.resolve(
-  path108.dirname(fileURLToPath70(import.meta.url)),
+var REPO_ROOT = path109.resolve(
+  path109.dirname(fileURLToPath70(import.meta.url)),
   ..._IN_BUNDLE2 ? ["..", ".."] : ["..", "..", ".."]
 );
-var MANIFEST_PATH = path108.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
+var MANIFEST_PATH = path109.join(REPO_ROOT, "src", "scripts", "hook_manifest.yaml");
 var EXIT_ALLOW37 = 0;
 var EXIT_BLOCK6 = 1;
 var EXIT_WARN20 = 2;
@@ -39408,11 +39999,11 @@ function _manifest_fingerprint(text) {
   return `${h.toString(16)}:${String(text.length)}`;
 }
 function _load_yaml3(p) {
-  const text = fs106.readFileSync(p, "utf-8");
+  const text = fs108.readFileSync(p, "utf-8");
   const compiled = p.replace(/\.ya?ml$/u, ".json");
   if (compiled !== p) {
     try {
-      const raw = JSON.parse(fs106.readFileSync(compiled, "utf-8"));
+      const raw = JSON.parse(fs108.readFileSync(compiled, "utf-8"));
       if (_isObject18(raw) && raw["fingerprint"] === _manifest_fingerprint(text) && _isObject18(raw["manifest"])) {
         return raw["manifest"];
       }
@@ -39510,7 +40101,7 @@ function _maybe_capture_payload(args, payload_text) {
   }
   try {
     const target = _expanduser3(capture_dir);
-    fs106.mkdirSync(target, { recursive: true });
+    fs108.mkdirSync(target, { recursive: true });
     let payload;
     try {
       payload = payload_text.trim() ? JSON.parse(payload_text) : {};
@@ -39527,8 +40118,8 @@ function _maybe_capture_payload(args, payload_text) {
     const ts = Date.now();
     const native = (args.native_event || args.event).replace(/\//g, "_");
     const fname = `${args.platform}__${native}__${ts}__${process.pid}.json`;
-    fs106.writeFileSync(
-      path108.join(target, fname),
+    fs108.writeFileSync(
+      path109.join(target, fname),
       _py_json_dumps2(record, 2) + "\n",
       { encoding: "utf-8" }
     );
@@ -39539,7 +40130,7 @@ function _maybe_capture_payload(args, payload_text) {
 function _expanduser3(p) {
   if (p === "~" || p.startsWith("~/")) {
     const home = process.env["HOME"] || process.env["USERPROFILE"] || "";
-    return path108.join(home, p.slice(1));
+    return path109.join(home, p.slice(1));
   }
   return p;
 }
@@ -39572,25 +40163,25 @@ function _resolve_tsx_invocation2(scriptPath, scriptArgs) {
   const walkUp = (start) => {
     let dir = start;
     for (; ; ) {
-      const candidate = path108.join(dir, "node_modules", ".bin", binName);
+      const candidate = path109.join(dir, "node_modules", ".bin", binName);
       if (_isFile8(candidate)) {
         return candidate;
       }
-      const parent = path108.dirname(dir);
+      const parent = path109.dirname(dir);
       if (parent === dir) {
         return null;
       }
       dir = parent;
     }
   };
-  const tsx = walkUp(path108.dirname(scriptPath)) ?? walkUp(path108.dirname(fileURLToPath70(import.meta.url)));
+  const tsx = walkUp(path109.dirname(scriptPath)) ?? walkUp(path109.dirname(fileURLToPath70(import.meta.url)));
   if (tsx !== null) {
     return { command: tsx, args: [scriptPath, ...scriptArgs] };
   }
   return { command: "npx", args: ["tsx", scriptPath, ...scriptArgs] };
 }
 function _run_concern_inproc(main_fn, concern, envelope) {
-  const scriptAbs = path108.join(REPO_ROOT, String(concern["script"]));
+  const scriptAbs = path109.join(REPO_ROOT, String(concern["script"]));
   const argsList = Array.isArray(concern["args"]) ? concern["args"].map((a) => String(a)) : [];
   argsList.push("--platform", String(envelope["platform"] || "generic"));
   const workspace = String(envelope["workspace_root"] || process.cwd());
@@ -39667,7 +40258,7 @@ function _run_concern(concern, envelope) {
       return _run_concern_inproc(inproc, concern, envelope);
     }
   }
-  const script = path108.join(REPO_ROOT, String(concern["script"]));
+  const script = path109.join(REPO_ROOT, String(concern["script"]));
   const argsList = Array.isArray(concern["args"]) ? concern["args"].map((a) => String(a)) : [];
   const cmd = [script, ...argsList];
   cmd.push("--platform", String(envelope["platform"] || "generic"));
@@ -39724,7 +40315,7 @@ function _run_concern(concern, envelope) {
 }
 function _isFile8(p) {
   try {
-    return fs106.statSync(p).isFile();
+    return fs108.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -39746,10 +40337,10 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     return;
   }
   const workspace = String(envelope["workspace_root"] || process.cwd());
-  const state_root = path108.join(workspace, "agents", "runtime", "state");
+  const state_root = path109.join(workspace, "agents", "runtime", "state");
   const fb_dir = feedback_dir(state_root, session_id);
   try {
-    fs106.mkdirSync(fb_dir, { recursive: true });
+    fs108.mkdirSync(fb_dir, { recursive: true });
   } catch (exc) {
     const msg = exc instanceof Error ? exc.message : String(exc);
     process.stderr.write(`dispatch_hook: feedback dir unavailable: ${msg}
@@ -39757,7 +40348,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
     return;
   }
   for (const entry of entries) {
-    const target = path108.join(fb_dir, `${entry["concern"]}.json`);
+    const target = path109.join(fb_dir, `${entry["concern"]}.json`);
     try {
       atomic_write_json(target, entry);
     } catch (exc) {
@@ -39806,7 +40397,7 @@ function _write_feedback(envelope, session_id, entries, final_rc, started_at) {
   };
   try {
     const invocation = `${String(process.pid)}-${process.hrtime.bigint().toString()}`;
-    update_json_under_lock(path108.join(fb_dir, "summary.json"), (loaded) => {
+    update_json_under_lock(path109.join(fb_dir, "summary.json"), (loaded) => {
       const priorRaw = loaded["invocations"];
       const prior = Array.isArray(priorRaw) ? priorRaw : [];
       const next = [...prior, { invocation, ...summary }];
@@ -39833,8 +40424,8 @@ function _record_rule_trips(envelope, entries) {
   if (tripped.length === 0) return;
   try {
     const workspace = String(envelope["workspace_root"] || process.cwd());
-    const state_dir = path108.join(workspace, "agents", "runtime", "state");
-    const target = path108.join(state_dir, "rule-trips.json");
+    const state_dir = path109.join(workspace, "agents", "runtime", "state");
+    const target = path109.join(state_dir, "rule-trips.json");
     const today = _now_iso3().slice(0, 10);
     update_json_under_lock(target, (loaded) => {
       const doc = { schema_version: 1, concerns: {}, ...loaded };
@@ -39976,7 +40567,7 @@ function main68(argv) {
   recordOpportunity(args.event, args.platform);
   recordCapture(args.event, args.platform);
   const manifest_path = args.manifest;
-  if (!fs106.existsSync(manifest_path)) {
+  if (!fs108.existsSync(manifest_path)) {
     process.stderr.write(`dispatch_hook: manifest missing at ${manifest_path}
 `);
     return EXIT_ALLOW37;
@@ -40146,7 +40737,7 @@ function main68(argv) {
 }
 function _isDir4(p) {
   try {
-    return fs106.statSync(p).isDirectory();
+    return fs108.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -40163,13 +40754,13 @@ function _isCliEntry51() {
   if (process.argv[1] === void 0) {
     return false;
   }
-  const argvUrl = pathToFileURL61(path108.resolve(process.argv[1])).href;
+  const argvUrl = pathToFileURL61(path109.resolve(process.argv[1])).href;
   if (import.meta.url === argvUrl) {
     return true;
   }
   try {
-    const here = fs106.realpathSync(fileURLToPath70(import.meta.url));
-    const argv = fs106.realpathSync(path108.resolve(process.argv[1]));
+    const here = fs108.realpathSync(fileURLToPath70(import.meta.url));
+    const argv = fs108.realpathSync(path109.resolve(process.argv[1]));
     return here === argv;
   } catch {
     return false;
@@ -40182,7 +40773,7 @@ if (isCliEntry16) {
 
 // src/scripts/hooks/dispatch_entry.ts
 var _selfPath = fileURLToPath71(import.meta.url);
-var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path109.resolve(process.argv[1]) === path109.resolve(_selfPath);
+var _invokedDirectly2 = globalThis.__AC_HOOKS_BUNDLE_DIRECT === true || process.argv[1] !== void 0 && path110.resolve(process.argv[1]) === path110.resolve(_selfPath);
 if (_invokedDirectly2) {
   process.exitCode = main68(process.argv.slice(2));
 }