@mmerterden/multi-agent-pipeline 16.27.0 → 16.28.0

package/pipeline/scripts/skill-siblings.mjs

@@ -44,11 +44,20 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(HERE, "..", "..");
 const HOME = homedir();
 
-const CMD_DIR = join(ROOT, "pipeline", "commands", "multi-agent");
-const CORE_DIR = join(ROOT, "pipeline", "skills", "shared", "core");
+// Two layouts, and the script ships into the second one. From the repo checkout
+// HERE is <repo>/pipeline/scripts, so the authored trees sit one level up. From
+// an install HERE is ~/.claude/scripts and there is no `pipeline/` above it:
+// resolving blind reported "no commands found" and made every caller believe
+// the tree had changed. Try the repo first, fall back to the install.
+const REPO_ROOT = resolve(HERE, "..", "..");
+const REPO_CMD_DIR = join(REPO_ROOT, "pipeline", "commands", "multi-agent");
+const IN_REPO = existsSync(REPO_CMD_DIR);
+const ROOT = IN_REPO ? REPO_ROOT : HOME;
+
+const CMD_DIR = IN_REPO ? REPO_CMD_DIR : join(HOME, ".claude", "commands", "multi-agent");
+const CORE_DIR = join(REPO_ROOT, "pipeline", "skills", "shared", "core");
 const COPILOT_DIR = join(HOME, ".copilot", "skills");
 const CODEX_DIR = join(HOME, ".codex", "multi-agent-refs", "commands");
 // The dispatcher is the one skill Codex installs as a SKILL: the 51 sub-commands
@@ -107,11 +116,23 @@ function siblingsOf(name) {
   );
   const installedName = name === "multi-agent" ? "multi-agent" : `multi-agent-${name}`;
 
