@mmerterden/multi-agent-pipeline 16.19.0 → 16.20.0

package/pipeline/scripts/review-delta.mjs

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+/**
+ * review-delta.mjs  -  classify one Phase 4 round against the round before it.
+ *
+ * Reviewers re-read the whole diff every round and return findings with no
+ * memory of the previous round. This script gives the loop that memory: it
+ * fingerprints both rounds (see _fingerprint.mjs) and reports which accepted
+ * findings are still present after the fix, which were resolved, which triage
+ * downgraded, and which are new. A finding that survives `--trip-cycles`
+ * consecutive rework cycles is the autopilot circuit-breaker's trigger 2.
+ *
+ * Usage:
+ *   review-delta.mjs --rounds-dir <dir> --iteration N [options]
+ *   review-delta.mjs --previous <round-N-1.json> --current <round-N.json> [--prior <round-N-2.json> ...] [options]
+ *
+ * Options:
+ *   --kind triage|reviewer|dev-critic   document shape (default triage)
+ *   --trip-cycles N                     recurrence that trips (default 2)
+ *   --severities a,b                    accepted severities that count as the
+ *                                       rework mandate (default blocking,important)
+ *
+ * Output (stdout, JSON): {iteration, previousIteration, counts, new[], stillPresent[],
+ *   resolved[], downgraded[], stillPresentBlocking[], recurrence{}, tripped, plateau}
+ *   Each list entry is {fingerprint, severity, file, issue} so a log line reads
+ *   without a lookup. With no previous round: {"skipped":"no-previous-round"}.
+ *
+ * Exit codes:
+ *   0   progress, or nothing to compare (fail-open like evidence-gate)
+ *   1   unparseable input or wrong shape
+ *   3   trigger-2 signal: a mandate finding recurred >= --trip-cycles times
+ *   64  usage
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { annotate, collectFingerprints, KINDS } from "./_fingerprint.mjs";
+
+const USAGE = `usage:
+  review-delta.mjs --rounds-dir <dir> --iteration N [--kind ${KINDS.join("|")}] [--trip-cycles N] [--severities a,b]
+  review-delta.mjs --previous <json> --current <json> [--prior <json> ...] [same options]`;
+
+const ROUND_FILE = (n) => `triage-round-${n}.json`;
+
+function parseArgs(argv) {
+  const opts = { prior: [], kind: "triage", tripCycles: 2, severities: ["blocking", "important"] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i];
+    if (a === "--rounds-dir") opts.roundsDir = next();
+    else if (a === "--iteration") opts.iteration = Number(next());
+    else if (a === "--previous") opts.previous = next();
+    else if (a === "--current") opts.current = next();
+    else if (a === "--prior") opts.prior.push(next());
+    else if (a === "--kind") opts.kind = next();
+    else if (a === "--trip-cycles") opts.tripCycles = Number(next());
+    else if (a === "--severities")
+      opts.severities = next()
+        .split(",")
+        .map((s) => s.trim());
+    else return null;
+  }
+  return opts;
+}
+
+function loadDoc(path, kind) {
+  const doc = JSON.parse(readFileSync(path, "utf-8"));
+  return annotate(doc, kind).doc;
+}
+
+/**
+ * Resolve the ordered list of round files, newest first: [current, previous, prior...].
+ * Returns null when there is no previous round to compare against.
+ */
+function resolveRounds(opts) {
+  if (opts.roundsDir) {
+    if (!Number.isInteger(opts.iteration) || opts.iteration < 1) {
+      throw new Error("--iteration must be a positive integer");
+    }
+    const current = join(opts.roundsDir, ROUND_FILE(opts.iteration));
+    if (!existsSync(current)) throw new Error(`current round file missing: ${current}`);
+    const chain = [current];
+    for (let n = opts.iteration - 1; n >= 1; n--) {
+      const p = join(opts.roundsDir, ROUND_FILE(n));
+      if (!existsSync(p)) break;
+      chain.push(p);
+    }
+    return { chain, iteration: opts.iteration };
+  }
+  if (!opts.current) throw new Error("--current is required without --rounds-dir");
+  const chain = [opts.current];
+  if (opts.previous) chain.push(opts.previous, ...opts.prior);
+  return { chain, iteration: chain.length };
+}
+
+function entry(fp, finding) {
+  return {
+    fingerprint: fp,
+    severity: finding.severity ?? null,
+    file: finding.file ?? null,
+    issue: finding.issue ?? null,
+  };
+}
+
+function buckets(kind) {
+  return kind === "triage"
+    ? { accepted: ["accepted"], elsewhere: ["deferred", "rejected"] }
+    : { accepted: ["findings"], elsewhere: [] };
+}
+
+function mandate(doc, kind, severities) {
+  return collectFingerprints(doc, { kind, buckets: buckets(kind).accepted, severities });
+}
+
+function setEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const x of a) if (!b.has(x)) return false;
+  return true;
+}
+
+export function computeDelta(docs, { kind, severities, tripCycles }) {
+  const [current, previous, ...priors] = docs;
+  const b = buckets(kind);
+  const prevMandate = mandate(previous, kind, severities);
+  const prevAll = collectFingerprints(previous, { kind, buckets: b.accepted });
+  const curAccepted = collectFingerprints(current, { kind, buckets: b.accepted });
+  const curElsewhere = collectFingerprints(current, { kind, buckets: b.elsewhere });
+
+  const stillPresent = [];
+  const resolved = [];
+  const downgraded = [];
+  for (const [fp, f] of prevMandate) {
+    if (curAccepted.has(fp)) stillPresent.push(entry(fp, curAccepted.get(fp)));
+    else if (curElsewhere.has(fp)) downgraded.push(entry(fp, f));
+    else resolved.push(entry(fp, f));
+  }
+  const fresh = [];
+  for (const [fp, f] of curAccepted) if (!prevAll.has(fp)) fresh.push(entry(fp, f));
+
+  const priorMandates = priors.map((d) => mandate(d, kind, severities));
+  const recurrence = {};
+  for (const { fingerprint } of stillPresent) {
+    let n = 1;
+    for (const m of priorMandates) {
+      if (!m.has(fingerprint)) break;
+      n += 1;
+    }
+    recurrence[fingerprint] = n;
+  }
+
+  let plateau = false;
+  if (priors.length > 0 && stillPresent.length > 0) {
+    const prevStill = new Set();
+    for (const fp of priorMandates[0].keys()) if (prevMandate.has(fp)) prevStill.add(fp);
+    plateau = setEqual(prevStill, new Set(stillPresent.map((e) => e.fingerprint)));
+  }
+
+  const tripped = stillPresent.some((e) => recurrence[e.fingerprint] >= tripCycles);
+  return {
+    counts: {
+      new: fresh.length,
+      stillPresent: stillPresent.length,
+      resolved: resolved.length,
+      downgraded: downgraded.length,
+    },
+    new: fresh,
+    stillPresent,
+    resolved,
+    downgraded,
+    stillPresentBlocking: stillPresent.filter((e) => e.severity === "blocking"),
+    recurrence,
+    tripped,
+    plateau,
+  };
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (!opts || !KINDS.includes(opts.kind) || !(opts.tripCycles >= 1)) {
+    console.error(USAGE);
+    return 64;
+  }
+
+  let rounds;
+  try {
+    rounds = resolveRounds(opts);
+  } catch (err) {
+    console.error(`error: ${err.message}`);
+    return opts.roundsDir && /missing/.test(err.message) ? 1 : 64;
+  }
+
+  if (rounds.chain.length < 2) {
+    process.stdout.write(JSON.stringify({ skipped: "no-previous-round" }) + "\n");
+    return 0;
+  }
+
+  let docs;
+  try {
+    docs = rounds.chain.map((p) => loadDoc(p, opts.kind));
+  } catch (err) {
+    console.error(`error: ${err.message}`);
+    return 1;
+  }
+
+  const delta = computeDelta(docs, opts);
+  const out = {
+    iteration: rounds.iteration,
+    previousIteration: rounds.iteration - 1,
+    ...delta,
+  };
+  process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+  return delta.tripped ? 3 : 0;
+}
+
+if (process.argv[1] && /review-delta\.mjs$/.test(process.argv[1])) {
+  process.exit(main());
+}

