@mmerterden/multi-agent-pipeline 20.34.0 → 20.36.0

package/pipeline/scripts/anonymize-findings.mjs

@@ -32,6 +32,12 @@
 //
 // Usage:
 //   anonymize-findings.mjs [--file <reviewers.json>] [--map <out.json>] [--seed <text>]
+//   anonymize-findings.mjs --restore --map <map.json> --in-place <triage.json>
+//
+// --restore runs after the triage verdict is validated: triage carries each
+// finding's `foundBy` label through and never sees which model it stands for,
+// and this writes the reviewer family back from the map for the per-reviewer
+// telemetry that reads `reviewer`.
 //
 // Exit codes: 0 ok, 64 usage, 65 input is not JSON.
 
@@ -161,7 +167,100 @@ export function anonymize(input, { seed } = {}) {
   return { findings: tagged, map: { seed: seedText, labelToModel, malformed } };
 }
 
+const FAMILIES = ["fable", "opus", "sonnet", "gpt"];
+
+/** The reviewer family a map entry names, or null for a model outside the four. */
+export function familyOf(model) {
+  const m = String(model ?? "").toLowerCase();
+  return FAMILIES.find((f) => m.includes(f)) ?? null;
+}
+
+/**
+ * The triage document with `reviewer` set on every finding whose `foundBy`
+ * label the map knows. Findings with no label (deterministic gate findings)
+ * or a label the map does not name are left as they are.
+ */
+export function restore(triage, map) {
+  const labels = map && typeof map.labelToModel === "object" ? map.labelToModel : {};
+  const fill = (f) => {
+    if (!f || typeof f !== "object" || typeof f.foundBy !== "string") return f;
+    if (!Object.hasOwn(labels, f.foundBy)) return f;
+    const family = familyOf(labels[f.foundBy]);
+    return family ? { ...f, reviewer: family } : f;
+  };
+  const out = { ...triage };
+  if (Array.isArray(out.accepted)) out.accepted = out.accepted.map(fill);
+  for (const key of ["deferred", "rejected"]) {
+    if (Array.isArray(out[key]))
+      out[key] = out[key].map((e) =>
+        e && typeof e === "object" ? { ...e, finding: fill(e.finding) } : e,
+      );
+  }
+  return out;
+}
+
+/**
+ * The label map: the --map file when it reads, else the newest
+ * reviewIterations[].anonymizationMap in the run state, which outlives /tmp.
+ */
+export function loadMap(mapPath, statePath) {
+  const read = (p) => {
+    try {
+      return p ? JSON.parse(readFileSync(p, "utf8")) : null;
+    } catch {
+      return null;
+    }
+  };
+  const fromFile = read(mapPath);
+  if (fromFile && typeof fromFile.labelToModel === "object") return fromFile;
+  const state = read(statePath);
+  const its = Array.isArray(state?.reviewIterations) ? state.reviewIterations : [];
+  for (let i = its.length - 1; i >= 0; i--) {
+    const m = its[i]?.anonymizationMap;
+    if (m && typeof m.labelToModel === "object") return m;
+  }
+  return null;
+}
+
 const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain && process.argv.includes("--restore")) {
+  const args = process.argv.slice(2);
+  const at = (name) => {
+    const i = args.indexOf(name);
+    return i === -1 ? undefined : args[i + 1];
+  };
+  const mapPath = at("--map");
+  const statePath = at("--state");
+  const target = at("--in-place");
+  const usage =
+    "usage: anonymize-findings.mjs --restore [--map <map.json>] [--state <state.json>] --in-place <triage.json>\n";
+  if (
+    !target ||
+    (!mapPath && !statePath) ||
+    args.length !== 3 + 2 * [mapPath, statePath].filter(Boolean).length
+  ) {
+    process.stderr.write(usage);
+    process.exit(64);
+  }
+  let triage;
+  try {
+    triage = JSON.parse(readFileSync(target, "utf8"));
+  } catch (e) {
+    process.stderr.write(`input is not JSON: ${e.message}\n`);
+    process.exit(65);
+  }
+  const map = loadMap(mapPath, statePath);
+  if (!map) {
+    // The verdict stands without the families; only per-reviewer telemetry
+    // loses them, so the triage chain is not stopped over it.
+    process.stderr.write(
+      "warning: no label map (neither --map nor the run state's anonymizationMap); reviewer families not restored\n",
+    );
+    process.exit(0);
+  }
+  writeFileSync(target, `${JSON.stringify(restore(triage, map), null, 2)}\n`);
+  process.exit(0);
+}
 if (isMain) {
   const args = process.argv.slice(2);
   const flag = (name) => {

package/pipeline/scripts/answer-check.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/**
+ * @file answer-check.mjs  -  PostToolUse hook (AskUserQuestion): an empty
+ * answer is not consent.
+ *
+ * rules.md ("Interaction") says a question submitted without a choice must be
+ * asked again or treated as unselected, never resolved to the option marked
+ * Recommended. The host returns such a submission as a normal tool result, so
+ * the rule depends on the model noticing. This hook names the unanswered
+ * questions back to the model as additionalContext whenever it happens.
+ *
+ * Where the answers come from: the structured result's `answers` map keyed by
+ * question text; when only the text form is present, the `"question"="answer"`
+ * pairs in it. A result it cannot read either way is left alone.
+ *
+ * Applies in every session, run or not: it only adds context. Exits 0 on every
+ * path and blocks nothing.
+ */
+
+import { readFileSync } from "node:fs";
+
+import { invokedDirectly } from "../lib/invoked-directly.mjs";
+
+const MAX_INPUT = 256 * 1024;
+const MAX_LABEL = 60;
+
+const label = (q, i) => {
+  const raw = String(q?.header || q?.question || `question ${i + 1}`)
+    .replace(/\s+/g, " ")
+    .trim();
+  return raw.length > MAX_LABEL ? `${raw.slice(0, MAX_LABEL - 3)}...` : raw;
+};
+
+/** The question text -> answer map from a structured or text result, or null. */
+export function answersOf(response) {
+  if (response && typeof response === "object" && !Array.isArray(response)) {
+    const a = response.answers;
+    if (a && typeof a === "object" && !Array.isArray(a)) return a;
+  }
+  const text =
+    typeof response === "string"
+      ? response
+      : Array.isArray(response)
+        ? response.map((b) => (typeof b === "string" ? b : (b?.text ?? ""))).join("\n")
+        : null;
+  if (!text || !/answered/i.test(text)) return null;
+  const out = {};
+  for (const m of text.matchAll(/"((?:[^"\\]|\\.)*)"="((?:[^"\\]|\\.)*)"/g)) out[m[1]] = m[2];
+  return out;
+}
+
+/** Labels of the questions with no answer, or null when the result is unreadable. */
+export function unanswered(payload) {
+  if (payload?.tool_name !== "AskUserQuestion") return null;
+  const questions = Array.isArray(payload.tool_input?.questions)
+    ? payload.tool_input.questions
+    : [];
+  if (!questions.length) return null;
+  const answers = answersOf(payload.tool_response);
+  if (!answers) return null;
+  const keys = Object.keys(answers);
+  return questions
+    .map((q, i) => {
+      const text = String(q?.question ?? "");
+      const hit = Object.hasOwn(answers, text)
+        ? answers[text]
+        : keys.length === 1 && questions.length === 1
+          ? answers[keys[0]]
+          : undefined;
+      const value = Array.isArray(hit) ? hit.join("") : hit;
+      return typeof value === "string" && value.trim() ? null : label(q, i);
+    })
+    .filter(Boolean);
+}
+
+/** The hook output for one payload, or null when every question was answered. */
+export function answer(payload) {
+  const missing = unanswered(payload);
+  if (!missing || !missing.length) return null;
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      additionalContext:
+        `The user submitted AskUserQuestion without choosing for: ${missing.map((m) => `"${m}"`).join(", ")}. ` +
+        "An empty answer is not consent: do not apply the option marked Recommended. " +
+        "Ask that question again, or treat the item as unselected and say so.",
+    },
+  };
+}
+
+function main() {
+  let raw;
+  try {
+    raw = readFileSync(0, "utf8");
+  } catch {
+    return;
+  }
+  if (!raw || raw.length > MAX_INPUT) return;
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const out = answer(payload);
+  if (out) process.stdout.write(JSON.stringify(out) + "\n");
+}
+
+try {
+  if (invokedDirectly(import.meta.url)) main();
+} catch {
+  /* silent by contract */
+}

