@event4u/agent-config 14.4.0 → 14.6.0

package/dist/hooks/dispatch.js

@@ -7765,6 +7765,10 @@ function claudeAdditionalContext(event, text) {
   })}
 `;
 }
+function emissionCarriesReasons(platform, severity) {
+  if (!VERIFIED_PLATFORMS.has(platform)) return false;
+  return severity !== "allow";
+}
 function emitFor(platform, event, severity, reasons, legacyExit) {
   if (!VERIFIED_PLATFORMS.has(platform)) {
     return { exit: legacyExit, stdout: "", stderr: "" };
@@ -7790,6 +7794,13 @@ function emitFor(platform, event, severity, reasons, legacyExit) {
 
 // src/scripts/hooks/injection_budget.ts
 var TURN_START_EVENT = "user_prompt_submit";
+var RC_ALLOW = 0;
+var RC_WARN = 2;
+function _severityForRc(rc) {
+  if (rc === RC_ALLOW) return "allow";
+  if (rc === RC_WARN) return "warn";
+  return "block";
+}
 function isExempt(c) {
   if (c.failClosed) return true;
   return c.severity.trim().toLowerCase() !== "advisory";
@@ -7870,13 +7881,43 @@ function shapeEmissions(candidates, opts) {
     ceilingCause
   };
 }
-var TURN_SPEND_BASENAME = "injection-turn.json";
-function turnSpendPath(workspaceRoot2) {
-  return path3.join(workspaceRoot2, "agents", "runtime", "state", TURN_SPEND_BASENAME);
+var TURN_SPEND_DIR_REL = path3.join("agents", "runtime", "state", "injection-turn");
+var TURN_SPEND_MAX_FILES = 64;
+function turnSpendKey(session) {
+  const safe = session.replace(/[^A-Za-z0-9._-]/g, "_");
+  let h = 2166136261;
+  for (let i = 0; i < session.length; i += 1) {
+    h ^= session.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  const digest = h.toString(16).padStart(8, "0");
+  return `${safe.slice(0, 96)}.${digest}`;
+}
+function turnSpendPath(workspaceRoot2, session) {
+  return path3.join(workspaceRoot2, TURN_SPEND_DIR_REL, `${turnSpendKey(session)}.json`);
+}
+function _pruneTurnSpend(dir) {
+  try {
+    const entries = fs3.readdirSync(dir).filter((n) => n.endsWith(".json") || n.endsWith(".tmp")).map((n) => {
+      const p = path3.join(dir, n);
+      try {
+        return { p, mtime: fs3.statSync(p).mtimeMs };
+      } catch {
+        return { p, mtime: 0 };
+      }
+    }).sort((a, b) => b.mtime - a.mtime);
+    for (const stale of entries.slice(TURN_SPEND_MAX_FILES)) {
+      try {
+        fs3.unlinkSync(stale.p);
+      } catch {
+      }
+    }
+  } catch {
+  }
 }
 function readTurnSpend(workspaceRoot2, session) {
   try {
-    const raw = fs3.readFileSync(turnSpendPath(workspaceRoot2), "utf-8");
+    const raw = fs3.readFileSync(turnSpendPath(workspaceRoot2, session), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.session !== session) return 0;
     return typeof parsed.bytes === "number" && Number.isFinite(parsed.bytes) && parsed.bytes >= 0 ? parsed.bytes : 0;
@@ -7889,9 +7930,13 @@ function recordTurnSpend(workspaceRoot2, session, bytes, opts = {}) {
   const previous = opts.reset === true ? 0 : readTurnSpend(workspaceRoot2, session);
   const entry = { session, bytes: previous + Math.max(0, bytes) };
   try {
-    const target = turnSpendPath(workspaceRoot2);
-    fs3.mkdirSync(path3.dirname(target), { recursive: true });
-    fs3.writeFileSync(target, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+    const target = turnSpendPath(workspaceRoot2, session);
+    const dir = path3.dirname(target);
+    fs3.mkdirSync(dir, { recursive: true });
+    const tmp = `${target}.${String(process.pid)}.tmp`;
+    fs3.writeFileSync(tmp, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+    fs3.renameSync(tmp, target);
+    _pruneTurnSpend(dir);
   } catch {
   }
 }
@@ -7957,12 +8002,15 @@ function shapeAndRecord(ctx, messages, finalRc) {
       nudgeRank: typeof rank2 === "number" ? rank2 : null
     };
   });
-  if (!VERIFIED_PLATFORMS.has(ctx.platform)) {
-    return textOf(new Set(candidates.map((c) => c.concern)));
-  }
   const workspaceRoot2 = _workspaceRoot(ctx);
   const sessionKey = _sessionKey(ctx) ?? "";
   const cap = resolveVolumeCap(ctx);
+  if (!emissionCarriesReasons(ctx.platform, _severityForRc(finalRc))) {
+    if (cap !== null && ctx.event === TURN_START_EVENT) {
+      recordTurnSpend(workspaceRoot2, sessionKey, 0, { reset: true });
+    }
+    return textOf(new Set(candidates.map((c) => c.concern)));
+  }
   const turnStartsHere = ctx.event === TURN_START_EVENT;
   const spentBefore = cap === null || turnStartsHere ? 0 : readTurnSpend(workspaceRoot2, sessionKey);
   const shaped = shapeEmissions(candidates, { capBytes: cap, spentBytes: spentBefore });
@@ -11873,9 +11921,9 @@ function user_global_settings_paths() {
   if (flat !== null) {
     paths.push(flat);
   }
-  const canonical = resolve_with_fallback(USER_GLOBAL_CANONICAL_RELATIVE);
-  if (canonical !== null) {
-    paths.push(canonical);
+  const canonical2 = resolve_with_fallback(USER_GLOBAL_CANONICAL_RELATIVE);
+  if (canonical2 !== null) {
+    paths.push(canonical2);
   }
   if (paths.length === 0) {
     paths.push(DEFAULT_USER_GLOBAL_FILE());
@@ -18070,6 +18118,20 @@ var CAPSULE_SCHEMA_VERSION = 3;
 function isShortLine(value, max) {
   return typeof value === "string" && value.length > 0 && value.length <= max && !value.includes("\n");
 }
+function isPathRef(value) {
+  return typeof value === "string" && value.length > 0 && !/\s/.test(value);
+}
+function checkPathRefList(errors, field, value, max, required) {
+  checkList(errors, field, value, max, required);
+  if (!Array.isArray(value)) return;
+  if (value.some((x) => !isShortLine(x, max))) return;
+  const bad = value.filter((x) => !isPathRef(x));
+  if (bad.length === 0) return;
+  const shown = bad.slice(0, 3).map((x) => JSON.stringify(String(x))).join(", ");
+  errors.push(
+    `${field} carries ${bad.length} entr${bad.length === 1 ? "y" : "ies"} that are prose, not path refs: ${shown}${bad.length > 3 ? ", \u2026" : ""} \u2014 write the path (src/generated/api.ts, ../other-worktree/) or drop the entry; a sentence naming a file cannot be compared against a write target, and being comparable is the whole reason this is a field rather than a line of prose`
+  );
+}
 function checkList(errors, field, value, max, required) {
   if (value === void 0) {
     if (required) errors.push(`${field} is required`);
@@ -18259,7 +18321,7 @@ function validateRecycleEnvelope(input) {
   checkList(errors, "decisions", e["decisions"], MAX_LINE_CHARS, false);
   errors.push(...decisionTagErrors(e["decisions"]));
   checkList(errors, "constraints", e["constraints"], MAX_LINE_CHARS, false);
-  checkList(errors, "do_not_touch", e["do_not_touch"], MAX_REF_CHARS, false);
+  checkPathRefList(errors, "do_not_touch", e["do_not_touch"], MAX_REF_CHARS, false);
   checkList(errors, "open_worker_envelopes", e["open_worker_envelopes"], MAX_REF_CHARS, false);
   checkList(errors, "artifact_paths", e["artifact_paths"], MAX_REF_CHARS, false);
   checkList(errors, "suggested_skills", e["suggested_skills"], MAX_REF_CHARS, false);
@@ -20813,11 +20875,11 @@ function refresh_precommit_hook(root) {
     if (!current.includes(_PRECOMMIT_MARKER)) {
       return null;
     }
-    const canonical = fs35.readFileSync(template, "utf-8");
-    if (current === canonical) {
+    const canonical2 = fs35.readFileSync(template, "utf-8");
+    if (current === canonical2) {
       return null;
     }
-    fs35.writeFileSync(target, canonical);
+    fs35.writeFileSync(target, canonical2);
     fs35.chmodSync(target, 493);
     return target;
   } catch {
@@ -21405,15 +21467,15 @@ function _load_config_fail_open() {
 var _CODEX_PLUGIN_DATA_DIRNAME = `${CODEX_PLUGIN_ID}-${CODEX_MARKETPLACE_NAME}`;
 var UPSTREAM_GATE_JOB_TITLE = "Codex Stop Gate Review";
 function _workspace_state_segment(workspace_root) {
-  let canonical = workspace_root;
+  let canonical2 = workspace_root;
   try {
-    canonical = fs37.realpathSync.native(workspace_root);
+    canonical2 = fs37.realpathSync.native(workspace_root);
   } catch {
-    canonical = workspace_root;
+    canonical2 = workspace_root;
   }
   const slug_source = path38.basename(workspace_root) || "workspace";
   const slug = slug_source.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
-  const hash = crypto3.createHash("sha256").update(canonical).digest("hex").slice(0, 16);
+  const hash = crypto3.createHash("sha256").update(canonical2).digest("hex").slice(0, 16);
   return `${slug}-${hash}`;
 }
 function upstream_state_dir_candidates(workspace_root) {
@@ -21913,9 +21975,9 @@ function resolveAvailability(cwd, env) {
     return null;
   }
   const exists = fs41.existsSync(p);
-  const provenance = env[COUNCIL_CONFIG_ENV] ? "env-override" : "user-global";
+  const provenance2 = env[COUNCIL_CONFIG_ENV] ? "env-override" : "user-global";
   if (!exists) {
-    return { configured: false, path: p, exists: false, provenance, membersEnabled: 0, memberNames: [] };
+    return { configured: false, path: p, exists: false, provenance: provenance2, membersEnabled: 0, memberNames: [] };
   }
   try {
     const cfg = load_council_config(p);
@@ -21924,12 +21986,12 @@ function resolveAvailability(cwd, env) {
       configured: cfg.enabled && enabled4.length > 0,
       path: p,
       exists: true,
-      provenance,
+      provenance: provenance2,
       membersEnabled: enabled4.length,
       memberNames: enabled4
     };
   } catch {
-    return { configured: false, path: p, exists: true, provenance, membersEnabled: 0, memberNames: [] };
+    return { configured: false, path: p, exists: true, provenance: provenance2, membersEnabled: 0, memberNames: [] };
   }
 }
 function buildFact(a) {
@@ -23828,20 +23890,24 @@ function _read_claim_file(file) {
     return null;
   }
 }
-function read_claimed_slug(workspace_root, session_id) {
+function resolve_claim(workspace_root, session_id) {
   const own = roadmap_claim_rel(session_id);
   if (own !== ROADMAP_CLAIM_REL) {
     for (const p of claim_read_paths(workspace_root, session_id)) {
       if (path52.basename(p) === path52.basename(ROADMAP_CLAIM_REL)) continue;
       const mine = _read_claim_file(p);
-      if (mine !== null) return mine.slug;
+      if (mine !== null) return { slug: mine.slug, path: p };
     }
   }
   let legacy = null;
+  let legacy_path = "";
   for (const p of claim_read_paths(workspace_root, session_id)) {
     if (path52.basename(p) !== path52.basename(ROADMAP_CLAIM_REL)) continue;
     legacy = _read_claim_file(p);
-    if (legacy !== null) break;
+    if (legacy !== null) {
+      legacy_path = p;
+      break;
+    }
   }
   if (legacy === null) {
     return null;
@@ -23850,7 +23916,10 @@ function read_claimed_slug(workspace_root, session_id) {
   if (id !== "") {
     return null;
   }
-  return legacy.slug;
+  return { slug: legacy.slug, path: legacy_path };
+}
+function read_claimed_slug(workspace_root, session_id) {
+  return resolve_claim(workspace_root, session_id)?.slug ?? null;
 }
 function claim_is_stale(workspace_root, slug, peer_worktree) {
   if (slug === null || slug.trim() === "") {
@@ -23858,7 +23927,7 @@ function claim_is_stale(workspace_root, slug, peer_worktree) {
   }
   const base = slug.trim().replace(/\.md$/, "");
   const rel = path52.normalize(path52.join("agents", "roadmaps", `${base}.md`));
-  const inside = rel.startsWith(`agents${path52.sep}roadmaps${path52.sep}`) && !rel.includes("..");
+  const inside = path52.dirname(rel) === path52.join("agents", "roadmaps");
   if (!inside || path52.isAbsolute(base)) {
     return true;
   }
@@ -23877,18 +23946,40 @@ function claim_is_stale(workspace_root, slug, peer_worktree) {
   return true;
 }
 function session_checkout(workspace_root, payload_cwd) {
+  const fallback = canonical(workspace_root);
   const cwd = String(payload_cwd ?? "").trim();
-  if (cwd === "") return workspace_root;
+  if (cwd === "") return fallback;
+  let start;
   try {
-    if (!fs52.statSync(cwd).isDirectory()) return workspace_root;
+    if (!fs52.statSync(cwd).isDirectory()) return fallback;
+    start = fs52.realpathSync(cwd);
   } catch {
-    return workspace_root;
+    return fallback;
   }
-  if (git_dir(cwd) === null) return workspace_root;
-  const mine = git_common_dir(cwd);
+  const root = nearest_checkout_root(start);
+  if (root === null) return fallback;
+  const mine = git_common_dir(root);
   const theirs = git_common_dir(workspace_root);
-  if (mine === null || theirs === null || mine !== theirs) return workspace_root;
-  return cwd;
+  if (mine === null || theirs === null || mine !== theirs) return fallback;
+  return root;
+}
+function canonical(p) {
+  const abs = path52.resolve(p);
+  try {
+    return fs52.realpathSync(abs);
+  } catch {
+    return abs;
+  }
+}
+function nearest_checkout_root(start) {
+  let dir = start;
+  for (let i = 0; i < 64; i++) {
+    if (git_dir(dir) !== null) return dir;
+    const up = path52.dirname(dir);
+    if (up === dir) return null;
+    dir = up;
+  }
+  return null;
 }
 function build_record(workspace_root, session_id, platform, started_at, now = /* @__PURE__ */ new Date()) {
   const rec = {
@@ -23973,8 +24064,8 @@ function foreign_sessions_block(workspace_root, session_id, now = /* @__PURE__ *
     );
   }
   if (branch_hit !== null) {
-    const peer_tree = path52.resolve(branch_hit.record.worktree ?? "");
-    const same_tree = peer_tree !== "" && peer_tree === path52.resolve(workspace_root);
+    const peer_tree = canonical(branch_hit.record.worktree ?? "");
+    const same_tree = (branch_hit.record.worktree ?? "") !== "" && peer_tree === canonical(workspace_root);
     if (same_tree) {
       parts.push(
         "",
@@ -25738,15 +25829,15 @@ function targets_kernel_rule(filePath) {
   if (segments.length === 0) {
     return null;
   }
-  const basename9 = segments[segments.length - 1];
-  if (!is_kernel_rule(basename9)) {
+  const basename10 = segments[segments.length - 1];
+  if (!is_kernel_rule(basename10)) {
     return null;
   }
   const dirSegments = segments.slice(0, -1);
   if (!dirSegments.includes("rules")) {
     return null;
   }
-  return basename9.replace(/\.md$/, "");
+  return basename10.replace(/\.md$/, "");
 }
 var _MUTATOR_VERBS = /* @__PURE__ */ new Set([
   "sed",
@@ -26119,9 +26210,9 @@ import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL32 } fr
 
 // src/install/rtkDetection.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync11, statSync as statSync15, readFileSync as readFileSync27, writeFileSync as writeFileSync13, mkdirSync as mkdirSync15 } from "node:fs";
+import { existsSync as existsSync11, statSync as statSync16, readFileSync as readFileSync27, writeFileSync as writeFileSync13, mkdirSync as mkdirSync15 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { delimiter as delimiter2, join as join26, dirname as dirname16 } from "node:path";
+import { delimiter as delimiter2, join as join26, dirname as dirname17 } from "node:path";
 var TOKEN_KILLER_GAIN_SIGNATURE = /RTK Token Savings/;
 var PROBE_TIMEOUT_MS = 3e3;
 function resolveBinaryOnPath(name, pathEnv) {
@@ -26190,7 +26281,7 @@ function detectRtkCached(options = {}) {
   if (binPath === null) return { present: false };
   let stat = null;
   try {
-    const st = statSync15(binPath);
+    const st = statSync16(binPath);
     stat = { mtimeMs: st.mtimeMs, size: st.size };
   } catch {
     stat = null;
@@ -26216,7 +26307,7 @@ function detectRtkCached(options = {}) {
     };
     if (detection.version !== void 0) entry.version = detection.version;
     try {
-      mkdirSync15(dirname16(file), { recursive: true });
+      mkdirSync15(dirname17(file), { recursive: true });
       writeFileSync13(file, `${JSON.stringify(entry, null, 2)}
 `, "utf-8");
     } catch {
@@ -28008,14 +28099,14 @@ function int(flags, key) {
   return Number.isFinite(n) ? n : NaN;
 }
 function contentHashId(input) {
-  const canonical = JSON.stringify({
+  const canonical2 = JSON.stringify({
     ts: input.ts,
     spawn_count: input.spawn_count,
     token_delta: input.token_delta,
     tier_chosen: input.tier_chosen ?? null,
     task_class: input.task_class ?? null
   });
-  return crypto7.createHash("sha256").update(canonical).digest("hex").slice(0, 26).toUpperCase();
+  return crypto7.createHash("sha256").update(canonical2).digest("hex").slice(0, 26).toUpperCase();
 }
 function main41(argv = process.argv.slice(2)) {
   const flags = parseFlags(argv);
@@ -31962,6 +32053,8 @@ import * as path85 from "node:path";
 import { fileURLToPath as fileURLToPath56, pathToFileURL as pathToFileURL50 } from "node:url";
 var EXIT_ALLOW27 = 0;
 var EXIT_BLOCK5 = 1;
+var BLOCKED_BY_MARKER = /<!--\s*blocked-by:\s*\S[^>]*-->/;
+var LEDGER_TAIL_MAX_BYTES = 512 * 1024;
 var EVENTS_RELPATH = path85.join(
   "agents",
   "runtime",
@@ -31972,10 +32065,14 @@ var STATE_DIR_REL = path85.join("agents", "runtime", "state");
 var MAX_ITERATIONS = 25;
 var WALL_CLOCK_CAP_MS = 4 * 60 * 60 * 1e3;
 var STALL_WINDOW = 3;
+var ABSENT_CONFIRM_FIRES = 2;
 var DUPLICATE_WINDOW_MS = 60 * 1e3;
-function isDuplicateFire(state, turnOrdinal, openCount, nowMs) {
+function isDuplicateFire(state, turnOrdinal, openCount, nowMs, roadmapSource) {
   if (state === null) return false;
   if (state.last_turn !== turnOrdinal) return false;
+  if (state.history_source !== void 0 && roadmapSource !== void 0 && state.history_source !== roadmapSource) {
+    return false;
+  }
   if (state.history.length === 0 || state.history[state.history.length - 1] !== openCount) {
     return false;
   }
@@ -32017,7 +32114,7 @@ function scanOpenSteps(text) {
     }
     const full = step.join("\n");
     const body = m[1];
-    if (body.includes("blocked-by:")) {
+    if (BLOCKED_BY_MARKER.test(body)) {
       blocked += 1;
       continue;
     }
@@ -32041,13 +32138,13 @@ function extractVerify(stepText) {
   if (backticked !== null) return backticked[1].trim() || null;
   return null;
 }
-function ladder(state, openCount, nowMs, caps = {
+function ladder(state, openCount, nowMs, blockedCount, caps = {
   maxIterations: MAX_ITERATIONS,
   wallClockMs: WALL_CLOCK_CAP_MS,
   stallWindow: STALL_WINDOW
 }) {
   if (state.halted) return state.halted;
-  if (openCount === 0) return "complete";
+  if (openCount === 0) return blockedCount > 0 ? "blocked" : "complete";
   if (state.iterations >= caps.maxIterations) return "halt-max-iterations";
   const started = Date.parse(state.started_at);
   if (Number.isFinite(started) && nowMs - started >= caps.wallClockMs) {
@@ -32059,10 +32156,57 @@ function ladder(state, openCount, nowMs, caps = {
   }
   return "engage";
 }
-function stateRelPath(runId) {
+function stateRelPath(runId, slug) {
+  const safeRun = runId.replace(/[^A-Za-z0-9_-]/g, "_");
+  const safeSlug = slug.replace(/[^A-Za-z0-9_-]/g, "_");
+  return path85.join(STATE_DIR_REL, `run-continuation-${safeRun}-${safeSlug}.json`);
+}
+function legacyStateRelPath(runId) {
   const safe = runId.replace(/[^A-Za-z0-9_-]/g, "_");
   return path85.join(STATE_DIR_REL, `run-continuation-${safe}.json`);
 }
+function readRunState(workspaceRoot2, runId, slug) {
+  const keyedFile = path85.join(workspaceRoot2, stateRelPath(runId, slug));
+  const keyed = readState4(keyedFile);
+  if (keyed !== null) return { state: keyed, from: "keyed", keyedFile };
+  if (fileExists(keyedFile)) {
+    return { state: null, from: "keyed", keyedFile };
+  }
+  const legacy = readState4(path85.join(workspaceRoot2, 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 };
+  }
+  return { state: legacy, from: "legacy", keyedFile };
+}
+function writeState3(file, state) {
+  try {
+    fs84.mkdirSync(path85.dirname(file), { recursive: true });
+    fs84.writeFileSync(file, `${JSON.stringify(state)}
+`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearRunState(workspaceRoot2, runId, keyedFile, adoptedLegacy) {
+  try {
+    fs84.rmSync(keyedFile, { force: true });
+  } catch {
+  }
+  if (!adoptedLegacy) return;
+  try {
+    fs84.rmSync(path85.join(workspaceRoot2, legacyStateRelPath(runId)), { force: true });
+  } catch {
+  }
+}
+function fileExists(p) {
+  try {
+    return fs84.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
 function readState4(file) {
   try {
     const parsed = JSON.parse(fs84.readFileSync(file, "utf8"));
@@ -32083,6 +32227,18 @@ function readState4(file) {
     if (typeof o["last_engaged_at"] === "string") {
       rec.last_engaged_at = o["last_engaged_at"];
     }
+    if (typeof o["history_source"] === "string") {
+      rec.history_source = o["history_source"];
+    }
+    if (typeof o["roadmap"] === "string") {
+      rec.roadmap = o["roadmap"];
+    }
+    if (typeof o["absent_fires"] === "number" && Number.isFinite(o["absent_fires"])) {
+      rec.absent_fires = o["absent_fires"];
+    }
+    if (o["inert_reported"] === true) {
+      rec.inert_reported = true;
+    }
     const halted = o["halted"];
     if (typeof halted === "string" && HALT_ACTIONS.includes(halted)) {
       rec.halted = halted;
@@ -32092,6 +32248,93 @@ function readState4(file) {
     return null;
   }
 }
+function normalizeDir(p) {
+  const abs = path85.resolve(p);
+  try {
+    return fs84.realpathSync(abs);
+  } catch {
+    return abs;
+  }
+}
+function normalizeFile(p) {
+  const abs = path85.resolve(p);
+  return path85.join(normalizeDir(path85.dirname(abs)), path85.basename(abs));
+}
+function provenance(workspaceRoot2, claimPath, sessionRoot, sessionCwd) {
+  const reader = normalizeDir(workspaceRoot2);
+  const writer = normalizeDir(sessionRoot);
+  return {
+    workspace_root: reader,
+    session_root: writer,
+    // Empty when the host sent no `cwd` at all, which is a different fact
+    // from a `cwd` that failed resolution — the first says the host is
+    // silent, the second says the session sat somewhere `session_checkout`
+    // would not trust. Both are readable; neither is guessed.
+    //
+    // Trimmed with the SAME rule `session_checkout` applies to the same
+    // string (round 3 finding 6). Without it a whitespace-padded value
+    // validated fine there and was `path.resolve`d here against the reader's
+    // cwd, fabricating a path that is neither `session_root` nor under it —
+    // precisely the shape the docblock above says no healthy resolution
+    // produces, so a healthy line read as degraded. A whitespace-only value
+    // now reads as host silence, which is what it is.
+    session_cwd: sessionCwd.trim() === "" ? "" : normalizeDir(sessionCwd.trim()),
+    git_dir: git_dir(writer) ?? "",
+    git_common_dir: git_common_dir(writer) ?? "",
+    claim_path: normalizeFile(claimPath)
+  };
+}
+function resolveRoadmap(sessionRoot, workspaceRoot2, slug) {
+  const dirRel = path85.join("agents", "roadmaps");
+  const stem = slug.trim().replace(/\.md$/, "");
+  const rel = path85.join(dirRel, `${stem}.md`);
+  const norm = path85.normalize(rel);
+  if (path85.dirname(norm) !== dirRel) return null;
+  if (sessionRoot !== workspaceRoot2 && isDirectory(path85.join(sessionRoot, dirRel))) {
+    return path85.join(sessionRoot, norm);
+  }
+  return path85.join(normalizeDir(workspaceRoot2), norm);
+}
+function isDirectory(p) {
+  try {
+    return fs84.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function eventAlreadyLogged(workspaceRoot2, runId, slug, event) {
+  try {
+    const file = path85.join(workspaceRoot2, EVENTS_RELPATH);
+    const size = fs84.statSync(file).size;
+    const start = Math.max(0, size - LEDGER_TAIL_MAX_BYTES);
+    const fd = fs84.openSync(file, "r");
+    let text;
+    try {
+      const buf = Buffer.alloc(size - start);
+      const read = fs84.readSync(fd, buf, 0, buf.length, start);
+      text = buf.subarray(0, read).toString("utf8");
+    } finally {
+      fs84.closeSync(fd);
+    }
+    for (const line of text.split("\n")) {
+      if (line === "") continue;
+      let rec;
+      try {
+        rec = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (rec === null || typeof rec !== "object") continue;
+      const o = rec;
+      if (o["event"] === event && o["run_id"] === runId && o["roadmap"] === slug) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 function appendEvent2(workspaceRoot2, record) {
   try {
     const file = path85.join(workspaceRoot2, EVENTS_RELPATH);
@@ -32125,13 +32368,60 @@ function main55() {
   }
   const workspaceRoot2 = str10(envelope["workspace_root"]) || process.cwd();
   const sessionId2 = str10(payload["session_id"]) || str10(envelope["session_id"]);
-  const slug = read_claimed_slug(workspaceRoot2, sessionId2 || null);
-  if (slug === null) return EXIT_ALLOW27;
-  const roadmapPath2 = path85.join(workspaceRoot2, "agents", "roadmaps", `${slug}.md`);
-  let roadmapText;
-  try {
-    roadmapText = fs84.readFileSync(roadmapPath2, "utf8");
-  } catch {
+  const claim = resolve_claim(workspaceRoot2, sessionId2 || null);
+  if (claim === null) return EXIT_ALLOW27;
+  const slug = claim.slug;
+  const sessionRoot = session_checkout(
+    workspaceRoot2,
+    str10(payload["cwd"])
+  );
+  const roadmapPath2 = resolveRoadmap(sessionRoot, workspaceRoot2, slug);
+  const runId = deriveSessionKey(sessionId2 || "unknown-session");
+  let roadmapFile = null;
+  let roadmapText = null;
+  if (roadmapPath2 !== null) {
+    try {
+      roadmapText = fs84.readFileSync(roadmapPath2, "utf8");
+      roadmapFile = roadmapPath2;
+    } catch {
+      roadmapText = null;
+    }
+  }
+  if (roadmapText === null || roadmapFile === null) {
+    const runState = readRunState(workspaceRoot2, runId, slug);
+    const driven = runState.state;
+    if (driven === null && runState.from === "none") return EXIT_ALLOW27;
+    if (driven?.halted !== void 0) return EXIT_ALLOW27;
+    const absenceRoots = provenance(
+      workspaceRoot2,
+      claim.path,
+      sessionRoot,
+      str10(payload["cwd"])
+    );
+    absenceRoots["roadmap_path"] = roadmapPath2;
+    const absentFires = (driven?.absent_fires ?? 0) + 1;
+    const firstAbsence = driven === null ? !eventAlreadyLogged(workspaceRoot2, runId, slug, "halt-roadmap-absent") : absentFires === 1;
+    if (firstAbsence) {
+      appendEvent2(workspaceRoot2, {
+        event: "halt-roadmap-absent",
+        run_id: runId,
+        roadmap: slug,
+        // `null` when the state file exists but could not be parsed.
+        // Reported as null rather than as 0, which would claim a fact the
+        // file no longer carries.
+        iterations: driven?.iterations ?? null,
+        absent_fires: driven === null ? null : absentFires,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        ...absenceRoots
+      });
+    }
+    if (driven === null) return EXIT_ALLOW27;
+    if (absentFires < ABSENT_CONFIRM_FIRES) {
+      driven.absent_fires = absentFires;
+      writeState3(runState.keyedFile, driven);
+      return EXIT_ALLOW27;
+    }
+    clearRunState(workspaceRoot2, runId, runState.keyedFile, runState.from === "legacy");
     return EXIT_ALLOW27;
   }
   if (parseExecutionMode(roadmapText) !== "autonomous") return EXIT_ALLOW27;
@@ -32140,7 +32430,29 @@ function main55() {
   );
   if (!transcriptPath) return EXIT_ALLOW27;
   try {
-    if (fs84.statSync(transcriptPath).size > TRANSCRIPT_READ_MAX_BYTES) return EXIT_ALLOW27;
+    if (fs84.statSync(transcriptPath).size > TRANSCRIPT_READ_MAX_BYTES) {
+      const inert = readRunState(workspaceRoot2, runId, slug);
+      if (inert.state !== null && inert.state.inert_reported !== true) {
+        const inertRoots = provenance(
+          workspaceRoot2,
+          claim.path,
+          sessionRoot,
+          str10(payload["cwd"])
+        );
+        inertRoots["roadmap_path"] = roadmapFile;
+        appendEvent2(workspaceRoot2, {
+          event: "inert-transcript-over-cap",
+          run_id: runId,
+          roadmap: slug,
+          iterations: inert.state.iterations,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          ...inertRoots
+        });
+        inert.state.inert_reported = true;
+        writeState3(inert.keyedFile, inert.state);
+      }
+      return EXIT_ALLOW27;
+    }
   } catch {
     return EXIT_ALLOW27;
   }
@@ -32152,57 +32464,73 @@ function main55() {
   } catch {
     return EXIT_ALLOW27;
   }
-  const runId = deriveSessionKey(sessionId2 || "unknown-session");
+  const roots = provenance(
+    workspaceRoot2,
+    claim.path,
+    sessionRoot,
+    str10(payload["cwd"])
+  );
+  roots["roadmap_path"] = roadmapFile;
   if (refusedThisTurn(workspaceRoot2, sessionId2, turnOrdinal)) {
     appendEvent2(workspaceRoot2, {
       event: "deferred-quality-gate",
       run_id: runId,
       roadmap: slug,
       turn: turnOrdinal,
-      at: (/* @__PURE__ */ new Date()).toISOString()
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...roots
     });
     return EXIT_ALLOW27;
   }
-  const stateFile4 = path85.join(workspaceRoot2, stateRelPath(runId));
-  const prev = readState4(stateFile4);
+  const mainState = readRunState(workspaceRoot2, runId, slug);
+  const stateFile4 = mainState.keyedFile;
+  const prev = mainState.state;
   const state = prev ?? {
     started_at: (/* @__PURE__ */ new Date()).toISOString(),
     iterations: 0,
     last_turn: -1,
-    history: []
+    history: [],
+    roadmap: slug
   };
+  state.roadmap = slug;
+  delete state.absent_fires;
   const scan = scanOpenSteps(roadmapText);
-  if (isDuplicateFire(prev, turnOrdinal, scan.open, Date.now())) {
+  if (isDuplicateFire(prev, turnOrdinal, scan.open, Date.now(), roadmapFile)) {
     process.stderr.write(_continuationText(slug, scan, state.iterations));
     return EXIT_BLOCK5;
   }
-  const action = ladder(state, scan.open, Date.now());
+  if (state.history_source !== roadmapFile) {
+    state.history = [];
+    state.history_source = roadmapFile;
+  }
+  const action = ladder(state, scan.open, Date.now(), scan.blocked);
   if (action !== "engage") {
-    appendEvent2(workspaceRoot2, {
-      event: action,
-      run_id: runId,
-      roadmap: slug,
-      turn: turnOrdinal,
-      iterations: state.iterations,
-      open: scan.open,
-      blocked: scan.blocked,
-      at: (/* @__PURE__ */ new Date()).toISOString()
-    });
+    const alreadyStamped = prev?.halted !== void 0;
+    const alreadyBlocked = action === "blocked" && eventAlreadyLogged(workspaceRoot2, runId, slug, "blocked");
+    if (!alreadyStamped && !alreadyBlocked) {
+      appendEvent2(workspaceRoot2, {
+        event: action,
+        run_id: runId,
+        roadmap: slug,
+        turn: turnOrdinal,
+        iterations: state.iterations,
+        open: scan.open,
+        blocked: scan.blocked,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        ...roots
+      });
+    }
     if (action === "complete") {
-      try {
-        fs84.rmSync(stateFile4, { force: true });
-      } catch {
-      }
+      clearRunState(workspaceRoot2, runId, stateFile4, mainState.from === "legacy");
+      return EXIT_ALLOW27;
+    }
+    if (action === "blocked") {
+      clearRunState(workspaceRoot2, runId, stateFile4, mainState.from === "legacy");
       return EXIT_ALLOW27;
     }
     if (!state.halted) {
       state.halted = action;
-      try {
-        fs84.mkdirSync(path85.dirname(stateFile4), { recursive: true });
-        fs84.writeFileSync(stateFile4, `${JSON.stringify(state)}
-`, "utf8");
-      } catch {
-      }
+      writeState3(stateFile4, state);
     }
     return EXIT_ALLOW27;
   }
@@ -32210,11 +32538,7 @@ function main55() {
   state.last_turn = turnOrdinal;
   state.history.push(scan.open);
   state.last_engaged_at = (/* @__PURE__ */ new Date()).toISOString();
-  try {
-    fs84.mkdirSync(path85.dirname(stateFile4), { recursive: true });
-    fs84.writeFileSync(stateFile4, `${JSON.stringify(state)}
-`, "utf8");
-  } catch {
+  if (!writeState3(stateFile4, state)) {
     return EXIT_ALLOW27;
   }
   appendEvent2(workspaceRoot2, {
@@ -32225,7 +32549,8 @@ function main55() {
     iteration: state.iterations,
     open: scan.open,
     blocked: scan.blocked,
-    at: (/* @__PURE__ */ new Date()).toISOString()
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...roots
   });
   process.stderr.write(_continuationText(slug, scan, state.iterations));
   return EXIT_BLOCK5;