package/pipeline/scripts/run-metrics.mjs

@@ -23,6 +23,11 @@
  *                                           attribution reports "unavailable".
  *   consensusVerdict                      - unanimous-* / split / unverified
  *   buildPassed                           - per-repo build outcome
+ *   diff.filesTouched / locAdded /        - size of the change, from state.diffRisk
+ *   locRemoved / maxScore                   (Phase 4 Step 1.75); null when the
+ *                                           run predates the persisted totals
+ *   reviewDelta.stillPresentFinal /       - cross-round classification of the
+ *   resolvedTotal / tripped                 last iteration (state.reviewIterations[].delta)
  *
  * Usage:
  *   node pipeline/scripts/run-metrics.mjs --state path/to/agent-state.json
@@ -147,6 +152,10 @@ if (projects.length) {
   buildPassed = typeof b === "string" ? b === "passed" : b && b.ok === true;
 }
 
+const diffRisk = state.diffRisk && typeof state.diffRisk === "object" ? state.diffRisk : {};
+const deltas = iterations.map((it) => it.delta).filter((d) => d && typeof d === "object");
+const lastDelta = deltas.length ? deltas[deltas.length - 1] : null;
+
 const metrics = {
   taskId: state.taskId ?? null,
   status: state.status ?? null,
@@ -193,6 +202,17 @@ const metrics = {
   },
   consensusVerdict: lastTriage.consensus ? lastTriage.consensus.verdict : null,
   buildPassed,
+  diff: {
+    filesTouched: Number.isInteger(diffRisk.files) ? diffRisk.files : null,
+    locAdded: Number.isInteger(diffRisk.loc_added) ? diffRisk.loc_added : null,
+    locRemoved: Number.isInteger(diffRisk.loc_removed) ? diffRisk.loc_removed : null,
+    maxScore: typeof diffRisk.max_score === "number" ? diffRisk.max_score : null,
+  },
+  reviewDelta: {
+    stillPresentFinal: lastDelta ? (lastDelta.stillPresent || []).length : null,
+    resolvedTotal: deltas.length ? deltas.reduce((n, d) => n + (d.resolved || []).length, 0) : null,
+    tripped: deltas.some((d) => d.tripped === true),
+  },
 };
 
 console.log(JSON.stringify(metrics, null, 2));

