tamperward 2.31.1 → 2.32.0

package/dist/cli/index.js

@@ -19715,8 +19715,10 @@ var init_record = __esm({
 });
 
 // src/research/run.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { execFileSync as execFileSync13 } from "node:child_process";
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync23, renameSync as renameSync4, rmSync as rmSync11, writeFileSync as writeFileSync11 } from "node:fs";
+import { closeSync as closeSync3, existsSync as existsSync18, linkSync, mkdirSync as mkdirSync9, openSync as openSync3, readFileSync as readFileSync23, renameSync as renameSync4, rmSync as rmSync11, unlinkSync, writeFileSync as writeFileSync11, writeSync } from "node:fs";
+import { hostname } from "node:os";
 import { join as join25, resolve as resolve15 } from "node:path";
 function git6(args, cwd) {
   return execFileSync13("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
@@ -19724,6 +19726,102 @@ function git6(args, cwd) {
 function pairRecordPath(ledger, task, pair) {
   return join25(ledger, "pairs", `${task}--${pair}.json`);
 }
+function researchLockPath(ledger) {
+  return join25(ledger, "run.lock");
+}
+function readLockOwner(path) {
+  try {
+    const parsed = JSON.parse(readFileSync23(path, "utf8"));
+    if (!isRecord(parsed) || typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0) return null;
+    if (typeof parsed.host !== "string" || typeof parsed.started_at !== "string" || typeof parsed.token !== "string") return null;
+    return { pid: parsed.pid, host: parsed.host, started_at: parsed.started_at, token: parsed.token };
+  } catch {
+    return null;
+  }
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code !== "ESRCH";
+  }
+}
+function lockHolder(path) {
+  const owner = readLockOwner(path);
+  return owner ? `pid ${owner.pid} on ${owner.host}, started ${owner.started_at}` : "an unreadable lock file";
+}
+function acquireResearchLock(ledger, breakStaleLock = false) {
+  mkdirSync9(ledger, { recursive: true });
+  const path = researchLockPath(ledger);
+  if (breakStaleLock && existsSync18(path)) {
+    const owner2 = readLockOwner(path);
+    if (!owner2) {
+      throw new ResearchError(`research output ${ledger} has an unreadable lock at ${path}; verify no run is active, then remove it deliberately`);
+    }
+    if (owner2.host !== hostname() || processAlive(owner2.pid)) {
+      throw new ResearchError(
+        `research output ${ledger} is still locked by ${lockHolder(path)}; refusing to break an active lock (a reused pid looks alive: if that owner is certainly gone, remove ${path} deliberately)`
+      );
+    }
+    const claimed = `${path}.stale-${process.pid}-${randomUUID2()}`;
+    let moved = true;
+    try {
+      renameSync4(path, claimed);
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        throw new ResearchError(`research output ${ledger} stale lock recovery failed for ${path}`);
+      }
+      moved = false;
+    }
+    if (moved) {
+      const inspected = readLockOwner(claimed);
+      if (inspected && inspected.token === owner2.token) {
+        unlinkSync(claimed);
+      } else {
+        try {
+          linkSync(claimed, path);
+          unlinkSync(claimed);
+        } catch {
+        }
+        throw new ResearchError(`research output ${ledger}: the lock at ${path} changed while it was being broken; refusing (rerun --break-lock only once no run is active)`);
+      }
+    }
+  }
+  const owner = {
+    pid: process.pid,
+    host: hostname(),
+    started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    token: randomUUID2()
+  };
+  const text = JSON.stringify(owner) + "\n";
+  let fd = -1;
+  try {
+    fd = openSync3(path, "wx", 384);
+    writeSync(fd, text);
+    closeSync3(fd);
+    fd = -1;
+  } catch (e) {
+    if (fd !== -1) closeSync3(fd);
+    if (e.code === "EEXIST") {
+      throw new ResearchError(
+        `research output ${ledger} is already locked by ${lockHolder(path)}; refusing concurrent writers. Verify the owner is not running, then remove ${path} deliberately or rerun with --break-lock`
+      );
+    }
+    throw new ResearchError(`research output ${ledger} cannot create lock ${path}`);
+  }
+  let released = false;
+  return {
+    release() {
+      if (released) return;
+      released = true;
+      try {
+        if (readFileSync23(path, "utf8") === text) unlinkSync(path);
+      } catch {
+      }
+    }
+  };
+}
 function resumableRecord(path, expected) {
   let raw;
   try {
@@ -20012,84 +20110,46 @@ function runResearch(opts) {
     return 2;
   }
   const ledger = resolve15(opts.out);
-  const pairs = opts.pairs ?? 1;
-  mkdirSync9(join25(ledger, "pairs"), { recursive: true });
-  for (const task of tasks) {
-    const existingRecords = /* @__PURE__ */ new Map();
-    let sourceBase = null;
-    try {
-      for (let pair = 1; pair <= pairs; pair++) {
-        const path = pairRecordPath(ledger, task.id, pair);
-        if (!existsSync18(path)) continue;
-        const existing = resumableRecord(path, {
-          task: task.id,
-          pair,
-          manifest_sha256: manifestSha,
-          adapter: { name: adapter.name, layers: adapter.layers },
-          model: opts.model ?? null,
-          tamperward_version: TW_VERSION,
-          agent_argv: agentArgvIdentity,
-          agent_budget: opts.agentBudget ?? null,
-          verify_command: task.verify.command,
-          source_base: sourceBase
-        });
-        sourceBase ??= existing.arms.ungated.base;
-        if (existing.arms.ungated.base !== sourceBase) {
-          throw new ResearchError(
-            `ledger record ${path} belongs to a different source commit (${existing.arms.ungated.base.slice(0, 12)}\u2026 != ${sourceBase.slice(0, 12)}\u2026); use a new --out, or remove it deliberately`
-          );
-        }
-        existingRecords.set(pair, existing);
-      }
-    } catch (e) {
-      if (e instanceof ResearchError) {
-        err2(`tamperward research: ${e.message}`);
-        return 2;
-      }
-      throw e;
+  let lock;
+  try {
+    lock = acquireResearchLock(ledger, opts.breakLock === true);
+  } catch (e) {
+    if (e instanceof ResearchError) {
+      err2(`tamperward research: ${e.message}`);
+      return 2;
     }
-    for (let pair = 1; pair <= pairs; pair++) {
-      const path = pairRecordPath(ledger, task.id, pair);
-      const existing = existingRecords.get(pair);
-      if (existing) {
-        if (!opts.json) out2(`tamperward research \u2014 task ${task.id} pair ${pair}: already recorded (${path}); skipping`);
-        continue;
-      }
-      let record;
+    throw e;
+  }
+  try {
+    const pairs = opts.pairs ?? 1;
+    mkdirSync9(join25(ledger, "pairs"), { recursive: true });
+    for (const task of tasks) {
+      const existingRecords = /* @__PURE__ */ new Map();
+      let sourceBase = null;
       try {
-        const arms = {};
-        for (const arm of RESEARCH_ARMS) {
-          if (!opts.json) out2(`tamperward research \u2014 task ${task.id} pair ${pair}: ${arm} arm`);
-          arms[arm] = runTrajectory(ledger, task, pair, arm, adapter, opts, sourceBase ?? void 0);
-          if (arm === "ungated") {
-            const resolvedSource = arms[arm]?.base;
-            if (!resolvedSource) throw new ResearchError(`task "${task.id}" pair ${pair}: ungated arm produced no source base`);
-            if (sourceBase !== null && resolvedSource !== sourceBase) {
-              throw new ResearchError(
-                `task "${task.id}" pair ${pair}: source base moved (${resolvedSource.slice(0, 12)}\u2026 != ${sourceBase.slice(0, 12)}\u2026)`
-              );
-            }
-            sourceBase ??= resolvedSource;
+        for (let pair = 1; pair <= pairs; pair++) {
+          const path = pairRecordPath(ledger, task.id, pair);
+          if (!existsSync18(path)) continue;
+          const existing = resumableRecord(path, {
+            task: task.id,
+            pair,
+            manifest_sha256: manifestSha,
+            adapter: { name: adapter.name, layers: adapter.layers },
+            model: opts.model ?? null,
+            tamperward_version: TW_VERSION,
+            agent_argv: agentArgvIdentity,
+            agent_budget: opts.agentBudget ?? null,
+            verify_command: task.verify.command,
+            source_base: sourceBase
+          });
+          sourceBase ??= existing.arms.ungated.base;
+          if (existing.arms.ungated.base !== sourceBase) {
+            throw new ResearchError(
+              `ledger record ${path} belongs to a different source commit (${existing.arms.ungated.base.slice(0, 12)}\u2026 != ${sourceBase.slice(0, 12)}\u2026); use a new --out, or remove it deliberately`
+            );
           }
+          existingRecords.set(pair, existing);
         }
-        const ungated = arms.ungated;
-        const gated = arms.gated;
-        if (!ungated || !gated) throw new ResearchError(`task "${task.id}" pair ${pair}: an arm produced no record`);
-        record = {
-          schema_version: MACHINE_SCHEMA_VERSION,
-          command: "research",
-          document: "pair",
-          task: task.id,
-          pair,
-          adapter: { name: adapter.name, layers: [...adapter.layers] },
-          model: opts.model ?? null,
-          tamperward_version: TW_VERSION,
-          agent_argv: [...agentArgvIdentity],
-          agent_budget: opts.agentBudget ?? null,
-          manifest_sha256: manifestSha,
-          verify_command: task.verify.command,
-          arms: { ungated, gated }
-        };
       } catch (e) {
         if (e instanceof ResearchError) {
           err2(`tamperward research: ${e.message}`);
@@ -20097,20 +20157,72 @@ function runResearch(opts) {
         }
         throw e;
       }
-      const text = JSON.stringify(record);
-      writeRecordAtomically(path, text + "\n");
-      if (opts.json) {
-        out2(text);
-      } else {
-        const g = record.arms.gated;
-        const u = record.arms.ungated;
-        out2(
-          `tamperward research \u2014 task ${task.id} pair ${pair}: ungated ${u.outcome.verify_verdict} (masked=${u.outcome.masked_failure}, surviving=${u.outcome.surviving_protected_mutations}); gated ${g.outcome.verify_verdict} (masked=${g.outcome.masked_failure}, surviving=${g.outcome.surviving_protected_mutations}), tamperward ${g.treatment?.verdict ?? "n/a"} \u2192 ${g.treatment?.disposition ?? "n/a"}` + (u.measured && g.measured ? "" : `; UNMEASURABLE (${[u.unmeasurable, g.unmeasurable].filter(Boolean).join(" / ")})`) + `; recorded ${path}`
-        );
+      for (let pair = 1; pair <= pairs; pair++) {
+        const path = pairRecordPath(ledger, task.id, pair);
+        const existing = existingRecords.get(pair);
+        if (existing) {
+          if (!opts.json) out2(`tamperward research \u2014 task ${task.id} pair ${pair}: already recorded (${path}); skipping`);
+          continue;
+        }
+        let record;
+        try {
+          const arms = {};
+          for (const arm of RESEARCH_ARMS) {
+            if (!opts.json) out2(`tamperward research \u2014 task ${task.id} pair ${pair}: ${arm} arm`);
+            arms[arm] = runTrajectory(ledger, task, pair, arm, adapter, opts, sourceBase ?? void 0);
+            if (arm === "ungated") {
+              const resolvedSource = arms[arm]?.base;
+              if (!resolvedSource) throw new ResearchError(`task "${task.id}" pair ${pair}: ungated arm produced no source base`);
+              if (sourceBase !== null && resolvedSource !== sourceBase) {
+                throw new ResearchError(
+                  `task "${task.id}" pair ${pair}: source base moved (${resolvedSource.slice(0, 12)}\u2026 != ${sourceBase.slice(0, 12)}\u2026)`
+                );
+              }
+              sourceBase ??= resolvedSource;
+            }
+          }
+          const ungated = arms.ungated;
+          const gated = arms.gated;
+          if (!ungated || !gated) throw new ResearchError(`task "${task.id}" pair ${pair}: an arm produced no record`);
+          record = {
+            schema_version: MACHINE_SCHEMA_VERSION,
+            command: "research",
+            document: "pair",
+            task: task.id,
+            pair,
+            adapter: { name: adapter.name, layers: [...adapter.layers] },
+            model: opts.model ?? null,
+            tamperward_version: TW_VERSION,
+            agent_argv: [...agentArgvIdentity],
+            agent_budget: opts.agentBudget ?? null,
+            manifest_sha256: manifestSha,
+            verify_command: task.verify.command,
+            arms: { ungated, gated }
+          };
+        } catch (e) {
+          if (e instanceof ResearchError) {
+            err2(`tamperward research: ${e.message}`);
+            return 2;
+          }
+          throw e;
+        }
+        const text = JSON.stringify(record);
+        writeRecordAtomically(path, text + "\n");
+        if (opts.json) {
+          out2(text);
+        } else {
+          const g = record.arms.gated;
+          const u = record.arms.ungated;
+          out2(
+            `tamperward research \u2014 task ${task.id} pair ${pair}: ungated ${u.outcome.verify_verdict} (masked=${u.outcome.masked_failure}, surviving=${u.outcome.surviving_protected_mutations}); gated ${g.outcome.verify_verdict} (masked=${g.outcome.masked_failure}, surviving=${g.outcome.surviving_protected_mutations}), tamperward ${g.treatment?.verdict ?? "n/a"} \u2192 ${g.treatment?.disposition ?? "n/a"}` + (u.measured && g.measured ? "" : `; UNMEASURABLE (${[u.unmeasurable, g.unmeasurable].filter(Boolean).join(" / ")})`) + `; recorded ${path}`
+          );
+        }
       }
     }
+    return 0;
+  } finally {
+    lock.release();
   }
-  return 0;
 }
 var err2, out2;
 var init_run2 = __esm({
@@ -20296,6 +20408,7 @@ function parseResearchRun(args) {
     else if (a === "--pairs") o.pairs = Number(args[++i]);
     else if (a === "--model") o.model = args[++i];
     else if (a === "--agent-budget") o.agentBudget = Number(args[++i]);
+    else if (a === "--break-lock") o.breakLock = true;
     else if (a === "--json") o.json = true;
   }
   return o;
@@ -20608,7 +20721,7 @@ function validateCliArgs(cmd, args) {
       const delimiter3 = rest.indexOf("--");
       const prefix = delimiter3 < 0 ? rest : rest.slice(0, delimiter3);
       const parsed = validateFlatArgs(prefix, {
-        flags: ["--json"],
+        flags: ["--break-lock", "--json"],
         values: {
           "--manifest": "string",
           "--out": "string",
@@ -20707,9 +20820,11 @@ Formats:
   tamperward research run --manifest F      bring-your-own-model evaluation: for every
              --out D --adapter A [--pairs N]  task in the manifest, pin one source commit,
              [--model M] [--agent-budget S]   clone fresh state per arm, run the agent
-             [--json] [-- <agent cmd...>]     ungated and under the run envelope, then
-                                             observe both with verify + check. Records
+             [--break-lock] [--json]         ungated and under the run envelope, then
+             [-- <agent cmd...>]             observe both with verify + check. Records
                                              are resumable by full experiment identity.
+                                             --break-lock recovers a verified stale
+                                             output lock (see the research guide).
   tamperward research summarize --ledger D  aggregate measured pairs into model behaviour,
                                              independent outcome, TamperWard hits/misses
                                              and paired counts \u2014 no composite score

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.31.1",
+  "version": "2.32.0",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",