@mmerterden/multi-agent-pipeline 12.6.0 → 12.8.0

package/pipeline/scripts/validate-diff-risk.mjs

@@ -49,22 +49,27 @@ function validate(obj) {
   if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
     return ["root must be an object"];
   }
-  if (obj.schemaVersion !== "1.1.0") errors.push(`schemaVersion must be "1.1.0", got ${JSON.stringify(obj.schemaVersion)}`);
+  if (obj.schemaVersion !== "1.1.0")
+    errors.push(`schemaVersion must be "1.1.0", got ${JSON.stringify(obj.schemaVersion)}`);
 
   if (typeof obj.task !== "object" || obj.task === null) {
     errors.push("task must be an object");
   } else {
-    if (typeof obj.task.base !== "string" || !obj.task.base.length) errors.push("task.base must be a non-empty string");
-    if (typeof obj.task.head !== "string" || !obj.task.head.length) errors.push("task.head must be a non-empty string");
+    if (typeof obj.task.base !== "string" || !obj.task.base.length)
+      errors.push("task.base must be a non-empty string");
+    if (typeof obj.task.head !== "string" || !obj.task.head.length)
+      errors.push("task.head must be a non-empty string");
   }
 
   if (typeof obj.totals !== "object" || obj.totals === null) {
     errors.push("totals must be an object");
   } else {
     for (const k of ["files", "loc_added", "loc_removed"]) {
-      if (!Number.isInteger(obj.totals[k]) || obj.totals[k] < 0) errors.push(`totals.${k} must be a non-negative integer`);
+      if (!Number.isInteger(obj.totals[k]) || obj.totals[k] < 0)
+        errors.push(`totals.${k} must be a non-negative integer`);
     }
-    if (typeof obj.totals.max_score !== "number" || obj.totals.max_score < 0) errors.push("totals.max_score must be a non-negative number");
+    if (typeof obj.totals.max_score !== "number" || obj.totals.max_score < 0)
+      errors.push("totals.max_score must be a non-negative number");
   }
 
   if (!Array.isArray(obj.files)) {
@@ -73,25 +78,33 @@ function validate(obj) {
     obj.files.forEach((row, i) => {
       const p = `files[${i}]`;
       if (typeof row !== "object" || row === null) {
-        errors.push(`${p} must be an object`); return;
+        errors.push(`${p} must be an object`);
+        return;
       }
-      if (typeof row.path !== "string" || !row.path.length) errors.push(`${p}.path must be a non-empty string`);
-      if (typeof row.score !== "number" || row.score < 0) errors.push(`${p}.score must be a non-negative number`);
+      if (typeof row.path !== "string" || !row.path.length)
+        errors.push(`${p}.path must be a non-empty string`);
+      if (typeof row.score !== "number" || row.score < 0)
+        errors.push(`${p}.score must be a non-negative number`);
       for (const k of ["loc_added", "loc_removed"]) {
-        if (!Number.isInteger(row[k]) || row[k] < 0) errors.push(`${p}.${k} must be a non-negative integer`);
+        if (!Number.isInteger(row[k]) || row[k] < 0)
+          errors.push(`${p}.${k} must be a non-negative integer`);
       }
       if (!Array.isArray(row.signals)) errors.push(`${p}.signals must be an array`);
-      else row.signals.forEach((s, j) => {
-        const sp = `${p}.signals[${j}]`;
-        if (!ALLOWED_SIGNALS.has(s.name)) errors.push(`${sp}.name "${s.name}" not in allowed set`);
-        if (typeof s.weight !== "number") errors.push(`${sp}.weight must be a number`);
-        if (typeof s.value !== "number") errors.push(`${sp}.value must be a number`);
-      });
+      else
+        row.signals.forEach((s, j) => {
+          const sp = `${p}.signals[${j}]`;
+          if (!ALLOWED_SIGNALS.has(s.name))
+            errors.push(`${sp}.name "${s.name}" not in allowed set`);
+          if (typeof s.weight !== "number") errors.push(`${sp}.weight must be a number`);
+          if (typeof s.value !== "number") errors.push(`${sp}.value must be a number`);
+        });
     });
     // Sort invariant
     for (let i = 1; i < obj.files.length; i++) {
       if (obj.files[i].score > obj.files[i - 1].score) {
-        errors.push(`files[] must be sorted by score descending (row ${i} score ${obj.files[i].score} > row ${i - 1} score ${obj.files[i - 1].score})`);
+        errors.push(
+          `files[] must be sorted by score descending (row ${i} score ${obj.files[i].score} > row ${i - 1} score ${obj.files[i - 1].score})`,
+        );
         break;
       }
     }
@@ -103,8 +116,9 @@ function validate(obj) {
 (async () => {
   const raw = await readInput();
   let obj;
-  try { obj = JSON.parse(raw); }
-  catch (e) {
+  try {
+    obj = JSON.parse(raw);
+  } catch (e) {
     console.log(JSON.stringify({ ok: false, errors: [`JSON parse error: ${e.message}`] }));
     process.exit(1);
   }

package/pipeline/scripts/validate-test-gap.mjs

@@ -34,15 +34,18 @@ function readInput() {
 
 function validate(obj) {
   const errors = [];
-  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return ["root must be an object"];
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj))
+    return ["root must be an object"];
   if (obj.schemaVersion !== "1.0.0") errors.push(`schemaVersion must be "1.0.0"`);
-  if (!ALLOWED_STACK.has(obj.stack)) errors.push(`stack must be one of ${Array.from(ALLOWED_STACK).join(",")}`);
+  if (!ALLOWED_STACK.has(obj.stack))
+    errors.push(`stack must be one of ${Array.from(ALLOWED_STACK).join(",")}`);
 
   if (typeof obj.totals !== "object" || obj.totals === null) {
     errors.push("totals must be an object");
   } else {
     for (const k of ["sourcesScanned", "testsScanned", "gapCount"]) {
-      if (!Number.isInteger(obj.totals[k]) || obj.totals[k] < 0) errors.push(`totals.${k} must be a non-negative integer`);
+      if (!Number.isInteger(obj.totals[k]) || obj.totals[k] < 0)
+        errors.push(`totals.${k} must be a non-negative integer`);
     }
     if (typeof obj.totals.gapBySeverity !== "object" || obj.totals.gapBySeverity === null) {
       errors.push("totals.gapBySeverity must be an object");
@@ -60,12 +63,17 @@ function validate(obj) {
   } else {
     obj.gaps.forEach((g, i) => {
       const p = `gaps[${i}]`;
-      if (typeof g !== "object" || g === null) { errors.push(`${p} must be object`); return; }
-      if (typeof g.sourcePath !== "string" || !g.sourcePath.length) errors.push(`${p}.sourcePath required`);
+      if (typeof g !== "object" || g === null) {
+        errors.push(`${p} must be object`);
+        return;
+      }
+      if (typeof g.sourcePath !== "string" || !g.sourcePath.length)
+        errors.push(`${p}.sourcePath required`);
       if (typeof g.symbol !== "string" || !g.symbol.length) errors.push(`${p}.symbol required`);
       if (typeof g.kind !== "string" || !g.kind.length) errors.push(`${p}.kind required`);
       if (!ALLOWED_SEVERITY.has(g.severity)) errors.push(`${p}.severity invalid: ${g.severity}`);
-      if (!Array.isArray(g.expectedTestPaths) || g.expectedTestPaths.length === 0) errors.push(`${p}.expectedTestPaths must be a non-empty array`);
+      if (!Array.isArray(g.expectedTestPaths) || g.expectedTestPaths.length === 0)
+        errors.push(`${p}.expectedTestPaths must be a non-empty array`);
       if (typeof g.hint !== "string") errors.push(`${p}.hint must be a string`);
     });
   }
@@ -76,7 +84,9 @@ function validate(obj) {
 (async () => {
   const raw = await readInput();
   let obj;
-  try { obj = JSON.parse(raw); } catch (e) {
+  try {
+    obj = JSON.parse(raw);
+  } catch (e) {
     console.log(JSON.stringify({ ok: false, errors: [`JSON parse error: ${e.message}`] }));
     process.exit(1);
   }

package/pipeline/scripts/validate-triage.mjs

@@ -25,7 +25,12 @@ import { readFileSync } from "node:fs";
 
 const ALLOWED_REVIEWERS = new Set(["fable", "opus", "sonnet", "gpt"]);
 const ALLOWED_SEVERITIES = new Set(["blocking", "important", "suggestion"]);
-const ALLOWED_CONSENSUS_VERDICTS = new Set(["unanimous-pass", "unanimous-block", "split", "unverified"]);
+const ALLOWED_CONSENSUS_VERDICTS = new Set([
+  "unanimous-pass",
+  "unanimous-block",
+  "split",
+  "unverified",
+]);
 const ALLOWED_VERIFICATION_RESULTS = new Set(["confirmed", "not-reproduced", "inconclusive"]);
 const OVER_REJECT_THRESHOLD = 0.8;
 const OVER_REJECT_MIN_FINDINGS = 5;
@@ -79,7 +84,9 @@ function validateVerification(v, label, errors) {
     return;
   }
   if (!ALLOWED_VERIFICATION_RESULTS.has(v.result)) {
-    errors.push(`${label}: bad result "${v.result}" (allowed: confirmed|not-reproduced|inconclusive)`);
+    errors.push(
+      `${label}: bad result "${v.result}" (allowed: confirmed|not-reproduced|inconclusive)`,
+    );
     return;
   }
   if (v.result === "confirmed" || v.result === "not-reproduced") {
@@ -115,10 +122,14 @@ function validateConsensus(c, errors) {
     return;
   }
   if (!Number.isInteger(c.reviewerCount) || c.reviewerCount < 1) {
-    errors.push(`consensus: reviewerCount must be an integer >= 1 (got ${JSON.stringify(c.reviewerCount)})`);
+    errors.push(
+      `consensus: reviewerCount must be an integer >= 1 (got ${JSON.stringify(c.reviewerCount)})`,
+    );
   }
   if (!ALLOWED_CONSENSUS_VERDICTS.has(c.verdict)) {
-    errors.push(`consensus: bad verdict "${c.verdict}" (allowed: unanimous-pass|unanimous-block|split|unverified)`);
+    errors.push(
+      `consensus: bad verdict "${c.verdict}" (allowed: unanimous-pass|unanimous-block|split|unverified)`,
+    );
   }
   if (c.disagreements !== undefined) {
     if (!Array.isArray(c.disagreements)) {
@@ -211,7 +222,8 @@ function validate(raw) {
         errors.push('consensus.verdict "unanimous-pass" contradicts an accepted blocking finding');
       }
       if (
-        typeof c.reviewerCount === "number" && c.reviewerCount < 2 &&
+        typeof c.reviewerCount === "number" &&
+        c.reviewerCount < 2 &&
         (c.verdict === "unanimous-pass" || c.verdict === "unanimous-block")
       ) {
         errors.push(

package/pipeline/scripts/write-state.mjs

@@ -5,7 +5,7 @@
  * Why this exists:
  *   Multiple worktrees can run the pipeline concurrently against the same
  *   task id. Two CLI instances writing agent-state.json in the usual
- *   fs.writeFileSync('path', JSON.stringify(...)) pattern is racy  - 
+ *   fs.writeFileSync('path', JSON.stringify(...)) pattern is racy  -
  *   second write wipes the first. This helper uses tmpfile + rename, which
  *   is atomic on POSIX, combined with an advisory .lock file for the tiny
  *   window between "read current state" and "write new state".
@@ -35,8 +35,7 @@ import {
   renameSync,
   existsSync,
   unlinkSync,
-  openSync,
-  closeSync,
+  linkSync,
   statSync,
 } from "fs";
 import { dirname, basename } from "path";
@@ -70,17 +69,36 @@ function parseArgs() {
  * @param {number} timeoutMs
  * @returns {Promise<void>}
  */
-async function acquireLock(path, timeoutMs = Number(process.env.WRITE_STATE_LOCK_TIMEOUT_MS) || 15_000) {
+async function acquireLock(
+  path,
+  timeoutMs = Number(process.env.WRITE_STATE_LOCK_TIMEOUT_MS) || 15_000,
+) {
   const lockPath = `${path}.lock`;
   const staleMs = Number(process.env.WRITE_STATE_LOCK_STALE_MS) || 30_000;
   const deadline = Date.now() + timeoutMs;
+  // The lock file must never be observable without its owning PID inside it.
+  // It used to be created with openSync(wx) and filled on the next line, so
+  // between those two calls it existed and was empty. A writer arriving in
+  // that window read an unparseable PID, concluded the lock was stale, and
+  // deleted a live one - after which two writers held it and one write was
+  // lost. Under CPU load that reproduced 3 times in 15 runs.
+  //
+  // Writing the PID into a private temp file and hard-linking it into place
+  // closes the window: link() fails with EEXIST if the lock is held, and the
+  // instant the lock exists it already has its contents.
+  const stagePath = `${lockPath}.${process.pid}.stage`;
   while (Date.now() < deadline) {
     try {
-      const fd = openSync(lockPath, "wx"); // O_EXCL  -  fails if exists
-      writeFileSync(fd, String(process.pid));
-      closeSync(fd);
+      writeFileSync(stagePath, String(process.pid));
+      linkSync(stagePath, lockPath); // fails EEXIST if another writer holds it
+      unlinkSync(stagePath);
       return;
     } catch (err) {
+      try {
+        unlinkSync(stagePath);
+      } catch {
+        /* already gone */
+      }
       if (err.code !== "EEXIST") throw err;
       if (isLockStale(lockPath, staleMs)) {
         // Holder crashed or the lock outlived any plausible writer  -  reclaim it.
@@ -105,7 +123,7 @@ async function acquireLock(path, timeoutMs = Number(process.env.WRITE_STATE_LOCK
 
 /**
  * A lock is stale when its owning PID is no longer alive, or when the lock
- * file is older than `staleMs` (covers PID reuse and unreadable PIDs).
+ * file is older than `staleMs` (which also covers PID reuse).
  * @param {string} lockPath
  * @param {number} staleMs
  * @returns {boolean}
@@ -121,7 +139,12 @@ function isLockStale(lockPath, staleMs) {
     return false;
   }
   if (Date.now() - mtimeMs > staleMs) return true;
-  if (!Number.isInteger(pid) || pid <= 0) return true;
+  // An unreadable PID is NOT proof of staleness. Treating it as such is what
+  // let a writer delete a live lock and lose another writer's update. With the
+  // link-based acquire above a lock is never observable without its PID, so
+  // this can only be genuine corruption - which the staleMs check reclaims
+  // anyway, without racing a writer that is merely mid-flight.
+  if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0); // probe liveness without signalling
     return false; // holder alive