package/pipeline/scripts/scope-check-gate.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * scope-check-gate.mjs  -  every file in the diff needs a stated reason.
+ *
+ * Phase 3 writes `.pipeline/scope-check.json` before the handoff: one reason
+ * per touched file, the things it deliberately did not do, and the simplifier
+ * rationales that used to be discarded. This gate compares that record with
+ * the real diff so an unjustified file cannot ride into review unnoticed.
+ *
+ * Usage:
+ *   git diff --name-only <base>...HEAD | node scope-check-gate.mjs --check .pipeline/scope-check.json --diff-files -
+ *   node scope-check-gate.mjs --check scope-check.json --diff-files files.txt [--advisory]
+ *
+ * Output (stdout, JSON): {ok, justified, unjustified[], unlisted[], notDone}
+ *   unjustified = in the diff, missing from files[] (or with an empty reason)
+ *   unlisted    = in files[], not in the diff (stale entry; reported, never fatal)
+ *
+ * Exit codes: 0 every diff file justified (or --advisory), 1 otherwise or on
+ * unreadable input, 64 usage.
+ */
+
+import { readFileSync } from "node:fs";
+
+import { normalizeFile } from "./_fingerprint.mjs";
+
+const USAGE =
+  "usage: scope-check-gate.mjs --check <scope-check.json> --diff-files <path|-> [--advisory]";
+
+function parseArgs(argv) {
+  const opts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--check") opts.check = argv[++i];
+    else if (a === "--diff-files") opts.diffFiles = argv[++i];
+    else if (a === "--advisory") opts.advisory = true;
+    else return null;
+  }
+  return opts.check && opts.diffFiles ? opts : null;
+}
+
+function readText(path) {
+  return path === "-" ? readFileSync(0, "utf-8") : readFileSync(path, "utf-8");
+}
+
+export function evaluate(check, diffFiles) {
+  const files = Array.isArray(check?.files) ? check.files : [];
+  const reasons = new Map();
+  for (const f of files) {
+    if (!f || typeof f.path !== "string") continue;
+    const reason = typeof f.reason === "string" ? f.reason.trim() : "";
+    reasons.set(normalizeFile(f.path), reason);
+  }
+  const diff = [...new Set(diffFiles.map(normalizeFile).filter(Boolean))];
+  const unjustified = diff.filter((p) => !(reasons.get(p) ?? "").length);
+  const diffSet = new Set(diff);
+  const unlisted = [...reasons.keys()].filter((p) => !diffSet.has(p));
+  return {
+    ok: unjustified.length === 0,
+    justified: diff.length - unjustified.length,
+    unjustified,
+    unlisted,
+    notDone: Array.isArray(check?.notDone) ? check.notDone.length : 0,
+  };
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (!opts) {
+    console.error(USAGE);
+    return 64;
+  }
+  const fail = opts.advisory ? 0 : 1;
+  let check;
+  let diffFiles;
+  try {
+    check = JSON.parse(readText(opts.check));
+    diffFiles = readText(opts.diffFiles).split("\n");
+  } catch (err) {
+    console.error(`scope-check-gate: ${err.message}`);
+    process.stdout.write(JSON.stringify({ ok: false, error: err.message }) + "\n");
+    return fail;
+  }
+  const result = evaluate(check, diffFiles);
+  process.stdout.write(JSON.stringify(result) + "\n");
+  return result.ok ? 0 : fail;
+}
+
+if (process.argv[1] && /scope-check-gate\.mjs$/.test(process.argv[1])) {
+  process.exit(main());
+}