+  // The two authored surfaces exist only in the checkout. From an install they
+  // are not missing, they are not applicable, and counting them as absent would
+  // report every command as 3/5 forever - a number that reads as damage and is
+  // really just the layout. In an install CMD_DIR is also the claude tree, so
+  // listing "authored" there would double-count one file as two surfaces.
+  const authoredSurfaces = IN_REPO
+    ? [
+        { tree: "command (authored)", path: authored, exists: existsSync(authored), inRepo: true },
+        { tree: "shared core skill", path: shared, exists: existsSync(shared), inRepo: true },
+      ]
+    : [];
+
   return {
     name,
+    layout: IN_REPO ? "repo" : "install",
     surfaces: [
-      { tree: "command (authored)", path: authored, exists: existsSync(authored), inRepo: true },
-      { tree: "shared core skill", path: shared, exists: existsSync(shared), inRepo: true },
+      ...authoredSurfaces,
       {
         tree: "claude (installed)",
         path: join(CLAUDE_DIR, name === "multi-agent" ? "SKILL.md" : join(name, "SKILL.md")),
@@ -145,11 +166,23 @@ if (AUDIT) {
   });
   const broken = rows.filter((r) => r.missingRepo.length > 0);
   if (JSON_OUT) {
-    process.stdout.write(JSON.stringify({ commands: names.length, broken, rows }, null, 2) + "\n");
+    process.stdout.write(
+      JSON.stringify(
+        { layout: IN_REPO ? "repo" : "install", commands: names.length, broken, rows },
+        null,
+        2,
+      ) + "\n",
+    );
   } else {
-    process.stdout.write(`${names.length} command(s) checked\n`);
+    process.stdout.write(`${names.length} command(s) checked (${IN_REPO ? "repo" : "install"})\n`);
     if (broken.length === 0) {
-      process.stdout.write("  every command has its authored sibling in the repo\n");
+      // From an install there is no authored side to check, and claiming one
+      // was checked is the failure this script exists to prevent one level up.
+      process.stdout.write(
+        IN_REPO
+          ? "  every command has its authored sibling in the repo\n"
+          : "  authored siblings not checked  -  no repo checkout resolved from here\n",
+      );
     }
     for (const r of broken) {
       process.stdout.write(`  MISSING  ${r.name}: ${r.missingRepo.join(", ")}\n`);

package/pipeline/scripts/validate-analysis-doc.mjs

@@ -100,11 +100,27 @@ const BANNED_PUNCT = [
   { ch: "’", name: "curly-single-close" },
 ];
 
+// A Section 20 status cell is bilingual (`Açık / Open`, `Karar verildi / Decided`),
+// so openness is decided per token rather than by searching the row. A substring
+// search read "hata açıklaması netleşti" as open, because "açıklama" contains
+// "Açık" - and "açıklama" is one of the most common words in a Turkish spec, so
+// that blocked a correctly closed document. English has the same trap in
+// "reopened" and "opened".
+const OPEN_STATUS = ["açık", "acik", "open", "girdi bekleniyor", "pending input"];
+function isOpenStatus(cell) {
+  return String(cell)
+    .split("/")
+    .some((part) => {
+      const t = part.trim().toLowerCase();
+      return OPEN_STATUS.some((v) => t === v || t.startsWith(`${v} `) || t.startsWith(`${v}(`));
+    });
+}
+
 function readInput() {
-  const args = process.argv.slice(2).filter((a) => a !== "--strict");
+  const args = process.argv.slice(2).filter((a) => !a.startsWith("--"));
   const arg = args[0];
   if (!arg) {
-    console.error("usage: validate-analysis-doc.mjs <path|-> [--strict]");
+    console.error("usage: validate-analysis-doc.mjs <path|-> [--strict] [--report]");
     process.exit(64);
   }
   if (arg === "-") return readFileSync(0, "utf-8");
@@ -169,11 +185,56 @@ function tableDataRows(bodyLines) {
   return rows;
 }
 
+// The report registry. `--report` prints one line per check, and the reason a
+// check did not run is part of the answer: the traceability matrix is corporate
+// only, so on a global document it never executes - and until this existed the
+// output for "ran, found nothing" and "never ran" was the same string. A summary
+// that cannot tell those apart is the shape of defect this file exists to catch.
+//
+// Attribution is positional: mark() closes the check that was running and takes
+// every error and warning pushed since the previous mark. That keeps the checks
+// themselves untouched, and the totals reconcile by construction - a forgotten
+// mark misnames a finding, it can never lose one.
+//
+// A count therefore OUTRANKS a skip label. Two blocks legitimately push a finding
+// and then mark themselves skipped - a malformed `status` value is caught by the
+// closure gate that then reports "draft document", and the redesign drift warning
+// is raised by the branch that reports "not a redesign". Printing the skip label
+// there dropped a real finding out of the report while stderr still carried it,
+// which is the one thing this registry exists to prevent.
+function makeReporter(errors, warns) {
+  const rows = [];
+  let e = 0;
+  let w = 0;
+  return {
+    rows,
+    mark(id, skipped) {
+      const de = errors.length - e;
+      const dw = warns.length - w;
+      e = errors.length;
+      w = warns.length;
+      const counts = [de ? `${de} error(s)` : null, dw ? `${dw} warning(s)` : null]
+        .filter(Boolean)
+        .join(", ");
+      const verdict = counts
+        ? skipped
+          ? `${counts} (otherwise skipped: ${skipped})`
+          : counts
+        : skipped
+          ? `skipped: ${skipped}`
+          : "ok";
+      rows.push({ id, verdict });
+    },
+  };
+}
+
 function main() {
   const text = readInput();
   const strict = process.argv.includes("--strict");
+  const report = process.argv.includes("--report");
   const errors = [];
   const warns = [];
+  const { rows: checkRows, mark } = makeReporter(errors, warns);
 
   // 1. Front-matter
   const parsed = parseFrontMatter(text);
@@ -198,6 +259,7 @@ function main() {
     errors.push(`front-matter profile must be global|corporate, got: ${profile}`);
   }
   const noPlatform = (parsed?.fm?.platform || "") === "none";
+  mark("front-matter");
 
   // 2. Never-omitted sections (by heading keyword)
   // Numbered section headings only. Layer headings (`# Bölüm B - Teknik Analiz`)
@@ -218,8 +280,15 @@ function main() {
       errors.push(`missing required section (${rule}): ${sec.key}`);
     }
   }
+  mark("required-sections");
+
+  // Section 20, resolved once and read twice: the marker check needs its owner
+  // column, the closure gate needs its status column.
+  let risksRows;
+  let risksHeader = null;
+  let risksStatusIdx = -1;
 
-  // 2a. Corporate profile: every EKLENECEK owes an open question, by id.
+  // 2a. Every admitted gap owes an open question, by id - in BOTH profiles.
   //
   // A placeholder with nobody assigned to resolve it is how "to be filled in"
   // reaches production. This used to pair a gap with Section 20 by matching the
@@ -228,7 +297,15 @@ function main() {
   // cases it still could not separate. Stable ids remove the ambiguity the same
   // way IG / UC / FG already do: the body writes EKLENECEK (AS-07) and Section 20
   // defines AS-07, and each side is checked against the other.
-  if (profile === "corporate") {
+  //
+  // It ran only in the corporate profile until now, which made the global one the
+  // profile where an inline marker could point at nothing. Two documents already
+  // told it to: Locked 36 says an unstamped gap fails the dispatch gate with no
+  // profile clause, and analysis/render.md routes an external-dependency gap to
+  // `AS-NN` in Section 20 for every run. The check was the only side that
+  // disagreed. Nothing changes for a document that carries no markers: every loop
+  // below is empty, so this is free for the documents that never needed it.
+  {
     const lines = text.split("\n");
     const risksStart = lines.findIndex((l) => /^#{2,3}\s+\d+/.test(l) && /(Riskler|Risks)/.test(l));
     let risksBlock = "";
@@ -271,6 +348,103 @@ function main() {
       }
     }
 
+    // The owner is what separates a plan from a defect, and until now that
+    // sentence lived only in analysis/review.md - a model's judgement call. The
+    // column is located from the header rather than by index, because the two
+    // profiles order Section 20 differently and an index would silently read the
+    // wrong cell in one of them.
+    const rows = risksBlock.split("\n").filter((l) => /^\s*\|/.test(l));
+    const header = rows.find((l) => /(Sahibi|Owner|Kime sorulacak)/i.test(l));
+    // Hoisted for the closure gate below, which has to read the SAME rows: the
+    // first pipe row in the document carrying an id is often a body table cell
+    // (the corporate template writes `| **Request** | EKLENECEK (AS-NN) |`), and
+    // judging openness from that row let a final document with live placeholders
+    // through. Section 20 is the only place that answers the question.
+    risksRows = rows;
+    risksHeader = header || rows.find((l) => /(Durum|Status)/i.test(l)) || null;
+    if (risksHeader) {
+      risksStatusIdx = risksHeader
+        .split("|")
+        .map((c) => c.trim())
+        .findIndex((c) => /(Durum|Status)/i.test(c));
+    }
+    if (header) {
+      const cols = header.split("|").map((c) => c.trim());
+      const oi = cols.findIndex((c) => /(Sahibi|Owner|Kime sorulacak)/i.test(c));
+      for (const row of rows) {
+        if (row === header || /^\s*\|[\s|:-]*\|?\s*$/.test(row)) continue;
+        if (!/\bAS-\d{2,3}\b/.test(row)) continue;
+        const cells = row.split("|").map((c) => c.trim());
+        const owner = cells[oi] || "";
+        if (!owner || /^(-|\?|TBD|EKLENECEK|N\/A)$/i.test(owner)) {
+          const id = (row.match(/\bAS-\d{2,3}\b/) || ["a row"])[0];
+          errors.push(`${id} names no owner in Risks and Open Questions (Locked 36)`);
+        }
+      }
+    } else if (rows.some((l) => /\bAS-\d{2,3}\b/.test(l))) {
+      // Only when there is something to own. A Section 20 with no stamped row
+      // has no owner to check, and warning there would fire on every document
+      // that never needed the column - noise that Phase 4 runs under --strict.
+      warns.push(
+        "Risks and Open Questions carries AS-NN rows but no owner column; ownership cannot be checked",
+      );
+    }
+    mark("uncertainty-markers");
+  }
+
+  // 2a-2. The closure gate. `status: final` is a publication claim, so it is the
+  // one place an open marker is fatal; `draft` reports the count and moves on.
+  // The key is optional and absent means draft - REQUIRED_FM deliberately does
+  // not list it, because a rule that fails every document written before it is
+  // not a rule, it is a migration nobody asked for.
+  {
+    const status = (parsed?.fm?.status || "draft").toLowerCase();
+    if (status !== "draft" && status !== "final") {
+      errors.push(`front-matter status must be draft|final, got: ${parsed.fm.status}`);
+    } else if (status === "final") {
+      const lines = text.split("\n");
+      const openMarkers = new Set();
+      for (const id of new Set(text.match(/\bAS-\d{2,3}\b/g) || [])) {
+        const row = risksRows.find((l) => l !== risksHeader && l.includes(id));
+        if (!row) {
+          // No Section 20 row at all. The pairing check above already errors on
+          // this; under `final` it is also unresolvable, so it stays open.
+          openMarkers.add(id);
+          continue;
+        }
+        if (risksStatusIdx >= 0) {
+          const cell = row.split("|").map((c) => c.trim())[risksStatusIdx] || "";
+          if (isOpenStatus(cell)) openMarkers.add(id);
+        } else if (lines.some((l) => l.includes(id) && /\b(EKLENECEK|TBD)\b/.test(l))) {
+          // The corporate Section 20 carries no status column, so the body is the
+          // signal: an EKLENECEK still stamped with this id is the gap itself,
+          // whatever the table says.
+          openMarkers.add(id);
+        }
+      }
+      for (const id of [...openMarkers].sort()) {
+        errors.push(`status: final but ${id} is still open (Locked 36 closure gate)`);
+      }
+      const stillOpen =
+        risksStatusIdx >= 0
+          ? risksRows.filter(
+              (l) =>
+                l !== risksHeader &&
+                isOpenStatus(l.split("|").map((c) => c.trim())[risksStatusIdx] || ""),
+            ).length
+          : 0;
+      if (stillOpen > 0 && openMarkers.size === 0) {
+        errors.push(
+          `status: final but Risks and Open Questions still has ${stillOpen} unresolved row(s)`,
+        );
+      }
+    }
+    mark("closure-gate", status === "final" ? undefined : "draft document");
+  }
+
+  if (profile === "corporate") {
+    const lines = text.split("\n");
+
     // 2b. JSON does not fit in a table cell (analysis-template.md Section 9.2 / 9.3).
     //
     // One document rendered `Request` as inline JSON with a field note glued to
@@ -289,6 +463,8 @@ function main() {
       }
     }
 
+    mark("payload-in-table-cell");
+
     // The traceability matrix is the most expensive thing in the document to get
     // wrong, because every downstream reader trusts it instead of re-deriving
     // the IG -> UC -> FG chain themselves. A matrix that merely exists is not
@@ -326,7 +502,13 @@ function main() {
           }
         }
       }
+      mark("traceability-matrix");
+    } else {
+      mark("traceability-matrix", "lite mode");
     }
+  } else {
+    mark("payload-in-table-cell", "global profile");
+    mark("traceability-matrix", "global profile");
   }
 
   // 2c. Diagram labels keep their diacritics.
@@ -363,6 +545,9 @@ function main() {
         }
       }
     }
+    mark("diagram-diacritics");
+  } else {
+    mark("diagram-diacritics", "document language is not tr");
   }
 
   // 2b. Opt-in coverage sections must be present when the front-matter says so.
