@event4u/agent-config 14.5.0 → 14.6.0

package/dist/hooks/dispatch.js

@@ -11921,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());
@@ -18118,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`);
@@ -18307,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);
@@ -20861,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 {
@@ -21453,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) {
@@ -23913,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;
   }
@@ -23932,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 = {
@@ -24028,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(
         "",
@@ -25793,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",
@@ -26176,7 +26212,7 @@ import { fileURLToPath as fileURLToPath39, pathToFileURL as pathToFileURL32 } fr
 import { spawnSync as spawnSync5 } from "node:child_process";
 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) {
@@ -26271,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 {
@@ -28063,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);
@@ -32017,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",
@@ -32027,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;
   }
@@ -32072,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;
     }
@@ -32096,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) {
@@ -32114,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"));
@@ -32138,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;
@@ -32147,14 +32248,93 @@ function readState4(file) {
     return null;
   }
 }
-function provenance(workspaceRoot2, claimPath) {
+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: workspaceRoot2,
-    git_dir: git_dir(workspaceRoot2) ?? "",
-    git_common_dir: git_common_dir(workspaceRoot2) ?? "",
-    claim_path: claimPath
+    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);
@@ -32191,12 +32371,57 @@ function main55() {
   const claim = resolve_claim(workspaceRoot2, sessionId2 || null);
   if (claim === null) return EXIT_ALLOW27;
   const slug = claim.slug;
-  const roots = provenance(workspaceRoot2, claim.path);
-  const roadmapPath2 = path85.join(workspaceRoot2, "agents", "roadmaps", `${slug}.md`);
-  let roadmapText;
-  try {
-    roadmapText = fs84.readFileSync(roadmapPath2, "utf8");
-  } catch {
+  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;
@@ -32205,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;
   }
@@ -32217,7 +32464,13 @@ 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",
@@ -32229,47 +32482,55 @@ function main55() {
     });
     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(),
-      ...roots
-    });
+    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;
   }
@@ -32277,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, {

package/dist/mcp/registry-manifest.json

@@ -3,13 +3,13 @@
     "artefact_count": 609,
     "scanner_version": "de0a22b4ac4c"
   },
-  "generated_at": "2026-08-19",
+  "generated_at": "2026-08-20",
   "package": {
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) \u2014 every claim machine-checked, including \"zero runtime daemon\".",
     "homepage": "https://event4u-app.github.io/agent-config",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "14.5.0"
+    "version": "14.6.0"
   },
   "registries": [
     {

package/dist/mcp/server.json

@@ -9,12 +9,12 @@
       "transport": {
         "type": "stdio"
       },
-      "version": "14.5.0"
+      "version": "14.6.0"
     }
   ],
   "repository": {
     "source": "github",
     "url": "https://github.com/event4u-app/agent-config"
   },
-  "version": "14.5.0"
+  "version": "14.6.0"
 }