shapeup-sdlc 3.7.6 → 3.7.7

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shapeup-sdlc-plugin",
   "displayName": "ShapeUp SDLC Plugin",
-  "version": "3.7.6",
+  "version": "3.7.7",
   "description": "Shape Up SDLC harness for Claude Code: shaping, intake, orient, scope-mapping, building (T0-verified, sandboxed, scope-contracted), evaluation and QA skills orchestrated by a tech-lead.",
   "author": {
     "name": "Liberty Nguyen",

package/kernel/gate.mjs

@@ -54,7 +54,7 @@ import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } fr
 import { parseBoard } from "./reduce/board.mjs";
 import { join, dirname } from "node:path";
 import { runArgs } from "./lib/argv.mjs";
-import { gateAnswerCandidates, gates as gatesPath, LOCAL, resultsDir, tasksDir, hammerCensus } from "./lib/paths.mjs";
+import { gateAnswerCandidates, gates as gatesPath, LOCAL, resultsDir, tasksDir, hammerCensus, readRunId } from "./lib/paths.mjs";
 
 export const GATE_IDS = ["L0", "L1a", "L1a.5", "L1b", "L2", "L3", "QA", "H", "L4", "COACH-1"];
 
@@ -465,7 +465,11 @@ export function cli(rawArgv) {
   // per-run ledger row — the same reasoning `resolveRunId` uses for "no run is active": absence is
   // the correct answer, not an error, so the write is skipped rather than guessing a location.
   if (args.slug) {
+    // THE ROW CARRIES THE RUN KEY. It did not, and the export stamped the current run's key onto
+    // every row it found — a prior run's sign-off became this run's in the one table that answers
+    // "was this ship signed off". Driven on a two-run fixture before it was fixed.
     appendGateLedger(cwd, args.slug, {
+      at: new Date().toISOString(), run_id: readRunId(cwd, args.slug),
       gate: r.gate, status: r.status, decision: r.decision ?? null,
       source: r.source ?? found.source, note: r.note ?? r.reason ?? null,
       round: args.round ?? null,

package/kernel/probe/eval.mjs

@@ -35,7 +35,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { runArgs } from "../lib/argv.mjs";
-import { resultsDir, scopesDir } from "../lib/paths.mjs";
+import { resultsDir, scopesDir, readRunId } from "../lib/paths.mjs";
 
 /** Longest `reason` reported. A deviation is prose written by a worker and can run to paragraphs. */
 const REASON_MAX = 400;
@@ -89,7 +89,7 @@ export function isScoped(cwd, slug) {
  * @returns {(string|null)} A reason phrased for an operator, or null when the file at `path` exists,
  *   hashes to the cited `sha256`, and its own `overall` reads "green".
  */
-function unresolvedCitation(cwd, citation) {
+function unresolvedCitation(cwd, citation, { round = null, runId = null } = {}) {
   const rel = typeof citation?.path === "string" ? citation.path : "";
   if (!rel) return "names no artifact path";
   let text;
@@ -109,6 +109,20 @@ function unresolvedCitation(cwd, citation) {
   try { body = JSON.parse(text); }
   catch { return `cites ${rel}, whose bytes match the hash but do not read as a T0 verdict`; }
   if (body?.overall !== "green") return `cites ${rel}, whose own verdict is "${body?.overall ?? "unknown"}", not green`;
+  // THE ARTIFACT HAS TO BE THE ONE THE CITATION SAYS IT IS. A re-hash proves the bytes are the
+  // file's; it says nothing about whose verdict the file holds. A PASS citing scope alpha's green
+  // artifact while declaring scope beta, or a prior round's, or a prior run's over the same slug,
+  // passed the digest check unremarked. The citation's own required `scope_id`, the round being
+  // judged and the run's key are compared to what the artifact records about itself.
+  if (typeof citation.scope_id === "string" && body?.scope_id && body.scope_id !== citation.scope_id) {
+    return `cites ${rel} for scope "${citation.scope_id}", but the artifact records scope "${body.scope_id}"`;
+  }
+  if (round != null && typeof body?.round === "number" && body.round !== round) {
+    return `cites ${rel}, a round ${body.round} artifact, as evidence for round ${round}`;
+  }
+  if (runId && body?.run_id && body.run_id !== runId) {
+    return `cites ${rel}, an artifact of run ${body.run_id}, as evidence for run ${runId}`;
+  }
   return null;
 }
 
@@ -143,15 +157,49 @@ function unresolvedCitation(cwd, citation) {
  *   citation resolves, an unscoped spec, or a block with no PASS/FAIL in it (there is no judgement
  *   to invalidate).
  */
-export function citationProblem(cwd, slug, verdict) {
+/**
+ * Why a verdict cannot stand on its own criteria, or null when it can.
+ *
+ * `overall` is the judge's field, and nothing recomputed it from the criteria the judge graded: a
+ * PASS over a failing criterion, or over no criterion at all, validated and ingested, and the
+ * round loop branched on it. The evaluator's own first rule is that absence of evidence is a FAIL,
+ * so a PASS criterion with no evidence is no evidence either. Recomputed here, on ingest and on
+ * read alike: PASS means every graded criterion passed with evidence and at least one was graded;
+ * FAIL means at least one graded criterion failed.
+ *
+ * @param {object} verdict - The WorkResult's `verdict`.
+ * @returns {(string|null)} A reason phrased for an operator, or null.
+ */
+export function verdictProblem(verdict) {
+  const overall = verdict?.overall;
+  if (overall !== "PASS" && overall !== "FAIL") return null;
+  const criteria = Array.isArray(verdict.criteria) ? verdict.criteria : [];
+  const fails = criteria.filter((c) => c?.verdict === "FAIL");
+  const passes = criteria.filter((c) => c?.verdict === "PASS");
+  const other = criteria.length - fails.length - passes.length;
+  if (overall === "PASS") {
+    if (criteria.length === 0) return "the PASS verdict grades no criterion at all — a PASS with no evidence is a claim";
+    if (fails.length) return `the verdict says PASS while ${fails.length} of its ${criteria.length} criteria read FAIL — overall is derived from the criteria, never declared over them`;
+    if (other) return `the verdict says PASS while ${other} of its criteria carry no PASS/FAIL verdict`;
+    const bare = passes.filter((c) => !(typeof c?.evidence === "string" && c.evidence.trim()));
+    if (bare.length) return `the PASS verdict has ${bare.length} criterion(s) marked PASS with no evidence — absence of evidence is a FAIL by the evaluator's own first rule`;
+    return null;
+  }
+  if (criteria.length === 0) return "the FAIL verdict grades no criterion at all — a FAIL must name what failed";
+  if (!fails.length) return `the verdict says FAIL while every one of its ${criteria.length} graded criteria reads PASS — a FAIL must cite the criterion it failed`;
+  return null;
+}
+
+export function citationProblem(cwd, slug, verdict, { round = null } = {}) {
   if (verdict?.overall !== "PASS" && verdict?.overall !== "FAIL") return null;
   if (!isScoped(cwd, slug)) return null;
   if (!Array.isArray(verdict.t0_citations) || !verdict.t0_citations.length) {
     return `the ${verdict.overall} verdict cites no T0 artifact, and a verdict on a scoped spec must ` +
       "cite the T0 verdict it re-hashed (the order lists them under payload.t0_artifacts)";
   }
+  const runId = readRunId(cwd, slug);
   for (const citation of verdict.t0_citations) {
-    const reason = unresolvedCitation(cwd, citation);
+    const reason = unresolvedCitation(cwd, citation, { round, runId });
     if (reason) return `the ${verdict.overall} verdict ${reason} — a T0 citation is re-hashed from disk, never taken on the handed word`;
   }
   return null;
@@ -185,7 +233,7 @@ export function evalVerdict(cwd, slug, round) {
       ? `the evaluator returned ${status || "no status"}: ${first}`
       : `status ${status || "unknown"} with no PASS/FAIL verdict`), status);
   }
-  const problem = citationProblem(cwd, slug, v);
+  const problem = verdictProblem(v) || citationProblem(cwd, slug, v, { round });
   if (problem) return unfit(problem, status, overall);
   return {
     found: true,

package/kernel/probe/rounds.mjs

@@ -22,7 +22,7 @@
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { ordersDir, verdictsDir, roundBuildDir, resultsDir } from "../lib/paths.mjs";
+import { ordersDir, verdictsDir, roundBuildDir, resultsDir, readRunId } from "../lib/paths.mjs";
 
 /** Parse a JSON file, returning null rather than throwing — every reader here is best-effort. */
 function readJson(p) {
@@ -59,12 +59,22 @@ const maxOf = (nums) => (nums.length ? Math.max(...nums) : null);
  * @returns {{rounds_used:*, rounds_judged:(number|null)}} Both counts.
  */
 export function deriveRounds(cwd, slug, fallback) {
+  // THIS RUN'S RECORDS ONLY. Orders, verdicts and build gates over one slug accumulate across runs
+  // and carry their run key; walking the directories unfiltered handed a run that had dispatched
+  // nothing a prior run's round count — into the committed report. A record with no key at all was
+  // written before the key existed and is kept; one with a different key is another run's.
+  const runId = readRunId(cwd, slug);
+  const mine = (rec) => !runId || !rec?.run_id || rec.run_id === runId;
   const orderRounds = [];
   const oDir = ordersDir(cwd, slug);
+  const orderOf = {};
   if (existsSync(oDir)) {
     for (const f of readdirSync(oDir)) {
       if (!f.endsWith(".json")) continue;
-      const r = orderRound(readJson(join(oDir, f))?.order_id);
+      const o = readJson(join(oDir, f));
+      orderOf[f] = o;
+      if (!mine(o)) continue;
+      const r = orderRound(o?.order_id);
       if (r !== null) orderRounds.push(r);
     }
   }
@@ -74,7 +84,7 @@ export function deriveRounds(cwd, slug, fallback) {
   if (existsSync(vDir)) {
     for (const f of readdirSync(vDir).filter((x) => x.endsWith(".json"))) {
       const v = readJson(join(vDir, f));
-      if (typeof v?.round === "number") verdictRounds.push(v.round);
+      if (mine(v) && typeof v?.round === "number") verdictRounds.push(v.round);
     }
   }
 
@@ -83,7 +93,7 @@ export function deriveRounds(cwd, slug, fallback) {
   if (existsSync(bDir)) {
     for (const f of readdirSync(bDir)) {
       const m = f.match(/^r(\d+)-t\d+\.json$/);
-      if (m) buildGateRounds.push(Number(m[1]));
+      if (m && mine(readJson(join(bDir, f)))) buildGateRounds.push(Number(m[1]));
     }
   }
 
@@ -92,7 +102,8 @@ export function deriveRounds(cwd, slug, fallback) {
   if (existsSync(rDir)) {
     for (const f of readdirSync(rDir)) {
       const m = f.match(/^evaluate-r(\d+)\.json$/);
-      if (m) evalRounds.push(Number(m[1]));
+      // A WorkResult carries no run key; it reaches one through its order of the same name.
+      if (m && mine(orderOf[f] ?? readJson(join(oDir, f)))) evalRounds.push(Number(m[1]));
     }
   }
 

package/kernel/reduce/ingest.mjs

@@ -37,7 +37,7 @@ import { fileURLToPath } from "node:url";
 import { validate } from "../verify/envelope.mjs";
 import { runArgs } from "../lib/argv.mjs";
 import { tasksDir, localRoot, dispatchReceipts, legLedger, readRunId } from "../lib/paths.mjs";
-import { citationProblem } from "../probe/eval.mjs";
+import { citationProblem, verdictProblem } from "../probe/eval.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const RESULT_SCHEMA = JSON.parse(readFileSync(resolve(HERE, "../schemas/work-result.schema.json"), "utf8"));
@@ -697,7 +697,8 @@ export async function cli(rawArgv) {
   // on (see `citationProblem`). `probe eval` refuses it to the round loop; refusing it here as well
   // keeps the verdict ledger from recording a verdict the loop will never branch on.
   if (result.verdict) {
-    const problem = citationProblem(cwd, String(result.order_id).split("/")[0], result.verdict);
+    const evalRound = Number((String(result.order_id).match(/-r(\d+)$/) || [])[1]) || null;
+    const problem = verdictProblem(result.verdict) || citationProblem(cwd, String(result.order_id).split("/")[0], result.verdict, { round: evalRound });
     if (problem) {
       console.error(`ingest-result: result refused — ${problem}.`);
       console.error(`  The round stays open: re-dispatch the evaluator against its order, which lists`);

package/kernel/reduce/ship.mjs

@@ -329,7 +329,13 @@ export function buildReport(facts) {
     "*Run state (board, orders, results, T0 artifacts, evaluation and QA reports) stays in the",
     "gitignored local tier (ADR-0001). This report",
     "is the frozen conclusion of it.*", "");
-  return L.join("\n");
+  // THE WHOLE REPORT, ONCE. Board ids were anchored in three places and leaked through a fourth: a
+  // discovery-ledger entry copied verbatim into "Discovered, not built" carried `[TASK-005]`, this
+  // kernel wrote it straight to the committed tier past the hook that guards the model's edits, and
+  // the next run's L1b lint red'd the file the previous run had frozen. A committed report may not
+  // name a board id anywhere, so the rule is applied to the finished text rather than section by
+  // section.
+  return deboard(L.join("\n"), board.anchors);
 }
 
 /**

package/kernel/report/export.mjs

@@ -173,12 +173,14 @@ function criterionRows(dir, runId, t) {
  * (see `appendGateLedger`), so this is a pass-through with a stamped `run_id` fallback rather than
  * a re-derivation: two readers of "what did this gate decide" must not compute the answer twice.
  * @param {object} g - One parsed line of `gates.jsonl`.
- * @param {(string|null)} runId - Run key for a row written before it carried its own.
+ * @param {(string|null)} runId - The run being exported (unused for attribution — the row's own key is the only one exported).
  * @returns {object} A flat `gate_decision` row.
  */
 function gateDecisionRow(g, runId) {
   return {
-    run_id: g?.run_id ?? runId ?? null,
+    // The row's own key, never the current run's stamped on: a row that carries no key was written
+    // before the ledger did, and is exported as unattributed rather than claimed.
+    run_id: g?.run_id ?? null,
     gate: g?.gate ?? null,
     decision: g?.decision ?? null,
     status: g?.status ?? null,
@@ -260,7 +262,9 @@ export function collectRun(cwd, slug) {
       criterion_verdict: criterionRows(evaluationDir(cwd, slug), runId, t),
       hook_decision,
       // The decision that crossed each gate, and the round build gate's own artifact.
-      gate_decision: readJsonl(gatesPath(cwd, slug), t).map((g) => gateDecisionRow(g, runId)),
+      // Scoped to the run, like hook_decision one line up: gate rows over one slug accumulate across
+      // runs, and a prior run's L4 exported under this run's key is a fabricated sign-off.
+      gate_decision: readJsonl(gatesPath(cwd, slug), t).filter((g) => runId && g?.run_id === runId).map((g) => gateDecisionRow(g, runId)),
       build_gate: readJsonDir(roundBuildDir(cwd, slug), t).map((a) => buildGateRow(a, runId)),
       leg: readJsonl(legLedger(cwd, slug), t)
         .filter((r) => !runId || !r?.run_id || r.run_id === runId)

package/kernel/verify/trace.mjs

@@ -40,7 +40,7 @@ import { resolve, join, dirname, relative, isAbsolute } from "node:path";
 import { readBoard } from "../compile.mjs";
 import { runArgs } from "../lib/argv.mjs";
 import { sharedRoot, traceDir, relLocal } from "../lib/paths.mjs";
-import { readContract, unreadableReason, LEGACY_LAYOUT, WIRING_MAP, PROJECT_PROFILE } from "../lib/contract.mjs";
+import { readContract, unreadableReason, LEGACY_LAYOUT, WIRING_MAP, PROJECT_PROFILE, reqId } from "../lib/contract.mjs";
 
 // --- requirements.md registry parser -----------------------------------------
 // A committed markdown table: | REQ-id | clause (verbatim) | source | status | note |
@@ -87,7 +87,10 @@ export function coveredReqIds(board) {
   for (const task of board) {
     for (const ac of task.acceptance_criteria || []) {
       const covers = typeof ac === "object" && Array.isArray(ac.covers) ? ac.covers : [];
-      for (const id of covers) if (/^REQ-\d+$/.test(id)) covered.add(id);
+      // ONE KEY SPACE. `R-2`, `[[REQ-5]]` and `req-4` are the same clause spelled three ways, and the
+      // sibling rule accepts all of them; testing the raw string here counted every one as nothing, so
+      // an author told at L1b to cover a requirement with an AC — which they had — stayed red.
+      for (const raw of covers) { const id = reqId(raw); if (/^REQ-\d+$/.test(id)) covered.add(id); }
     }
   }
   return covered;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shapeup-sdlc",
-  "version": "3.7.6",
+  "version": "3.7.7",
   "description": "Shape Up for coding agents \u2014 with gates the agent can't talk its way past. Harness for Claude Code.",
   "bin": {
     "shapeup-sdlc": "bin/init.mjs"