@@ -392,6 +577,8 @@ function main() {
     }
   }
 
+  mark("optin-coverage-sections");
+
   // 2c. The Test Plan is Phase 3's RED input (phase-3-dev.md step 5b): the tests
   // written first come from it. Full mode without it hands dev an empty matrix.
   // It is Section 15 in the global profile and Section 19 in the corporate one;
@@ -427,6 +614,10 @@ function main() {
     }
   }
 
+  if (mode !== "full") mark("test-plan", "lite mode");
+  else if (noPlatform) mark("test-plan", "no target platform");
+  else mark("test-plan");
+
   // 2d. Section 3 carries the diagrams. Omission is legitimate under the
   // template's conditions, so absence warns; a rendered section with no
   // mermaid block is empty scaffolding and fails.
@@ -444,6 +635,8 @@ function main() {
     );
   }
 
+  mark("flow-chart");
+
   // 2e. Locked 16: every Files-to-Add row is tagged. The decision says untagged
   // rows fail the dispatch gate, so this is where that sentence becomes true.
   const allLines = text.split("\n");
@@ -459,6 +652,8 @@ function main() {
     }
   }
 
+  mark("files-to-add-tags", filesBody ? undefined : "no Files-to-Add section");
+
   // 2f. Locked 24: every Pass B concept-table cell carries its footnote.
   const conceptBody = sectionBody(allLines, ["Kavram tablosu", "Concept table"], 3);
   if (conceptBody) {
@@ -475,6 +670,8 @@ function main() {
     }
   }
 
