@event4u/agent-config 9.33.0 → 9.35.0

package/dist/hooks/dispatch.js

@@ -3996,10 +3996,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep6, value } = collItem;
+        const { start, key, sep: sep7, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep6?.[0],
+          next: key ?? sep7?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -4013,7 +4013,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep6) {
+          if (!keyProps.anchor && !keyProps.tag && !sep7) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -4037,7 +4037,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep6 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep7 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -4053,7 +4053,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep6, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep7, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -4144,7 +4144,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep6 = "";
+        let sep7 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -4158,13 +4158,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep6 + cb;
-              sep6 = "";
+                comment += sep7 + cb;
+              sep7 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep6 += source;
+                sep7 += source;
               hasSpace = true;
               break;
             default:
@@ -4207,18 +4207,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep: sep6, value } = collItem;
+        const { start, key, sep: sep7, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep6?.[0],
+          next: key ?? sep7?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep6 && !value) {
+          if (!props.anchor && !props.tag && !sep7 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -4272,8 +4272,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep6 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep6, null, props, onError);
+        if (!isMap && !sep7 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep7, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -4285,7 +4285,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep6 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep7 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -4296,8 +4296,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep6)
-                for (const st of sep6) {
+              if (sep7)
+                for (const st of sep7) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -4314,7 +4314,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep6, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep7, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -4494,7 +4494,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep6 = "";
+      let sep7 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -4511,24 +4511,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep6 + indent.slice(trimIndent) + content;
-          sep6 = "\n";
+          value += sep7 + indent.slice(trimIndent) + content;
+          sep7 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep6 === " ")
-            sep6 = "\n";
-          else if (!prevMoreIndented && sep6 === "\n")
-            sep6 = "\n\n";
-          value += sep6 + indent.slice(trimIndent) + content;
-          sep6 = "\n";
+          if (sep7 === " ")
+            sep7 = "\n";
+          else if (!prevMoreIndented && sep7 === "\n")
+            sep7 = "\n\n";
+          value += sep7 + indent.slice(trimIndent) + content;
+          sep7 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep6 === "\n")
+          if (sep7 === "\n")
             value += "\n";
           else
-            sep6 = "\n";
+            sep7 = "\n";
         } else {
-          value += sep6 + content;
-          sep6 = " ";
+          value += sep7 + content;
+          sep7 = " ";
           prevMoreIndented = false;
         }
       }
@@ -4710,25 +4710,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep6 = " ";
+      let sep7 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep6 === "\n")
-            res += sep6;
+          if (sep7 === "\n")
+            res += sep7;
           else