package/pipeline/scripts/answer-check.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# answer-check.sh  -  PostToolUse hook (AskUserQuestion) for the pipeline.
+#
+# Tells the model which questions came back with no choice, so an empty answer
+# is asked again instead of resolved to the Recommended option. The logic is in
+# answer-check.mjs; this wrapper exists because every hook the pipeline
+# registers is a `bash "$HOME/.<host>/scripts/<name>"` command.
+#
+# Exits 0 on every path: a missing node or any internal error means no
+# context, never a blocked tool call.
+
+set -u
+
+HERE="$(cd "$(dirname "$0")" 2>/dev/null && pwd || true)"
+CORE="$HERE/answer-check.mjs"
+[ -f "$CORE" ] || exit 0
+command -v node >/dev/null 2>&1 || exit 0
+
+node "$CORE" 2>/dev/null || true
+exit 0

package/pipeline/scripts/autopilot-publish.mjs

@@ -1509,7 +1509,9 @@ function scriptRunner(results, env) {
  *     publish rights, which an unattended run does not get, so they are
  *     reported as skipped.
  *   reportIssueUpdates: update-issue-progress.sh for a GitHub issue the run
- *     recorded, and a PR-link Jira comment when no channel comment went out.
+ *     recorded, with a PR-link comment it posts before the Progress flags
+ *     (comment and flags go together), and a PR-link Jira comment when no
+ *     channel comment went out.
  *
  * Every text passes the outbound gate here before a script sees it, and every
  * script runs with MULTI_AGENT_UNATTENDED unset (each script's own gate runs
@@ -1569,7 +1571,12 @@ export function reportAfterPublish({
   }
   if (config?.reportIssueUpdates === true) {
     if (state?.githubIssue?.number && state?.taskId) {
-      runScript("issue-progress", progressScript, [String(state.taskId)]);
+      runScript(
+        "issue-progress",
+        progressScript,
+        [String(state.taskId)],
+        `Draft PR opened: ${prUrl}\n`,
+      );
     }
     if (jiraKey && !jiraPosted) {
       runScript("jira-pr-link", jiraScript, ["--issue", jiraKey], `Draft PR opened: ${prUrl}\n`);

package/pipeline/scripts/contract-server.mjs

@@ -305,7 +305,7 @@ import { runMain } from "../lib/fatal.mjs";
 import { invokedDirectly } from "../lib/invoked-directly.mjs";
 
 /** The contract as a whole; pipeline/contract/manifest.json carries the same. */
-export const CONTRACT_VERSION = "1.6.0";
+export const CONTRACT_VERSION = "1.7.0";
 /** The majors `?v=` accepts. A new major keeps the previous one here for one minor. */
 export const SUPPORTED_MAJORS = [1];
 export const BIND_HOST = "127.0.0.1";
@@ -1528,6 +1528,33 @@ function evidenceRoute({ params }) {
   }
 }
 
+/**
+ * GET /v1/prs/reach: work-items.mjs reach as a child process, because loading
+ * a repository's graph is a synchronous parse of a file that can run to tens
+ * of megabytes, and no other route may wait behind it.
+ */
+async function prReachRoute() {
+  const r = await spawnAsync(process.execPath, [join(HERE, "work-items.mjs"), "reach"], {
+    env: process.env,
+    timeoutMs: 180_000,
+    maxBytes: 2 * 1024 * 1024,
+  });
+  let doc;
+  try {
+    doc = JSON.parse(r.stdout);
+  } catch {
+    doc = null;
+  }
+  if (r.status !== 0 || !doc || !Array.isArray(doc.items)) {
+    throw new HttpError(
+      502,
+      "upstream-failed",
+      "the reach of the pull requests could not be measured",
+    );
+  }
+  return doc;
+}
+
 function workError(err) {
   if (!(err instanceof WorkError)) return err;
   if (err.code === "no-run" || err.code === "bad-key")
@@ -1899,6 +1926,13 @@ export const ROUTES = [
       ({ redact }) => pullRequests({ redact }),
     ),
   },
+  {
+    method: "GET",
+    path: "/v1/prs/reach",
+    query: [],
+    remote: "local-only",
+    handle: shared(() => "prs-reach", prReachRoute),
+  },
   { method: "GET", path: "/v1/tools", query: [], handle: toolsRoute },
   {
     method: "POST",

package/pipeline/scripts/gate-ledger.mjs

@@ -54,14 +54,18 @@
 
 import { spawnSync } from "node:child_process";
 import {
+  copyFileSync,
   existsSync,
+  mkdtempSync,
   readFileSync,
   realpathSync,
   renameSync,
+  rmSync,
   statSync,
   writeFileSync,
 } from "node:fs";
-import { basename, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
 
 import { decisionEntry, withDecision } from "../lib/decisions.mjs";
 import { invokedDirectly } from "../lib/invoked-directly.mjs";
@@ -103,31 +107,77 @@ export const ATTENDED_RECORDED = new Set([
   "plan-coverage",
   "evidence-gate/build",
   "evidence-gate/test",
+  "review-decision",
 ]);
 
 /** What an attended commit is checked for (pre-commit-check.sh, `evidence`). */
+/**
+ * Fix loops with a hard cap (rules.md: three attempts, the fourth failure
+ * pauses): consecutive failing verdicts of one of these gates count, and the
+ * append that reaches RETRY_CAP pauses the run with a halt reason.
+ */
+export const RETRY_CAPPED = new Set(["evidence-gate/build", "evidence-gate/test"]);
+export const RETRY_CAP = 4;
+
+/** Consecutive failing verdicts at the end of `gates` for one gate. */
+export function trailingFailures(gates, gate) {
+  let n = 0;
+  for (let i = gates.length - 1; i >= 0; i--) {
+    const e = gates[i];
+    if (!e || e.gate !== gate) continue;
+    if (e.verdict !== "fail") break;
+    n += 1;
+  }
+  return n;
+}
+
 export const ATTENDED_COMMIT_EVIDENCE = ["evidence-gate/build", "evidence-gate/test"];
 
-/** prefs.global.attendedCommitGate.mode values; `warn` is the default. */
-export const ATTENDED_COMMIT_MODES = ["off", "warn", "block"];
+/** Asked for too once the run is in its commit phase: the review verdict. */
+export const ATTENDED_REVIEW_EVIDENCE = "review-decision";
+export const ATTENDED_REVIEW_FROM_PHASE = 4;
 
 /**
- * The build/test evidence an attended commit on `sha` lacks: every gate in
- * ATTENDED_COMMIT_EVIDENCE whose latest entry for that sha, attended or not,
- * is missing or not passing.
+ * prefs.global.attendedCommitGate.mode values. `auto`, the default, blocks
+ * the commit when the run is bound to the committing session (the session
+ * driving it) and warns otherwise.
+ */
+export const ATTENDED_COMMIT_MODES = ["off", "warn", "block", "auto"];
+
+/**
+ * The evidence an attended commit on `sha` lacks: every gate in
+ * ATTENDED_COMMIT_EVIDENCE, plus the review verdict from the commit phase on,
+ * whose latest entry for that sha, attended or not, is missing or not passing.
+ * A checkpoint commit during development comes before any review and is held
+ * to build and test only.
  *
  * @param {object} state
  * @param {string} sha
  * @returns {string[]}
  */
-export function attendedEvidenceGaps(state, sha) {
-  const latest = latestByGate(state?.gates, sha);
-  return ATTENDED_COMMIT_EVIDENCE.filter((g) => {
+export function attendedEvidenceGaps(state, sha, { sameTree } = {}) {
+  const wanted = [...ATTENDED_COMMIT_EVIDENCE];
+  if (Number(state?.currentPhase) >= ATTENDED_REVIEW_FROM_PHASE)
+    wanted.push(ATTENDED_REVIEW_EVIDENCE);
+  const asked = (Array.isArray(state?.gates) ? state.gates : []).filter((e) =>
+    wanted.includes(e?.gate),
+  );
+  const latest = sameTree
+    ? latestByGateWhere(asked, (s) => s === sha || sameTree(s))
+    : latestByGate(asked, sha);
+  return wanted.filter((g) => {
     const e = latest.get(g);
     return !e || !PASSING.has(e.verdict);
   });
 }
 
+/** The mode that applies: an explicit off/warn/block, else block for a bound run. */
+export function effectiveCommitMode(pref, bound) {
+  const mode = ATTENDED_COMMIT_MODES.includes(pref) ? pref : "auto";
+  if (mode !== "auto") return mode;
+  return bound ? "block" : "warn";
+}
+
 const QUESTION_ID = /^[a-z][a-z0-9-]*$/;
 const OPTION_ID = /^[a-z0-9][a-z0-9+_-]*$/;
 const QUESTION_KEYS = ["id", "stepId", "text", "kind", "options"];
@@ -184,6 +234,54 @@ export class LedgerError extends Error {
  * HEAD of the repository at `dir`, or null outside one.
  * @param {string} dir
  */
+/**
+ * A predicate: does a recorded sha hold the content this commit records?
+ * Yes when its tree is the index's, or the tree `git add -A` would stage from
+ * the working tree (built in a throwaway copy of the index, so the real index
+ * is untouched). The hook runs before a `git add ... && git commit` line
+ * stages anything, and Phase 4's `git reset HEAD~1` leaves a checkpoint
+ * commit's new files untracked; both still match the evidence they were
+ * tested with, while a file added after the evidence does not. Each sha is
+ * asked once; anything git cannot answer is "no".
+ */
+export function sameTreeAs(dir) {
+  const run = (args, env) => {
+    const r = spawnSync("git", ["-C", dir, ...args], {
+      encoding: "utf8",
+      timeout: 20000,
+      env: env ? { ...process.env, ...env } : process.env,
+    });
+    return r.status === 0 ? r.stdout.trim() : null;
+  };
+  const indexTree = run(["write-tree"]);
+  let workTree = null;
+  const indexPath = run(["rev-parse", "--path-format=absolute", "--git-path", "index"]);
+  if (indexPath) {
+    const scratch = mkdtempSync(join(tmpdir(), "ma-tree-"));
+    const copy = join(scratch, "index");
+    try {
+      if (existsSync(indexPath)) copyFileSync(indexPath, copy);
+      if (run(["add", "-A"], { GIT_INDEX_FILE: copy }) !== null) {
+        workTree = run(["write-tree"], { GIT_INDEX_FILE: copy });
+      }
+    } catch {
+      workTree = null;
+    } finally {
+      rmSync(scratch, { recursive: true, force: true });
+    }
+  }
+  const targets = new Set([indexTree, workTree].filter(Boolean));
+  const seen = new Map();
+  return (sha) => {
+    if (!targets.size || typeof sha !== "string" || !/^[0-9a-f]{7,64}$/.test(sha)) return false;
+    if (!seen.has(sha)) {
+      const tree = run(["rev-parse", "--verify", "--quiet", `${sha}^{tree}`]);
+      seen.set(sha, Boolean(tree) && targets.has(tree));
+    }
+    return seen.get(sha);
+  };
+}
+
 export function headSha(dir) {
   const r = spawnSync("git", ["-C", dir, "rev-parse", "HEAD"], {
     encoding: "utf8",
@@ -399,11 +497,22 @@ export async function record(
     detail: detail && typeof detail === "object" ? detail : { value: detail },
     ...(attended ? { attended: true } : {}),
   };
-  await updateState(path, (s) => ({
-    ...s,
-    gates: [...(Array.isArray(s.gates) ? s.gates : []), entry],
-  }));
-  return { written: true, statePath: path, entry };
+  let capped = false;
+  await updateState(path, (s) => {
+    const gates = [...(Array.isArray(s.gates) ? s.gates : []), entry];
+    const next = { ...s, gates };
+    if (
+      RETRY_CAPPED.has(gate) &&
+      verdict === "fail" &&
+      trailingFailures(gates, gate) >= RETRY_CAP
+    ) {
+      capped = true;
+      next.status = "paused";
+      next.haltReason = `${phaseOf(s)}:retry-cap: ${gate} failed ${RETRY_CAP} times in a row; the fix loop stops here for the user`;
+    }
+    return next;
+  });
+  return { written: true, statePath: path, entry, capped };
 }
 
 /**
@@ -494,9 +603,14 @@ function phaseOf(state) {
  * Latest entry per gate for one sha. "Latest" is by `at`, then by position.
  */
 export function latestByGate(gates, sha) {
+  return latestByGateWhere(gates, (s) => s === sha);
+}
+
+/** latestByGate over the entries whose sha `accept` takes. */
+export function latestByGateWhere(gates, accept) {
   const out = new Map();
   (Array.isArray(gates) ? gates : []).forEach((e, i) => {
-    if (!e || typeof e !== "object" || e.sha !== sha || typeof e.gate !== "string") return;
+    if (!e || typeof e !== "object" || typeof e.gate !== "string" || !accept(e.sha)) return;
     const prev = out.get(e.gate);
     const t = Date.parse(e.at) || 0;
     if (!prev || t > prev.t || (t === prev.t && i > prev.i)) out.set(e.gate, { e, t, i });
@@ -570,6 +684,12 @@ async function main(argv) {
     // Gates off: nothing is written and nothing is said.
     if (!r.written && r.reason === attendedVerdict(opts.gate).reason) return 0;
     if (!r.written) process.stderr.write(`gate-ledger: nothing written: ${r.reason}\n`);
+    if (r.capped) {
+      process.stderr.write(
+        `gate-ledger: ${opts.gate} failed ${RETRY_CAP} times in a row; the run is paused (retry cap). Report what was tried and ask the user how to continue.\n`,
+      );
+      return 5;
+    }
     return r.written ? 0 : 3;
   }
   if (mode === "check") {
@@ -619,9 +739,8 @@ async function main(argv) {
     // mode that commits nothing, evidence present), 1 warn, 4 block. Never 2
     // or 3 for a missing run: outside the pipeline a commit is none of this
     // hook's business.
-    const pref = globalPref("attendedCommitGate.mode", "warn");
-    const gateMode = ATTENDED_COMMIT_MODES.includes(pref) ? pref : "warn";
-    if (gateMode === "off") return 0;
+    const pref = globalPref("attendedCommitGate.mode", "auto");
+    if (pref === "off") return 0;
     let session = "";
     if (opts["hook-input"] === "-") {
       try {
@@ -638,7 +757,11 @@ async function main(argv) {
     if (modeEntry(state)?.commits === false) return 0;
     const sha = opts.sha || headSha(repo);
     if (!sha) return 0;
-    const missing = attendedEvidenceGaps(state, sha);
+    const launched = process.env.MULTI_AGENT_SESSION_ID || "";
+    const bound =
+      (session && state.hostSessionId === session) || (launched && state.sessionId === launched);
+    const gateMode = effectiveCommitMode(pref, Boolean(bound));
+    const missing = attendedEvidenceGaps(state, sha, { sameTree: sameTreeAs(repo) });
     if (opts.json)
       writeFileSync(1, `${JSON.stringify({ statePath: path, sha, gateMode, missing })}\n`);
     if (!missing.length) return 0;
@@ -647,9 +770,9 @@ async function main(argv) {
       2,
       `${[
         `pre-commit-check: ${verb}: the run's gate ledger (${path}) has no passing ${missing.join(" / ")} for HEAD ${sha.slice(0, 12)}.`,
-        "  Run the build and the tests through evidence-gate.mjs (Phase 2 Gate 1) so the commit rests on recorded evidence.",
+        "  Run the build and the tests through evidence-gate.mjs (Phase 2 Gate 1), and in the commit phase the review verdict (review-decision-gate.mjs), so the commit rests on recorded evidence.",
         gateMode === "block"
-          ? "  prefs.global.attendedCommitGate.mode is block; set it to warn to commit anyway."
+          ? "  This session drives the run, so the commit waits for the evidence; prefs.global.attendedCommitGate.mode warn lets it through."
           : "  The commit goes ahead; prefs.global.attendedCommitGate.mode block refuses it instead.",
       ].join("\n")}\n`,
     );