+  mark("concept-table-evidence", conceptBody ? undefined : "no concept table");
+
   // 2g. Locked 31 main clause: a rule with no test scenario fails the gate.
   // The pre-existing occurrence-count heuristic below stays as the looser net.
   if (mode === "full") {
@@ -496,6 +693,145 @@ function main() {
     }
   }
 
+  mark("rule-to-test", mode === "full" ? undefined : "lite mode");
+
+  // 2h. Redesign mode (Locked 37). Eight checks, live only when the front-matter
+  // opts in. The contract they enforce is analysis/redesign.md, which loads only
+  // on a redesign run; what is here is the enforcement, not the explanation.
+  const redesign = String(parsed?.fm?.redesign || "false").toLowerCase() === "true";
+  const cbBody = sectionBody(
+    allLines,
+    ["Mevcut Davranış", "Mevcut Davranis", "Current Behaviour", "Current Behavior"],
+    3,
+  );
+  const epBody = sectionBody(
+    allLines,
+    ["Endpoint Eşlemesi", "Endpoint Eslemesi", "Endpoint Mapping"],
+    3,
+  );
+  const dlBody = sectionBody(allLines, ["Fark Listesi", "Difference List"], 3);
+  if (redesign) {
+    // 1. The sections themselves. Without this every row check below passes over
+    // nothing, which is the specific defect that shows a gate green on an empty
+    // document - the same shape the corporate matrix check guards against.
+    for (const [body, name] of [
+      [cbBody, "4.5 Current Behaviour"],
+      [epBody, "4.6 Endpoint Mapping"],
+      [dlBody, "9.5 Difference List"],
+    ]) {
+      if (!body) errors.push(`redesign: true but Section ${name} is missing (Locked 37)`);
+    }
+
+    const STATUSES = ["Moved", "Partial", "Missing", "New", "Out of scope"];
+    const CB_ID = /\bCB-[a-z0-9]+(?:-[a-z0-9]+)*-\d+/gi;
+    const cbRows = cbBody ? tableDataRows(cbBody) : [];
+    const dlRows = dlBody ? tableDataRows(dlBody) : [];
+
+    for (const row of cbRows) {
+      const cells = row.split("|").map((c) => c.trim());
+      const id = (row.match(CB_ID) || ["a row"])[0];
+      const evidence = cells[3] || "";
+      const certainty = (cells[4] || "").toLowerCase();
+      // 2. An unmarked guess. Prose can only ask an author to mark it; this finds
+      // the row that was not marked.
+      if (!/:\d+\b/.test(evidence) && !certainty.includes("uncertain")) {
+        errors.push(
+          `current-behaviour row ${id} cites no file:line and is not marked uncertain (Locked 37)`,
+        );
+      }
+      // 3. A rule that lives only in a shared module legitimately reads this way,
+      // so it warns rather than blocks - and Phase 4 runs --strict, so it blocks
+      // there, which is where a human is already looking.
+      if (/cross-cutting/i.test(evidence) && certainty.includes("confirmed")) {
+        warns.push(
+          `current-behaviour row ${id} is confirmed on cross-cutting evidence alone; name the file:line or mark it uncertain`,
+        );
+      }
+    }
+
+    for (const row of dlRows) {
+      const cells = row.split("|").map((c) => c.trim());
+      const id = (row.match(CB_ID) || ["a row"])[0];
+      const statusCell = cells[2] || "";
+      const status = STATUSES.find((v) => new RegExp(`\\b${v}\\b`, "i").test(statusCell));
+      // 4. A controlled vocabulary decaying into free text.
+      if (!status) {
+        errors.push(
+          `difference-list row ${id} has status "${statusCell}"; expected one of ${STATUSES.join(" / ")} (Locked 37)`,
+        );
+        continue;
+      }
+      // 5. The reason the mode exists: a behaviour v2 drops with no decision.
+      if ((status === "Missing" || status === "Partial") && !/\bAS-\d{2,3}\b/.test(row)) {
+        errors.push(
+          `difference-list row ${id} is ${status} with no AS-NN open question (Locked 37)`,
+        );
+      }
+    }
+
+    // 6. Both directions. A CB- id in the code and on nobody's difference list is
+    // the thing a redesign loses and production finds; an id on the list that no
+    // behaviour table defines is a row about nothing.
+    if (cbBody && dlBody) {
+      const defined = new Set(
+        cbRows.flatMap((r) => (r.match(CB_ID) || []).map((x) => x.toUpperCase())),
+      );
+      const listed = new Set(
+        dlRows.flatMap((r) => (r.match(CB_ID) || []).map((x) => x.toUpperCase())),
+      );
+      for (const id of defined) {
+        if (!listed.has(id))
+          errors.push(`${id} is in current behaviour but not in the difference list`);
+      }
+      for (const id of listed) {
+        if (!defined.has(id))
+          errors.push(`${id} is in the difference list but no behaviour defines it`);
+      }
+    }
+
+    // 7. A renderer that adds a column would silently disable the row checks
+    // above, so the shape is asserted before the rows are trusted.
+    if (epBody) {
+      const header = epBody.find((l) => /^\s*\|/.test(l) && /\bv1\b/i.test(l));
+      // GFM makes the trailing pipe optional, so a raw segment count reported a
+      // perfectly valid row as short. Strip the outer pipes on both sides first.
+      const cellCount = (line) =>
+        line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").length;
+      if (!header) {
+        errors.push("Section 4.6 has no v1/v2 header row (Locked 37)");
+      } else {
+        const cols = cellCount(header);
+        for (const row of tableDataRows(epBody)) {
+          if (cellCount(row) !== cols) {
+            errors.push(`endpoint-mapping row has ${cellCount(row)} cells, header has ${cols}`);
+          }
+        }
+      }
+    }
+    mark("redesign-artifacts");
+  } else {
+    // 8. Drift: the sections are rendered but the front-matter does not claim the
+    // mode, so none of the seven checks above ran over them.
+    //
+    // The heading match alone is not enough to say that. sectionBody tests the
+    // keyword as a raw substring of the heading line - deliberately, since Locked
+    // 2 re-flows section numbers and the corporate profile numbers them
+    // differently - so an unrelated `### 4.9 Notes on the old Current Behaviour
+    // audit process` matched, and Phase 4 runs --strict, which turns this warning
+    // into a blocked document. The artefact itself is the honest signal: a
+    // rendered current-behaviour table always carries `CB-<slug>-NN` ids, and a
+    // paragraph that merely uses the words never does.
+    const looksRendered = /\bCB-[a-z0-9]+(?:-[a-z0-9]+)*-\d+/i.test(
+      [...(cbBody || []), ...(dlBody || [])].join("\n"),
+    );
+    if (looksRendered) {
+      warns.push(
+        "redesign sections are present but front-matter does not say redesign: true, so none of their checks ran",
+      );
+    }
+    mark("redesign-artifacts", "not a redesign");
+  }
+
   // 3. Humanizer punctuation. Scope mirrors the humanizer pass exactly
   // (analysis/render.md): front-matter, fenced code blocks, table rows and
   // URLs are exempt there, so flagging them here would raise an ERROR that no