-            sep6 = "\n";
+            sep7 = "\n";
         } else {
-          res += sep6 + match[1];
-          sep6 = " ";
+          res += sep7 + match[1];
+          sep7 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep6 + (match?.[1] ?? "");
+      return res + sep7 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -5538,14 +5538,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep6, value }) {
+    function stringifyItem({ start, key, sep: sep7, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep6)
-        for (const st of sep6)
+      if (sep7)
+        for (const st of sep7)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -6712,18 +6712,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep6;
+          let sep7;
           if (scalar.end) {
-            sep6 = scalar.end;
-            sep6.push(this.sourceToken);
+            sep7 = scalar.end;
+            sep7.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep6 = [this.sourceToken];
+            sep7 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep6 }]
+            items: [{ start, key: scalar, sep: sep7 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -6876,15 +6876,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep6 = it.sep;
-                  sep6.push(this.sourceToken);
+                  const sep7 = it.sep;
+                  sep7.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep: sep6 }]
+                    items: [{ start: start2, key, sep: sep7 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -7078,13 +7078,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep6 = fc.end.splice(1, fc.end.length);
-            sep6.push(this.sourceToken);
+            const sep7 = fc.end.splice(1, fc.end.length);
+            sep7.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep6 }]
+              items: [{ start, key: fc, sep: sep7 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -7993,7 +7993,7 @@ function* iter_corpus(roots = DEFAULT_SCAN_ROOTS, exts = [".md"]) {
 function report(findings, opts) {
   const check_label = opts.check_label;
   if (findings.length === 0) {
-    process.stdout.write(`\u2705  ${check_label}: clean (${_corpus_note()}).
+    process.stdout.write(`\u2705  ${check_label}: clean (${_corpus_note(opts.scanned_roots)}).
 `);
     return 0;
   }
@@ -8033,8 +8033,9 @@ function _pyG(n) {
   }
   return s;
 }
-function _corpus_note() {
-  return "scanned " + DEFAULT_SCAN_ROOTS.join(", ");
+function _corpus_note(scanned_roots) {
+  const roots = scanned_roots && scanned_roots.length > 0 ? scanned_roots : DEFAULT_SCAN_ROOTS;
+  return "scanned " + roots.join(", ");
 }
 var PyFloat = class {
   constructor(value) {
@@ -14035,6 +14036,11 @@ var import_yaml3 = __toESM(require_dist(), 1);
 import * as fs14 from "node:fs";
 import * as os2 from "node:os";
 import * as path13 from "node:path";
+
+// src/scripts/ai_council/quorum.ts
+var SOLO_FLOOR_MIN_PRESENT = 2;
+
+// src/scripts/ai_council/config.ts
 var _VALID_PROVIDERS = /* @__PURE__ */ new Set([
   "anthropic",
   "openai",
@@ -14341,6 +14347,9 @@ function _build_config(raw, source_path) {
     _asDict(_getOr(raw, "cli_call_budget", {}))
   );
   const quorum = _build_quorum(_get(raw, "quorum", "majority"));
+  const quorum_min_present = _build_quorum_min_present(
+    _get(raw, "quorum_min_present", SOLO_FLOOR_MIN_PRESENT)
+  );
   const necessity_classifier = _build_necessity_classifier(
     _asDict(_getOr(raw, "necessity_classifier", {}))
   );
@@ -14389,6 +14398,7 @@ function _build_config(raw, source_path) {
     consensus_scoring: consensus,
     cli_call_budget,
     quorum,
+    quorum_min_present,
     necessity_classifier,
     model_downgrade,
     debate,
@@ -15216,6 +15226,14 @@ function _build_quorum(raw) {
     `\`quorum\`=${_pyRepr3(raw)} must be 'majority' or an integer >= 1 (got ${_pyTypeName(raw)}).`
   );
 }
+function _build_quorum_min_present(raw) {
+  if (_isInt(raw) && raw >= 1) {
+    return raw;
+  }
+  throw new CouncilConfigError(
+    `\`quorum_min_present\`=${_pyRepr3(raw)} must be an integer >= 1 (got ${_pyTypeName(raw)}).`
+  );
+}
 function _build_advisor(name, cfg) {
   if (!_isDict(cfg)) {
     throw new CouncilConfigError(`advisors.${name}: must be a mapping.`);
@@ -16205,6 +16223,38 @@ function hasBoundaryMarker(block) {
   // outside the datamarking while still riding in the same block.
   block.trimEnd().endsWith(ENVELOPE_BOUNDARY_CLOSE);
 }
+var DECISION_REVERSIBILITY_TAGS = ["reversible", "irreversible"];
+function decisionTagErrors(decisions) {
+  if (!Array.isArray(decisions)) {
+    return [];
+  }
+  const errors = [];
+  for (const line of decisions) {
+    if (typeof line !== "string") {
+      continue;
+    }
+    const m = /\[([^\]]*)\]\s*$/.exec(line.trimEnd());
+    if (m === null) {
+      continue;
+    }
+    const inner = (m[1] ?? "").trim();
+    const lowered = inner.toLowerCase();
+    if (DECISION_REVERSIBILITY_TAGS.includes(lowered)) {
+      if (inner !== lowered) {
+        errors.push(
+          `decisions: reversibility tag must be lower-case \u2014 got \`[${inner}]\`, expected \`[${lowered}]\``
+        );
+      }
+      continue;
+    }
+    if (/^i?rr?ever[a-z]*[^a-z]*$/i.test(lowered)) {
+      errors.push(
+        `decisions: \`[${inner}]\` is not a reversibility tag \u2014 use exactly ` + DECISION_REVERSIBILITY_TAGS.map((t) => `\`[${t}]\``).join(" or ") + ", or drop the bracket"
+      );
+    }
+  }
+  return errors;
+}
 var RECYCLE_ENVELOPE_KEYS = /* @__PURE__ */ new Set([
   "capsule_version",
   "variant",
@@ -16217,6 +16267,7 @@ var RECYCLE_ENVELOPE_KEYS = /* @__PURE__ */ new Set([
   "not_carried_forward",
   "decisions",
   "constraints",
+  "do_not_touch",
   "open_worker_envelopes",
   "artifact_paths",
   "assumptions",
@@ -16269,7 +16320,9 @@ function validateRecycleEnvelope(input) {
   checkList(errors, "remaining", e["remaining"], MAX_LINE_CHARS, true);
   checkList(errors, "not_carried_forward", e["not_carried_forward"], MAX_LINE_CHARS, true);
   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);
   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);
@@ -18839,6 +18892,12 @@ function claude_config_dir() {
   return env !== "" ? env : path32.join(os4.homedir(), ".claude");
 }
 
+// src/scripts/_lib/env_kill_switch.ts
+var _OFF_VALUES = /* @__PURE__ */ new Set(["", "0", "false", "False"]);
+function isEnvKillSwitchActive(name) {
+  return !_OFF_VALUES.has(process.env[name] ?? "");
+}
+
 // src/scripts/ai_team/config.ts
 var TeamConfigError = class extends Error {
   constructor(message) {
@@ -19048,8 +19107,7 @@ function circuit_breaker_notice(bound) {
   return `\u26A0\uFE0F team review-gate circuit breaker: ${bound} consecutive BLOCK verdict(s) this session (bound: \`ai_team.review_gate.max_consecutive_blocks\`). The managed gate stops re-blocking now \u2014 you decide: review the last BLOCK reason via \`/team:status\`, fix what is real, ignore what is not. An ALLOW verdict resets the counter.`;
 }
 function _kill_switch_active() {
-  const value = process.env[_KILL_SWITCH_ENV] ?? "";
-  return !(value === "" || value === "0" || value === "false" || value === "False");
+  return isEnvKillSwitchActive(_KILL_SWITCH_ENV);
 }
 function _iso_seconds_z(d) {
   const pad = (n, w = 2) => String(n).padStart(w, "0");
@@ -19930,6 +19988,28 @@ function fingerprint2(defect_class, evidence) {
   const shape = evidence.toLowerCase().replace(/\d+/g, "#").replace(/[`"'‚'„"»«]/g, "").replace(/[^a-zà-ÿ#\s]/g, " ").replace(/\s+/g, " ").trim();
   return createHash4("sha256").update(`${defect_class}|${shape}`).digest("hex").slice(0, 16);
 }
+var NEW_RECORDS_PER_SOURCE_PER_WINDOW = 20;
+var CREATION_WINDOW_MS = 24 * 60 * 60 * 1e3;
+function recentCreations(existing, source, now) {
+  const end = Date.parse(now);
+  if (Number.isNaN(end)) {
+    return 0;
+  }
+  return existing.filter((r) => {
+    if (r.source !== source) {
+      return false;
+    }
+    const t = Date.parse(r.first_seen);
+    return Number.isNaN(t) || end - t < CREATION_WINDOW_MS && end - t >= 0;
+  }).length;
+}
+function creationCapReached(existing, finding, now) {
+  const fp = fingerprint2(finding.defect_class, finding.evidence);
+  if (existing.some((r) => r.fingerprint === fp)) {
+    return false;
+  }
+  return recentCreations(existing, finding.source, now) >= NEW_RECORDS_PER_SOURCE_PER_WINDOW;
+}
 function mergeRecord(existing, finding, now) {
   const fp = fingerprint2(finding.defect_class, finding.evidence);
   if (existing !== null && existing.fingerprint === fp) {
@@ -19995,7 +20075,7 @@ function listRecords(root) {
   }
   const out = [];
   for (const n of names.sort()) {
-    if (!n.endsWith(".json")) {
+    if (!n.endsWith(".json") || n === OVERFLOW_FILE) {
       continue;
     }
     const rec = readRecord(root, n.slice(0, -".json".length));
@@ -20009,9 +20089,35 @@ function listRecords(root) {
 function openRecords(root) {
   return listRecords(root).filter((r) => r.status === "open");
 }
+var OVERFLOW_FILE = "_overflow.json";
+function overflowPath(root) {
+  return path38.join(storeDir(root), OVERFLOW_FILE);
+}
+function readOverflow(root) {
+  try {
+    const parsed = JSON.parse(fs37.readFileSync(overflowPath(root), "utf-8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function bumpOverflow(root, source, now) {
+  const counts = readOverflow(root);
+  const prev = counts[source]?.dropped ?? 0;
+  counts[source] = { dropped: prev + 1, last_seen: now };
+  const dir = storeDir(root);
+  fs37.mkdirSync(dir, { recursive: true });
+  fs37.writeFileSync(overflowPath(root), `${JSON.stringify(counts, null, 2)}
+`, "utf-8");
+}
 function upsertFinding(root, finding, now) {
   const fp = fingerprint2(finding.defect_class, finding.evidence);
-  const merged = mergeRecord(readRecord(root, fp), finding, now);
+  const existing = readRecord(root, fp);
+  if (existing === null && creationCapReached(listRecords(root), finding, now)) {
+    bumpOverflow(root, finding.source, now);
+    return null;
+  }
+  const merged = mergeRecord(existing, finding, now);
   writeRecord(root, merged);
   return merged;
 }
@@ -20405,35 +20511,109 @@ function foreign_live_records(dir, session_id, options = {}) {
   const own = safe_stem(session_id);
   return read_live_records(dir, options).filter((r) => safe_stem(r.session_id) !== own);
 }
+function classify_collisions(others, here) {
+  const out = [];
+  for (const r of others) {
+    if (here.roadmap_slug !== null && r.roadmap_slug !== null && r.roadmap_slug === here.roadmap_slug) {
+      out.push({ kind: "roadmap", record: r });
+    }
+  }
+  for (const r of others) {
+    if (here.branch !== null && r.branch === here.branch) {
+      out.push({ kind: "branch", record: r });
+    }
+  }
+  return out;
+}
 
 // src/scripts/session_register_hook.ts
 var REPLAY_ENV_VAR6 = "AGENT_CONFIG_REPLAY";
-var ROADMAP_CLAIM_REL = path42.join("agents", "runtime", "state", "roadmap-claim.json");
+var _STATE_REL = path42.join("agents", "runtime", "state");
+var ROADMAP_CLAIM_REL = path42.join(_STATE_REL, "roadmap-claim.json");
+function roadmap_claim_rel(session_id) {
+  const id = String(session_id ?? "").trim();
+  if (id === "") {
+    return ROADMAP_CLAIM_REL;
+  }
+  const rel = path42.join(_STATE_REL, `roadmap-claim-${safe_stem(id)}.json`);
+  const norm = path42.normalize(rel);
+  if (!norm.startsWith(`${_STATE_REL}${path42.sep}`) || norm.includes("..")) {
+    return ROADMAP_CLAIM_REL;
+  }
+  return norm;
+}
 function _is_replay_mode4() {
   return String(process9.env[REPLAY_ENV_VAR6] ?? "").trim() !== "";
 }
-function read_claimed_slug(workspace_root) {
+function _read_claim_file(file) {
   try {
-    const raw = fs41.readFileSync(path42.join(workspace_root, ROADMAP_CLAIM_REL), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const slug = parsed["slug"];
-      if (typeof slug === "string" && slug.trim().length > 0) {
-        return slug.trim();
-      }
+    const parsed = JSON.parse(fs41.readFileSync(file, "utf-8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
     }
-    return null;
+    const rec = parsed;
+    const slug = rec["slug"];
+    if (typeof slug !== "string" || slug.trim().length === 0) {
+      return null;
+    }
+    const sid = rec["session_id"];
+    return {
+      slug: slug.trim(),
+      ...typeof sid === "string" && sid.trim() !== "" ? { session_id: sid.trim() } : {}
+    };
   } catch {
     return null;
   }
 }
+function read_claimed_slug(workspace_root, session_id) {
+  const own = roadmap_claim_rel(session_id);
+  if (own !== ROADMAP_CLAIM_REL) {
+    const mine = _read_claim_file(path42.join(workspace_root, own));
+    if (mine !== null) {
+      return mine.slug;
+    }
+  }
+  const legacy = _read_claim_file(path42.join(workspace_root, ROADMAP_CLAIM_REL));
+  if (legacy === null) {
+    return null;
+  }
+  const id = String(session_id ?? "").trim();
+  if (id !== "") {
+    return null;
+  }
+  return legacy.slug;
+}
+function claim_is_stale(workspace_root, slug, peer_worktree) {
+  if (slug === null || slug.trim() === "") {
+    return false;
+  }
+  const base = slug.trim().replace(/\.md$/, "");
+  const rel = path42.normalize(path42.join("agents", "roadmaps", `${base}.md`));
+  const inside = rel.startsWith(`agents${path42.sep}roadmaps${path42.sep}`) && !rel.includes("..");
+  if (!inside || path42.isAbsolute(base)) {
+    return true;
+  }
+  const roots = [peer_worktree, workspace_root].filter(
+    (r) => typeof r === "string" && r.trim() !== ""
+  );
+  for (const root of roots) {
+    try {
+      if (fs41.existsSync(path42.join(root, rel))) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
 function build_record(workspace_root, session_id, platform, started_at, now = /* @__PURE__ */ new Date()) {
   return {
     session_id,
     platform,
     worktree: workspace_root,
     branch: current_branch(workspace_root),
-    roadmap_slug: read_claimed_slug(workspace_root),
+    roadmap_slug: read_claimed_slug(workspace_root, session_id),
     started_at,
     last_seen: iso_now(now)
   };
@@ -20451,20 +20631,26 @@ function foreign_sessions_block(workspace_root, session_id, now = /* @__PURE__ *
   const others = foreign_live_records(dir, session_id, { prune: true, now });
   if (others.length === 0) return null;
   const here = current_branch(workspace_root);
+  const my_slug = read_claimed_slug(workspace_root, session_id);
   const lines = [];
-  let collision = null;
+  const live_others = [];
   for (const r of others) {
     const age_min = Math.max(0, Math.round((now.getTime() - Date.parse(r.last_seen)) / 6e4));
-    const slug = r.roadmap_slug === null ? "no roadmap claimed" : `roadmap: ${r.roadmap_slug}`;
+    const stale = claim_is_stale(workspace_root, r.roadmap_slug, r.worktree);
+    const slug = r.roadmap_slug === null ? "no roadmap claimed" : stale ? `roadmap: ${r.roadmap_slug} (STALE \u2014 no such open roadmap; treat as no claim)` : `roadmap: ${r.roadmap_slug}`;
     const ttl_note = ttl_is_measured(r.platform) ? "" : ` \xB7 unmeasured host, TTL falls back to ${Math.round(ttl_seconds_for(r.platform) / 3600)}h`;
     lines.push(
       `- ${r.platform} \xB7 branch \`${r.branch ?? "detached"}\` \xB7 ${slug} \xB7 last seen ${age_min} min ago${ttl_note}
   worktree: ${r.worktree}`
     );
-    if (collision === null && here !== null && r.branch === here) {
-      collision = r;
-    }
+    live_others.push(stale ? { ...r, roadmap_slug: null } : r);
   }
+  const collisions = classify_collisions(live_others, {
+    branch: here,
+    roadmap_slug: claim_is_stale(workspace_root, my_slug) ? null : my_slug
+  });
+  const roadmap_hits = collisions.filter((c) => c.kind === "roadmap");
+  const branch_hit = collisions.find((c) => c.kind === "branch") ?? null;
   const parts = [
     "<session-register>",
     "The following OTHER agent sessions are live on this repository right now.",
@@ -20472,7 +20658,23 @@ function foreign_sessions_block(workspace_root, session_id, now = /* @__PURE__ *
     "",
     ...lines
   ];
-  if (collision !== null) {
+  if (roadmap_hits.length > 0) {
+    parts.push(
+      "",
+      `DUPLICATE WORK: ${roadmap_hits.length} other live session(s) claim the SAME roadmap \`${my_slug}\`.`,
+      ...roadmap_hits.map(
+        (h) => `  \xB7 branch \`${h.record.branch ?? "detached"}\` in ${h.record.worktree}`
+      ),
+      "A different branch name does NOT make this a different task \u2014 measured twice,",
+      "two sessions built one roadmap phase under two branch names and one PR was wasted.",
+      "STOP before writing code. Ask the user ONCE, as numbered options:",
+      "  1. Take a different roadmap (`agent-config sessions:list` shows what is held)",
+      "  2. Split the roadmap explicitly \u2014 name which phases are yours",
+      "  3. Continue anyway, accepting that one of the two results is discarded",
+      "Never decide silently, in either direction."
+    );
+  }
+  if (branch_hit !== null) {
     parts.push(
       "",
       `COLLISION: another live session already holds branch \`${here}\`.`,
@@ -20513,6 +20715,10 @@ function main25() {
     if (event === "session_end" || event === "stop" && stop_means_session_end(platform)) {
       const dir = register_dir(root);
       if (dir !== null) delete_record(dir, session_id);
+      try {
+        fs41.unlinkSync(path42.join(root, roadmap_claim_rel(session_id)));
+      } catch {
+      }
       return 0;
     }
     if (event === "session_start" || event === "user_prompt_submit" || event === "stop") {
@@ -22439,7 +22645,7 @@ import { fileURLToPath as fileURLToPath36, pathToFileURL as pathToFileURL29 } fr
 
 // src/install/rtkDetection.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync8, statSync as statSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync8, mkdirSync as mkdirSync9 } from "node:fs";
+import { existsSync as existsSync9, statSync as statSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync8, mkdirSync as mkdirSync9 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { delimiter, join as join19, dirname as dirname9 } from "node:path";
 var TOKEN_KILLER_GAIN_SIGNATURE = /RTK Token Savings/;
@@ -22452,7 +22658,7 @@ function resolveBinaryOnPath(name, pathEnv) {
     if (dir.length === 0) continue;
     for (const suffix of suffixes) {
       const candidate = join19(dir, `${name}${suffix}`);
-      if (existsSync8(candidate)) return candidate;
+      if (existsSync9(candidate)) return candidate;
     }
   }
   return null;
@@ -25266,6 +25472,32 @@ function detectLanguage(reply, pinned) {
     reason: `the pinned reply language is "${pinned}" but the reply classifies as "${verdict.language}" (${verdict.de_markers} de / ${verdict.en_markers} en markers; code, quotes, tables, URLs and paths excluded, then scored lead-first by the same classifier that sets the pin)`
   };
 }
+var _EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var _VERIFY_RE = /\b(test|tests|vitest|jest|pytest|phpunit|pest|tsc|eslint|ruff|mypy|pyright|clippy|typecheck|lint|build|ci|preflight|smoke[-_:a-z]*|check[-_:a-z]*|validate[-_:a-z]*)\b|\b(task|npm|pnpm|yarn|composer|cargo|go|make|php artisan|bun)\s+(run\s+)?\S*(test|check|lint|build|ci|typecheck)/i;
+function isVerificationCommand(command) {
+  return _VERIFY_RE.test(command);
+}
+function detectUnverifiedEdit(toolCalls) {
+  let lastEdit = -1;
+  for (let i = 0; i < toolCalls.length; i += 1) {
+    if (_EDIT_TOOLS.has(toolCalls[i].name)) lastEdit = i;
+  }
+  if (lastEdit === -1) return null;
+  for (let i = lastEdit + 1; i < toolCalls.length; i += 1) {
+    const c = toolCalls[i];
+    if (c.name === "Bash" && c.command !== void 0 && isVerificationCommand(c.command)) {
+      return null;
+    }
+  }
+  const edited = toolCalls[lastEdit].path;
+  return {
+    detector: "verification",
+    // The path, never the diff: the evidence span is quoted into a refusal,
+    // and `ToolCall` is shaped so a file body cannot reach it.
+    evidence: edited ?? toolCalls[lastEdit].name,
+    reason: "this turn changed a file and then ran no verification command \u2014 no test, type-check, lint or build call follows the last edit (verify-before-complete: a claim without a fresh run is unverified)"
+  };
+}
 function stateDir(workspaceRoot2) {
   return path59.join(workspaceRoot2, "agents", "runtime", "state", "turn-end-gate");
 }
@@ -25298,7 +25530,7 @@ function markRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal, detector) {
   }
 }
 function readTranscriptTail(transcriptPath, opts = {}) {
-  const empty = { lastAssistant: "", turnOrdinal: 0 };
+  const empty = { lastAssistant: "", turnOrdinal: 0, toolCalls: [] };
   if (!transcriptPath || !isSafeTranscriptPath(transcriptPath, opts)) return empty;
   let lines;
   try {
@@ -25311,6 +25543,7 @@ function readTranscriptTail(transcriptPath, opts = {}) {
   }
   let lastAssistant = "";
   let turnOrdinal = 0;
+  let toolCalls = [];
   for (const rawLine of lines) {
     const line = rawLine.trim();
     if (!line) continue;
@@ -25327,15 +25560,42 @@ function readTranscriptTail(transcriptPath, opts = {}) {
     if (role !== "assistant" && role !== "user") continue;
     const msg = entry["message"];
     if (typeof msg !== "object" || msg === null || Array.isArray(msg)) continue;
-    const text = _messageText(msg["content"]);
+    const content = msg["content"];
+    if (role === "assistant") {
+      toolCalls.push(..._toolCalls(content));
+    }
+    const text = _messageText(content);
     if (text === null) continue;
     if (role === "assistant") {
       lastAssistant = text;
     } else if (!isSyntheticPrompt(text)) {
       turnOrdinal += 1;
+      toolCalls = [];
     }
   }
-  return { lastAssistant: lastAssistant.trim(), turnOrdinal };
+  return { lastAssistant: lastAssistant.trim(), turnOrdinal, toolCalls };
+}
+function _toolCalls(content) {
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const blk of content) {
+    if (typeof blk !== "object" || blk === null || Array.isArray(blk)) continue;
+    const b = blk;
+    if (b["type"] !== "tool_use") continue;
+    const name = b["name"];
+    if (typeof name !== "string") continue;
+    const input = b["input"];
+    const call = { name };
+    if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+      const inp = input;
+      const cmd = inp["command"];
+      if (typeof cmd === "string") call.command = cmd;
+      const p = inp["file_path"] ?? inp["path"] ?? inp["notebook_path"];
+      if (typeof p === "string") call.path = p;
+    }
+    out.push(call);
+  }
+  return out;
 }
 function _messageText(content) {
   if (typeof content === "string") return content;
@@ -25359,7 +25619,12 @@ function _isOn(v) {
   return null;
 }
 function readGateSettings(workspaceRoot2) {
-  const off = { enabled: false, promissory: true, language: true };
+  const off = {
+    enabled: false,
+    promissory: true,
+    language: true,
+    verification: true
+  };
   let settings;
   try {
     settings = load_agent_settings({ cwd: workspaceRoot2 });
@@ -25378,7 +25643,8 @@ function readGateSettings(workspaceRoot2) {
   return {
     enabled: flag("enabled", false),
     promissory: flag("promissory", true),
-    language: flag("language", true)
+    language: flag("language", true),
+    verification: flag("verification", true)
   };
 }
 function str4(v) {
@@ -25399,7 +25665,7 @@ function main41() {
   const transcriptPath = str4(
     payload["transcript_path"] ?? payload["transcriptPath"]
   );
-  const { lastAssistant, turnOrdinal } = readTranscriptTail(transcriptPath, {
+  const { lastAssistant, turnOrdinal, toolCalls } = readTranscriptTail(transcriptPath, {
     maxBytes: TRANSCRIPT_READ_MAX_BYTES
   });
   if (!lastAssistant) return EXIT_ALLOW17;
@@ -25416,6 +25682,10 @@ function main41() {
     const f = detectLanguage(lastAssistant, readLanguagePin(workspaceRoot2));
     if (f) findings.push(f);
   }
+  if (settings.verification) {
+    const f = detectUnverifiedEdit(toolCalls);
+    if (f) findings.push(f);
+  }
   if (findings.length === 0) return EXIT_ALLOW17;
   markRefusedTurn(workspaceRoot2, sessionKey, turnOrdinal, findings[0].detector);
   const lines = findings.map(
@@ -25425,7 +25695,7 @@ function main41() {
   process.stderr.write(
     `turn-end-gate: REFUSED \u2014 this turn is not finished.
 ${lines.join("\n")}
-  Do the promised work now, or correct the language, then end the turn.
+  Do the promised work now, correct the language, or run the verification the edit needs, then end the turn.
   This turn will not be refused a second time.
   Disable: hooks.turn_end_gate.enabled: false in .agent-settings.yml
 `