@event4u/agent-config 14.5.0 → 14.7.0

package/dist/cli-delegate/chunk-2GNWGMAL.js

@@ -0,0 +1,172 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  read_lockfile
+} from "./chunk-T7L2QK3K.js";
+
+// src/scripts/_lib/turn_end_refusals.ts
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var DETECTOR_IDS = [
+  "promissory",
+  "language",
+  "verification",
+  "completion"
+];
+var REFUSAL_STATE_REL = path.join("agents", "runtime", "state", "turn-end-gate");
+function refusalStateDir(workspaceRoot) {
+  return path.join(workspaceRoot, REFUSAL_STATE_REL);
+}
+function deriveSessionKey(sessionId) {
+  return crypto.createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+}
+function sessionRefusalFile(workspaceRoot, sessionKey) {
+  return path.join(refusalStateDir(workspaceRoot), `${sessionKey}.json`);
+}
+function readSessionCounts(workspaceRoot, sessionId) {
+  try {
+    const raw = fs.readFileSync(
+      sessionRefusalFile(workspaceRoot, deriveSessionKey(sessionId)),
+      "utf-8"
+    );
+    const rec = parseRecord(raw);
+    return rec === null ? null : countsOf(rec);
+  } catch {
+    return null;
+  }
+}
+function emptyCounts() {
+  return { promissory: 0, language: 0, verification: 0, completion: 0 };
+}
+function isDetector(v) {
+  return typeof v === "string" && DETECTOR_IDS.includes(v);
+}
+function parseRecord(raw) {
+  let decoded;
+  try {
+    decoded = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+  const o = decoded;
+  if (typeof o["refused_at"] !== "string") return null;
+  if (typeof o["refused_turn"] !== "number") return null;
+  if (!isDetector(o["detector"])) return null;
+  const rec = {
+    refused_at: o["refused_at"],
+    refused_turn: o["refused_turn"],
+    detector: o["detector"]
+  };
+  if (typeof o["first_refused_at"] === "string") rec.first_refused_at = o["first_refused_at"];
+  if (typeof o["agent_config_version"] === "string") {
+    rec.agent_config_version = o["agent_config_version"];
+  }
+  const counts = o["counts"];
+  if (typeof counts === "object" && counts !== null && !Array.isArray(counts)) {
+    const parsed = {};
+    for (const id of DETECTOR_IDS) {
+      const n = counts[id];
+      if (typeof n === "number" && Number.isFinite(n) && n >= 0) parsed[id] = n;
+    }
+    rec.counts = parsed;
+  }
+  return rec;
+}
+function countsOf(rec) {
+  const out = emptyCounts();
+  if (rec.counts === void 0) {
+    out[rec.detector] = 1;
+    return out;
+  }
+  let any = false;
+  for (const id of DETECTOR_IDS) {
+    const n = rec.counts[id];
+    if (typeof n === "number" && n > 0) {
+      out[id] = n;
+      any = true;
+    }
+  }
+  if (!any) out[rec.detector] = 1;
+  return out;
+}
+function foldRefusal(prev, input) {
+  const counts = prev === null ? emptyCounts() : countsOf(prev);
+  for (const d of input.detectors) counts[d] += 1;
+  const primary = input.detectors[0] ?? prev?.detector ?? "verification";
+  const rec = {
+    refused_at: input.at,
+    refused_turn: input.turnOrdinal,
+    detector: primary,
+    first_refused_at: prev?.first_refused_at ?? prev?.refused_at ?? input.at,
+    counts
+  };
+  if (input.version !== void 0) rec.agent_config_version = input.version;
+  else if (prev?.agent_config_version !== void 0) {
+    rec.agent_config_version = prev.agent_config_version;
+  }
+  return rec;
+}
+function readInstallBoundary() {
+  try {
+    const lock = read_lockfile();
+    if (lock === null) return { version: null, installed_at: null };
+    return {
+      version: lock.agent_config_version ?? null,
+      installed_at: lock.installed_at ?? null
+    };
+  } catch {
+    return { version: null, installed_at: null };
+  }
+}
+var REFUSAL_STATE_MAX_AGE_DAYS = 90;
+function pruneAgedRefusalState(workspaceRoot, opts = {}) {
+  const maxAgeDays = opts.maxAgeDays ?? REFUSAL_STATE_MAX_AGE_DAYS;
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const dir = refusalStateDir(workspaceRoot);
+  const result = { scanned: 0, pruned: 0, kept: 0 };
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return result;
+  }
+  const cutoffMs = now.getTime() - maxAgeDays * 24 * 60 * 60 * 1e3;
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    result.scanned += 1;
+    const file = path.join(dir, name);
+    let rec = null;
+    try {
+      rec = parseRecord(fs.readFileSync(file, "utf-8"));
+    } catch {
+      rec = null;
+    }
+    if (rec === null) {
+      result.kept += 1;
+      continue;
+    }
+    const at = Date.parse(rec.refused_at);
+    if (!Number.isFinite(at) || at >= cutoffMs) {
+      result.kept += 1;
+      continue;
+    }
+    try {
+      fs.unlinkSync(file);
+      result.pruned += 1;
+    } catch {
+      result.kept += 1;
+    }
+  }
+  return result;
+}
+
+export {
+  deriveSessionKey,
+  sessionRefusalFile,
+  readSessionCounts,
+  parseRecord,
+  foldRefusal,
+  readInstallBoundary,
+  pruneAgedRefusalState
+};