@@ -517,6 +853,8 @@ function main() {
     }
   }
 
+  mark("punctuation");
+
   // 4. Placeholder whole-section bodies (Locked 2).
   // Not a defect in the corporate profile: there N/A and EKLENECEK are how a
   // backbone section reports "considered, nothing to state" (Locked 33), and the
@@ -527,6 +865,8 @@ function main() {
     );
   }
 
+  mark("placeholder-bodies", profile === "global" ? undefined : "corporate profile");
+
   // 5. Traceability (Full mode only, Locked 31)
   if (mode === "full") {
     const idRe = /BR-[a-z0-9]+(?:-[a-z0-9]+)*-\d+/gi;
@@ -548,6 +888,8 @@ function main() {
     }
   }
 
+  mark("br-reference-count", mode === "full" ? undefined : "lite mode");
+
   // 6. Manual test scenarios (Section 15.7): every MT row carries a BR id.
   // A manual scenario nobody can trace back to a rule is a scenario nobody can
   // tell is still correct when the rule changes.
@@ -559,6 +901,8 @@ function main() {
     }
   }
 
+  mark("manual-scenario-ids");
+
   // 7. Variant coverage (Section 6.X): a row that lists an axis must say what
   // the whole axis is AND which values this screen uses. Half a row cannot be
   // audited - "used subset" means nothing without the set it is a subset of.