package/pipeline/scripts/smoke-cross-cli-behavior.sh

@@ -159,15 +159,22 @@ echo "→ 7. Agent personas deployed to both CLIs"
 
 CLAUDE_AGENTS="$HOME/.claude/agents"
 COPILOT_AGENTS="$HOME/.copilot/agents"
-AGENT_FILES=(code-reviewer.md explorer.md ios-architect.md android-architect.md backend-architect.md security-auditor.md)
+AGENT_FILES=()
+if [ -d "$CLAUDE_AGENTS" ]; then
+  for f in "$CLAUDE_AGENTS"/*.md; do
+    [ -f "$f" ] && AGENT_FILES+=("$(basename "$f")")
+  done
+fi
 
 if [ -d "$CLAUDE_AGENTS" ] && [ -d "$COPILOT_AGENTS" ]; then
   missing_on_copilot=0
-  for a in "${AGENT_FILES[@]}"; do
+  for a in ${AGENT_FILES[@]+"${AGENT_FILES[@]}"}; do
     [ -f "$COPILOT_AGENTS/$a" ] || missing_on_copilot=$((missing_on_copilot+1))
   done
-  if [ "$missing_on_copilot" -eq 0 ]; then
-    pass "all 6 reviewer/explorer personas present on both CLIs"
+  if [ "$missing_on_copilot" -eq 0 ] && [ "${#AGENT_FILES[@]}" -gt 0 ]; then
+    pass "all ${#AGENT_FILES[@]} personas present on both CLIs"
+  elif [ "${#AGENT_FILES[@]}" -eq 0 ]; then
+    fail "no persona files under $CLAUDE_AGENTS"
   else
     fail "$missing_on_copilot persona file(s) missing from Copilot side"
   fi

package/pipeline/scripts/validate-reviewer.mjs

@@ -29,6 +29,7 @@ import { readFileSync } from "node:fs";
 
 const ALLOWED_SEVERITIES = new Set(["blocking", "important", "suggestion"]);
 const ALLOWED_VERDICTS = new Set(["conformant", "violated", "not-applicable"]);
+const FINGERPRINT_RE = /^F:[0-9a-f]{8}$/;
 
 /** @returns {Promise<string>} */
 function readInput() {
@@ -73,6 +74,11 @@ function validateFinding(f, label, errors) {
   if (typeof f.fix !== "string" || f.fix.length < 4) {
     errors.push(`${label}: fix too short or missing`);
   }
+  if (f.fingerprint !== undefined && !FINGERPRINT_RE.test(String(f.fingerprint))) {
+    errors.push(
+      `${label}: fingerprint ${JSON.stringify(f.fingerprint)} is not F: plus 8 hex digits  -  echo one from <previous-round-findings> or leave it unset`,
+    );
+  }
 }
 
 /** Rule IDs the reviewer was told to answer for. Empty set = no criteria supplied. */

package/pipeline/scripts/validate-triage.mjs

@@ -32,6 +32,7 @@ const ALLOWED_CONSENSUS_VERDICTS = new Set([
   "unverified",
 ]);
 const ALLOWED_VERIFICATION_RESULTS = new Set(["confirmed", "not-reproduced", "inconclusive"]);
+const FINGERPRINT_RE = /^F:[0-9a-f]{8}$/;
 const OVER_REJECT_THRESHOLD = 0.8;
 const OVER_REJECT_MIN_FINDINGS = 5;
 
@@ -73,6 +74,11 @@ function validateRawFinding(f, label, errors) {
   if (f.verification !== undefined) {
     validateVerification(f.verification, `${label}.verification`, errors);
   }
+  if (f.fingerprint !== undefined && !FINGERPRINT_RE.test(String(f.fingerprint))) {
+    errors.push(
+      `${label}: fingerprint ${JSON.stringify(f.fingerprint)} is not F: plus 8 hex digits (finding-fingerprint.mjs computes it; do not invent one)`,
+    );
+  }
 }
 
 // v3.2.0 verify-by-test outcome (Phase 4 Step 3.7). Optional; when present:
@@ -237,6 +243,20 @@ function validate(raw) {
     return { ok: false, code: 1, errors, warnings, corrected };
   }
 
+  // Two reviewers can report the same issue; the merge is triage's job, so a
+  // repeated fingerprint inside accepted[] is surfaced, not rejected.
+  const seenFingerprints = new Map();
+  parsed.accepted.forEach((f, i) => {
+    if (typeof f.fingerprint !== "string") return;
+    if (seenFingerprints.has(f.fingerprint)) {
+      warnings.push(
+        `accepted[${i}] repeats fingerprint ${f.fingerprint} of accepted[${seenFingerprints.get(f.fingerprint)}]  -  same finding reported twice; Phase 3 should treat them as one`,
+      );
+    } else {
+      seenFingerprints.set(f.fingerprint, i);
+    }
+  });
+
   // Contradiction auto-correction (bidirectional)
   const hasBlocker = parsed.accepted.some((f) => f.severity === "blocking");
   if (parsed.approved === false && !hasBlocker) {

package/pipeline/skills/shared/core/multi-agent-store-ready/SKILL.md

@@ -39,6 +39,11 @@ doc is the contract.
 | 2 Authoritative | `ios_testflight_validate` → `altool --validate-app`, needs credentials | `SKIPPED`  -  Play's authoritative check is server-side only and no client ships here |
 | 3 Policy | `ai-ios-toolkit:app-store-review` skill vs repo source | `ai-android-toolkit:play-store-review` skill vs repo source |
 
+Gate 1 also fails the package on its own, without the MCP tool, when the archive
+carries no dSYM (iOS) or a `minifyEnabled true` module produced no `mapping.txt`
+(Android). Gate 3 carries a `Crash symbolication` row on both platforms: a dSYM
+upload step for iOS, a `mapping.txt` upload for Android.
+
 Gate 2's asymmetry is reported as an asymmetry. An Android run clears at most 2 of 3
 gates and must never print `passed`. A skipped gate is never folded into the pass
 count on either platform.