package/dist/cli-delegate/{chunk-RLN73PR5.js → chunk-4VR4ORQ6.js}

@@ -1,7 +1,10 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  statePathFor
+} from "./chunk-JZ4NR2TW.js";
 import {
   git_common_dir
-} from "./chunk-PZWRPRWP.js";
+} from "./chunk-6EOCNQAM.js";
 
 // src/scripts/_lib/envelope_grounding.ts
 import { execFileSync } from "node:child_process";
@@ -78,10 +81,10 @@ function collectRepoAnchor(root) {
     head: git(root, ["rev-parse", "HEAD"])
   };
 }
-var VERIFY_STATE_REL = path.join("agents", "runtime", "state", "verify-before-complete.json");
-function readLastVerify(root) {
+function readLastVerify(root, session_id) {
+  if (typeof session_id !== "string" || session_id.trim() === "") return null;
   try {
-    const raw = fs.readFileSync(path.join(root, VERIFY_STATE_REL), "utf-8");
+    const raw = fs.readFileSync(path.join(root, statePathFor(session_id)), "utf-8");
     const state = JSON.parse(raw);
     const lv = state["last_verification"];
     if (typeof lv !== "object" || lv === null || Array.isArray(lv)) return null;
@@ -94,11 +97,11 @@ function readLastVerify(root) {
     return null;
   }
 }
-function collectGrounding(root) {
+function collectGrounding(root, session_id) {
   const anchor = collectRepoAnchor(root);
   const porcelain = git(root, ["status", "--porcelain"]);
   if (porcelain === null) {
-    return { ...anchor, uncommitted_paths: [], status_summary: null, last_verify: readLastVerify(root) };
+    return { ...anchor, uncommitted_paths: [], status_summary: null, last_verify: readLastVerify(root, session_id) };
   }
   const lines = porcelain.split("\n").filter((l) => l.trim().length > 0);
   const paths = lines.map((l) => l.slice(3).trim()).filter((p) => p.length > 0 && p.length <= MAX_FIELD_CHARS).slice(0, MAX_PATHS);
@@ -106,7 +109,7 @@ function collectGrounding(root) {
     ...anchor,
     uncommitted_paths: paths,
     status_summary: lines.length === 0 ? "clean working tree" : `${lines.length} uncommitted path(s)${lines.length > MAX_PATHS ? `, first ${MAX_PATHS} listed` : ""}`,
-    last_verify: readLastVerify(root)
+    last_verify: readLastVerify(root, session_id)
   };
 }
 function describeDrift(envelope, actual) {

package/dist/cli-delegate/chunk-6EOCNQAM.js

@@ -0,0 +1,402 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/hooks/state_io.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+var LOCK_BASENAME = ".dispatcher.lock";
+var REPLAY_ENV_VAR = "AGENT_CONFIG_REPLAY";
+function is_replay_mode() {
+  return (process.env[REPLAY_ENV_VAR] ?? "").trim() === "1";
+}
+function _lock_path(state_dir) {
+  return path.join(state_dir, LOCK_BASENAME);
+}
+function _target_lock_path(target_path) {
+  return `${target_path}.lock`;
+}
+function _py_json_dumps(value, indent) {
+  const pad = " ".repeat(indent);
+  const escapeString = (s) => {
+    let out = '"';
+    for (const ch of s) {
+      const code = ch.codePointAt(0);
+      switch (ch) {
+        case '"':
+          out += '\\"';
+          break;
+        case "\\":
+          out += "\\\\";
+          break;
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "	":
+          out += "\\t";
+          break;
+        case "\b":
+          out += "\\b";
+          break;
+        case "\f":
+          out += "\\f";
+          break;
+        default:
+          if (code < 32 || code > 126) {
+            if (code > 65535) {
+              const c = code - 65536;
+              const hi = 55296 + (c >> 10);
+              const lo = 56320 + (c & 1023);
+              out += "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
+            } else {
+              out += "\\u" + code.toString(16).padStart(4, "0");
+            }
+          } else {
+            out += ch;
+          }
+      }
+    }
+    return out + '"';
+  };
+  const render = (v, depth) => {
+    if (v === null || v === void 0) {
+      return "null";
+    }
+    if (typeof v === "boolean") {
+      return v ? "true" : "false";
+    }
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) {
+        if (Number.isNaN(v)) return "NaN";
+        return v > 0 ? "Infinity" : "-Infinity";
+      }
+      return String(v);
+    }
+    if (typeof v === "string") {
+      return escapeString(v);
+    }
+    const curPad = pad.repeat(depth + 1);
+    const closePad = pad.repeat(depth);
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        return "[]";
+      }
+      const items = v.map((item) => curPad + render(item, depth + 1));
+      return "[\n" + items.join(",\n") + "\n" + closePad + "]";
+    }
+    if (typeof v === "object") {
+      const obj = v;
+      const keys = Object.keys(obj);
+      if (keys.length === 0) {
+        return "{}";
+      }
+      const items = keys.map(
+        (k) => curPad + escapeString(k) + ": " + render(obj[k], depth + 1)
+      );
+      return "{\n" + items.join(",\n") + "\n" + closePad + "}";
+    }
+    throw new TypeError(`Object of type ${typeof v} is not JSON serializable`);
+  };
+  return render(value, 0);
+}
+function atomic_write_json(target, payload, options = {}) {
+  if (is_replay_mode()) {
+    return;
+  }
+  const indent = options.indent ?? 2;
+  const targetPath = path.resolve(target);
+  const state_dir = path.dirname(targetPath);
+  fs.mkdirSync(state_dir, { recursive: true });
+  const body = _py_json_dumps(payload, indent) + "\n";
+  _atomic_write_text(targetPath, body);
+}
+function atomic_write_text(target, text) {
+  if (is_replay_mode()) {
+    return;
+  }
+  const targetPath = path.resolve(target);
+  const state_dir = path.dirname(targetPath);
+  fs.mkdirSync(state_dir, { recursive: true });
+  _atomic_write_text(targetPath, text);
+}
+var LOCK_STALE_MS = 3e4;
+var LOCK_ACQUIRE_DEADLINE_MS = 5e3;
+var LOCK_SPIN_SLEEP_MS = 2;
+function _sleep(ms) {
+  const sab = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(sab, 0, 0, ms);
+}
+function _acquire_lock(lock_path, options = {}) {
+  const blocking = options.blocking ?? true;
+  const fd = fs.openSync(lock_path, "a", 420);
+  const held = lock_path + ".held";
+  const give_up = () => {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+    return null;
+  };
+  const start = Date.now();
+  for (; ; ) {
+    try {
+      const heldFd = fs.openSync(held, "wx", 420);
+      fs.closeSync(heldFd);
+      return fd;
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        return fd;
+      }
+      let age_ms;
+      try {
+        age_ms = Date.now() - fs.statSync(held).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (age_ms >= LOCK_STALE_MS) {
+        try {
+          fs.rmSync(held, { force: true });
+        } catch {
+        }
+        continue;
+      }
+      if (!blocking) {
+        return give_up();
+      }
+      if (Date.now() - start > LOCK_ACQUIRE_DEADLINE_MS) {
+        return give_up();
+      }
+      _sleep(LOCK_SPIN_SLEEP_MS);
+    }
+  }
+}
+function _release_lock(fd, lock_path) {
+  try {
+    fs.closeSync(fd);
+  } catch {
+  }
+  try {
+    fs.rmSync(lock_path + ".held", { force: true });
+  } catch {
+  }
+}
+function _publish_text_locked(target, text) {
+  const tmp = target + `.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, text, { encoding: "utf-8" });
+  fs.renameSync(tmp, target);
+}
+function _atomic_write_text(target, text) {
+  const lock_path = _lock_path(path.dirname(target));
+  const fd = _acquire_lock(lock_path);
+  if (fd === null) {
+    _publish_text_locked(target, text);
+    return;
+  }
+  try {
+    _publish_text_locked(target, text);
+  } finally {
+    _release_lock(fd, lock_path);
+  }
+}
+function has_stable_session_id(session_id) {
+  return typeof session_id === "string" && session_id.trim() !== "";
+}
+function session_state_file(dir, session_id) {
+  const digest = createHash("sha256").update(session_id, "utf8").digest("hex").slice(0, 32);
+  return path.join(dir, `${digest}.json`);
+}
+function restore_claimed_state(tomb, live, link = fs.linkSync) {
+  try {
+    link(tomb, live);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EEXIST" && code !== "ENOENT") {
+      if (!NO_HARD_LINK_CODES.has(code ?? "")) throw err;
+      if (!fs.existsSync(live)) {
+        fs.renameSync(tomb, live);
+        return;
+      }
+    }
+  }
+  fs.rmSync(tomb, { force: true });
+}
+var NO_HARD_LINK_CODES = /* @__PURE__ */ new Set(["EPERM", "ENOSYS", "EXDEV", "EOPNOTSUPP", "EMLINK"]);
+function prune_stale_session_states(dir, now_ms, retention_days, mtime_of = (target) => fs.statSync(target).mtimeMs) {
+  if (is_replay_mode()) return 0;
+  const cutoff = now_ms - retention_days * 24 * 60 * 60 * 1e3;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return 0;
+  }
+  let removed = 0;
+  let claim = 0;
+  for (const name of entries) {
+    const orphan = /^(.+\.json)\.\d+\.\d+\.tomb$/.exec(name);
+    const live_name = orphan?.[1];
+    if (live_name === void 0) continue;
+    const tomb = path.join(dir, name);
+    const live = path.join(dir, live_name);
+    try {
+      if (mtime_of(tomb) >= cutoff) {
+        restore_claimed_state(tomb, live);
+        continue;
+      }
+      fs.rmSync(tomb, { force: true });
+      removed += 1;
+    } catch {
+    }
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    const full = path.join(dir, name);
+    try {
+      if (mtime_of(full) >= cutoff) continue;
+      claim += 1;
+      const tomb = `${full}.${process.pid}.${claim}.tomb`;
+      fs.renameSync(full, tomb);
+      if (mtime_of(tomb) >= cutoff) {
+        restore_claimed_state(tomb, full);
+        continue;
+      }
+      fs.rmSync(tomb, { force: true });
+      for (const suffix of [".lock", ".lock.held"]) {
+        try {
+          fs.rmSync(`${full}${suffix}`, { force: true });
+        } catch {
+        }
+      }
+      removed += 1;
+    } catch {
+    }
+  }
+  return removed;
+}
+function prune_legacy_state_file(target) {
+  if (is_replay_mode()) return;
+  try {
+    if (fs.statSync(target).isFile()) {
+      fs.rmSync(target, { force: true });
+    }
+  } catch {
+  }
+}
+function owns_session_state(state, session_id) {
+  if (typeof state !== "object" || state === null || Array.isArray(state)) return false;
+  return state["session_id"] === session_id;
+}
+function update_json_under_lock(target, mutate, options = {}) {
+  if (is_replay_mode()) return "failed";
+  const targetPath = path.resolve(target);
+  const state_dir = path.dirname(targetPath);
+  try {
+    fs.mkdirSync(state_dir, { recursive: true });
+  } catch {
+    return "failed";
+  }
+  const lock_path = _target_lock_path(targetPath);
+  let fd;
+  try {
+    fd = _acquire_lock(lock_path, { blocking: options.blocking ?? true });
+  } catch {
+    return "failed";
+  }
+  if (fd === null) return "failed";
+  try {
+    let loaded = {};
+    try {
+      const raw = fs.readFileSync(targetPath, "utf-8");
+      const decoded = JSON.parse(raw);
+      if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+        loaded = decoded;
+      }
+    } catch {
+    }
+    const next = mutate(loaded);
+    if (next === null) return "skipped";
+    _publish_text_locked(targetPath, _py_json_dumps(next, options.indent ?? 2) + "\n");
+    return "written";
+  } catch {
+    return "failed";
+  } finally {
+    _release_lock(fd, lock_path);
+  }
+}
+
+// src/scripts/_lib/git_common_dir.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+function realpath_or_self(p) {
+  try {
+    return fs2.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function git_dir(project_root) {
+  const dot_git = path2.join(project_root, ".git");
+  try {
+    const st = fs2.statSync(dot_git);
+    if (st.isDirectory()) {
+      return realpath_or_self(dot_git);
+    }
+    const m = fs2.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
+    if (m === null) {
+      return null;
+    }
+    return realpath_or_self(path2.resolve(project_root, m[1].trim()));
+  } catch {
+    return null;
+  }
+}
+function current_branch(project_root) {
+  const gd = git_dir(project_root);
+  if (gd === null) return null;
+  try {
+    const head = fs2.readFileSync(path2.join(gd, "HEAD"), "utf-8").trim();
+    const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+    return m === null ? null : m[1].trim();
+  } catch {
+    return null;
+  }
+}
+function git_common_dir(project_root) {
+  const dot_git = path2.join(project_root, ".git");
+  try {
+    const st = fs2.statSync(dot_git);
+    if (st.isDirectory()) {
+      return realpath_or_self(dot_git);
+    }
+    const m = fs2.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
+    if (m === null) {
+      return null;
+    }
+    const gitdir = path2.resolve(project_root, m[1].trim());
+    const commondir_file = path2.join(gitdir, "commondir");
+    if (fs2.existsSync(commondir_file)) {
+      const common = path2.resolve(gitdir, fs2.readFileSync(commondir_file, "utf-8").trim());
+      return realpath_or_self(common);
+    }
+    return realpath_or_self(gitdir);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  is_replay_mode,
+  atomic_write_json,
+  atomic_write_text,
+  has_stable_session_id,
+  session_state_file,
+  prune_stale_session_states,
+  prune_legacy_state_file,
+  owns_session_state,
+  update_json_under_lock,
+  git_dir,
+  current_branch,
+  git_common_dir
+};