@@ -585,21 +929,41 @@ function main() {
     }
   }
 
+  mark("variant-coverage");
+
   // Report
+  if (report) {
+    const width = Math.max(...checkRows.map((r) => r.id.length));
+    console.log(
+      `validate-analysis-doc: ${checkRows.length} check(s), mode=${mode}, profile=${profile}`,
+    );
+    // The provenance the reader needs to compare two reports. A timestamp cannot
+    // separate two runs on the same day; the digest says the evidence moved and
+    // base_commit says the repo did. Both are already in the front-matter, on
+    // the side only a machine reads - this is the human-readable copy.
+    const digest = parsed?.fm?.evidence_digest;
+    const commit = parsed?.fm?.base_commit;
+    if (digest || commit) {
+      console.log(`  evidence_digest ${digest || "absent"}   base_commit ${commit || "absent"}`);
+    }
+    for (const r of checkRows) console.log(`  ${r.id.padEnd(width)}  ${r.verdict}`);
+    console.log("");
+  }
   for (const w of warns) console.error(`WARN: ${w}`);
   for (const e of errors) console.error(`ERROR: ${e}`);
   if (errors.length > 0) {
     console.error(
       `validate-analysis-doc: FAIL (${errors.length} error(s), ${warns.length} warning(s))`,
     );
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
   if (strict && warns.length > 0) {
     console.error(`validate-analysis-doc: FAIL under --strict (${warns.length} warning(s))`);
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
   console.log(`validate-analysis-doc: OK (mode=${mode}, ${warns.length} warning(s))`);
-  process.exit(0);
 }
 
 main();

package/pipeline/scripts/validate-analysis.mjs

@@ -55,7 +55,8 @@ async function main() {
     parsed = JSON.parse(raw);
   } catch (err) {
     emit({ ok: false, code: 1, errors: [`invalid JSON: ${err.message}`] });
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
 
   const errors = [];
@@ -63,7 +64,8 @@ async function main() {
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     errors.push("root must be an object");
     emit({ ok: false, code: 1, errors });
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
 
   // stack
@@ -124,11 +126,11 @@ async function main() {
 
   if (errors.length > 0) {
     emit({ ok: false, code: 1, errors });
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
 
   emit({ ok: true, code: 0, errors: [] });
-  process.exit(0);
 }
 
 function emit(result) {
@@ -137,5 +139,5 @@ function emit(result) {
 
 main().catch((err) => {
   emit({ ok: false, code: 1, errors: [`unhandled: ${err.message}`] });
-  process.exit(1);
+  process.exitCode = 1;
 });

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

@@ -4,6 +4,7 @@ language: en
 description: "List unassigned GitHub issues, pick one, auto-assign, and launch the multi-agent pipeline. Use when a GitHub issue should be picked up and started without knowing its number in advance."
 user-invocable: true
 argument-hint: "[autopilot]  -  optional: run the pipeline without confirmations"
+not-for: jira
 ---
 
 # multi-agent issue  -  GitHub Issue Picker

package/pipeline/skills/shared/core/multi-agent-review-issue/SKILL.md

@@ -4,6 +4,7 @@ language: en
 description: "Assess whether a GitHub issue is ready for multi-agent development: fetch it, grade scope / acceptance criteria / repro / design / API / stack readiness, then (after confirm) post the gaps as an issue comment. Read-only on code. Use when deciding whether a GitHub issue is specified well enough to hand to development."
 user-invocable: true
 argument-hint: "[#N | repo#N | GitHub issue URL]  -  optional; with no argument, pick from open issues"
+not-for: review-jira
 ---
 
 # multi-agent review-issue  -  GitHub issue readiness review