shapeup-sdlc 3.3.0 → 3.4.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shapeup-sdlc-plugin",
   "displayName": "ShapeUp SDLC Plugin",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "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/lib/contract.mjs

@@ -172,7 +172,16 @@ export function coerce(raw) {
   // A LIST IS TESTED BEFORE THE QUOTES ARE STRIPPED. `"[a, b]"` is a quoted STRING; stripping first
   // would turn it into a list and change its type on a round-trip.
   if (/^\[.*\]$/.test(trimmed)) return splitList(trimmed.slice(1, -1));
+  // A QUOTED SCALAR IS A STRING, VERBATIM — the same rule the list test above already applies, one
+  // step further in. Unquoting FIRST and then testing the bareword literals meant the quotes bought
+  // nothing: `"false"` unwrapped to `false` and then matched the boolean test, so a cell whose value
+  // is genuinely the word "false" re-read as the boolean. Same for `"true"`, `"123"`, `"~"` and `""`
+  // — a string changed TYPE on a round trip, silently, the first time its contract was rewritten.
+  // Quoting is how an author says "this is text"; honouring that is what makes the round trip total.
+  const quoted = trimmed.length >= 2 && (trimmed[0] === '"' || trimmed[0] === "'")
+    && trimmed[trimmed.length - 1] === trimmed[0];
   const v = unquote(trimmed);
+  if (quoted) return v;
   if (v === "true") return true;
   if (v === "false") return false;
   if (v === "~" || v === "null" || v === "") return null;
@@ -192,10 +201,17 @@ export function uncoerce(v) {
   // side instead of the reader's.
   if (Array.isArray(v)) return `[${v.map((x) => (/[,"]/.test(String(x)) ? JSON.stringify(String(x)) : String(x))).join(", ")}]`;
   const s = String(v);
-  // A scalar that itself begins AND ends with a quote is indistinguishable, once written, from a
-  // quoted scalar — so emit it in the JSON form the reader unwraps exactly. Without this the round
-  // trip loses the value's own outer quotes, which is the same shredding as the reader's half.
-  if (s.length >= 2 && (s[0] === '"' || s[0] === "'") && s[s.length - 1] === s[0]) return JSON.stringify(s);
+  // THE READER IS THE ORACLE. Anything whose plain text would come back as a DIFFERENT VALUE goes
+  // out quoted — and the only honest test of that is to ask `coerce` itself.
+  //
+  // This subsumes the older rule (a scalar that begins AND ends with a quote) and closes the family
+  // it missed: a string whose text is a bareword literal changed TYPE on a round trip. The string
+  // "false" re-read as the boolean false, "123" as the number 123, "[a, b]" as a two-member list,
+  // "~" as null. Each is a value an author can legitimately write in a cell, and each silently
+  // became something else the first time the contract was rewritten. `coerce(s) !== v` catches all
+  // of them at once and leaves every value that already round-trips untouched — a path, a sentence,
+  // a real boolean, a real number.
+  if (coerce(s) !== v) return JSON.stringify(s);
   return s;
 }
 

package/kernel/reduce/board.mjs

@@ -68,7 +68,11 @@ const listField = (fm, key) => {
  */
 export function parseBoard(tasksDir) {
   if (!existsSync(tasksDir)) return [];
-  return readdirSync(tasksDir)
+  // SORTED, because `criticalPath` breaks ties on strict `>` and therefore keeps the FIRST chain it
+  // meets among equal-hours chains. Directory order is a filesystem detail (APFS happens to return
+  // sorted; ext4's hash order does not, and neither does a rename), so an unsorted read made a
+  // derived value depend on which machine ran it. Every sibling reader in the kernel already sorts.
+  return readdirSync(tasksDir).sort()
     .filter((f) => /^TASK-[\w.-]+\.md$/i.test(f))
     .map((f) => {
       const body = readFileSync(join(tasksDir, f), "utf8");
@@ -130,10 +134,30 @@ export function criticalPath(tasks) {
     }
     return (memo[id] = { hours: best.hours + t.hours, chain: [...best.chain, id] });
   };
+  // TIES BREAK ON CONTENT, NOT ON ARRIVAL. `>` alone keeps whichever equal-hours chain is MET
+  // FIRST, which is input order — so this function returned a different critical path for the same
+  // board depending only on how its task list happened to be ordered. Measured: two disjoint
+  // 5-hour chains, five permutations of one list, two different answers.
+  //
+  // Sorting the reader that feeds it (`parseBoard`) makes the input stable and therefore hides this
+  // on any one machine, but it leaves the ORDER-DEPENDENCE in place one call up — a caller with its
+  // own ordering, or a future second reader, re-opens it. A derived value has to be a function of
+  // the board, not of the walk that produced it, so the tie is resolved here: same hours, then the
+  // lexicographically smaller chain. Deterministic on every machine and for every caller.
+  /**
+   * Is chain `c` a better critical path than the incumbent `b`?
+   * @param {{hours:number, chain:string[]}} c - The candidate chain.
+   * @param {{hours:number, chain:string[]}} b - The incumbent best.
+   * @returns {boolean} True when `c` has more hours, or ties on hours and sorts first by chain
+   *   content — so the answer is a function of the board rather than of the iteration order.
+   */
+  const better = (c, b) => c.hours > b.hours
+    || (c.hours === b.hours && c.chain.length > 0
+        && (b.chain.length === 0 || c.chain.join("\u0000") < b.chain.join("\u0000")));
   let best = { hours: 0, chain: [] };
   for (const t of tasks) {
     const c = longest(t.id);
-    if (c.hours > best.hours) best = c;
+    if (better(c, best)) best = c;
   }
   return best;
 }

package/kernel/reduce/graph.mjs

@@ -43,7 +43,7 @@ export const WORK_NODES = ["Run", "Order", "Result", "Verdict", "Trial", "GateDe
 export const DOMAIN_NODES = ["Scope", "UseCase", "Requirement", "Seam"];
 
 /** Edge types. Each names a direction that is meaningful to read backwards. */
-export const EDGES = ["PRODUCED", "EVALUATES", "SUPERSEDES", "COVERS", "DEPENDS_ON", "DERIVED_FROM"];
+export const EDGES = ["PRODUCED", "EVALUATES", "SUPERSEDES", "COVERS", "DEPENDS_ON", "DERIVED_FROM", "IMPLEMENTS"];
 
 /**
  * Read the graph as a log and fold it into nodes and edges.
@@ -63,7 +63,10 @@ export function readGraph(cwd, slug) {
     let row;
     try { row = JSON.parse(line); } catch { continue; }   // a torn line proves nothing; skip it
     lines++;
-    if (row.k === "node" && row.id) nodes.set(row.id, { ...(nodes.get(row.id) || {}), ...row });
+    // LAST LINE WINS, as the banner says — a REPLACE, not a merge. Merging kept attributes from
+    // superseded lines alive forever, so an attribute removed from an artifact survived in the
+    // projection and a rebuilt graph stopped matching the maintained one.
+    if (row.k === "node" && row.id) nodes.set(row.id, row);
     else if (row.k === "edge" && row.from && row.to && row.t) edges.set(`${row.from}|${row.t}|${row.to}`, row);
   }
   return { nodes, edges, lines };
@@ -194,16 +197,19 @@ export function project(cwd, slug) {
         source: g.source ?? null, note: g.note ?? null, round: g.round ?? null,
         run_id: g.run_id ?? runId ?? null,
       });
-      // A round-scoped gate's decision depends on that round's T0 verdict(s) — the most honest
-      // shape, since that is the evidence the decision was made against. Every other gate (and a
-      // round-scoped one with no verdict yet on disk) depends on the Run instead, so no
-      // `GateDecision` node is ever orphaned.
+      // EVERY gate depends on the Run, UNCONDITIONALLY — and a round-scoped one ALSO depends on that
+      // round's T0 verdict(s), the evidence it was decided against.
+      //
+      // The Run edge used to be an `else` FALLBACK, and a conditional edge TARGET cannot survive an
+      // append-only log. Gates are crossed BEFORE the round's verdict artifact lands, so the first
+      // projection minted `DEPENDS_ON run` and a later one added the verdict edges beside it —
+      // and `appendGraph` has no tombstone, so the fallback became permanent. The incremental graph
+      // then carried an edge a rebuild does not imply, breaking the one property this file exists to
+      // promise: that it can be deleted and rebuilt identically. Unconditional is also truer — a gate
+      // does depend on its run. The fix is not a guard; it is removing the condition.
+      if (runNode) edge(id, "DEPENDS_ON", runNode);
       const roundVerdicts = (g.gate === "L2" || g.gate === "L3") ? verdictIdsByRound.get(g.round) : null;
-      if (roundVerdicts?.length) {
-        for (const vid of roundVerdicts) edge(id, "DEPENDS_ON", vid);
-      } else if (runNode) {
-        edge(id, "DEPENDS_ON", runNode);
-      }
+      for (const vid of roundVerdicts || []) edge(id, "DEPENDS_ON", vid);
     }
   }
 
@@ -221,7 +227,15 @@ export function project(cwd, slug) {
       // projected to two nodes. `--trace` is supposed to reach "the execution record"; it reached
       // whichever scope happened to be written last. `baseline_trial` is chosen from the same
       // scope's prior rows, so the SUPERSEDES edge resolves inside the same partition.
-      const trialKey = (n) => `trial:${slug}:${t.scope_id ? `${t.scope_id}:` : ""}${n}`;
+      //
+      // AND THE RUN IS PART OF THE KEY TOO, for the same reason one step out. A trial ordinal
+      // restarts at 1 in the next run while `trials.jsonl` is APPEND-ONLY, so both runs' rows live
+      // on disk together and `trial:<slug>:<scope>:1` named two of them — the second run silently
+      // overwrote the first run's execution record, which is the identical defect the paragraph
+      // above records fixing once already, one key component short. `baseline_trial` is chosen from
+      // the same run's rows, so SUPERSEDES still resolves inside the partition.
+      const trialRun = t.run_id ?? runId ?? "norun";
+      const trialKey = (n) => `trial:${slug}:${trialRun}:${t.scope_id ? `${t.scope_id}:` : ""}${n}`;
       const id = trialKey(t.trial);
       node(id, "Trial", {
         trial: t.trial, round: t.round ?? null, attempt: t.attempt ?? null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shapeup-sdlc",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "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"

package/skills/tech-lead/workflows/shapeup-run.js

@@ -1193,6 +1193,17 @@ await advisory(`reduce hill --slug ${slug}`, "MapScopes", "hill-derive");
 const lastEval = rs.eval_rounds_done?.length ? Math.max(...rs.eval_rounds_done) : 0;
 let round = lastEval + 1;
 let verdict = null;
+// DERIVED FROM DISK AT EVERY LAUNCH, never accumulated only in memory. These two lists ARE GATE H's
+// census: `scope-hammer` is dispatched with `hammer_proposals`, and AGENTS.md makes a scope that
+// exhausted its attempt budget a queued GATE H proposal. As bare `const []` they were emptied by the
+// one event that most needs them intact — a gate PAUSE is a `return`, so the PO's answer is followed
+// by a FRESH LAUNCH whose accumulators start empty and whose round loop is then fast-forwarded past
+// the rounds that filled them. The PO was handed an empty cut list for a run that had genuinely
+// exhausted scopes. Unattended (`ci`) runs never pause, which is why no archived trace shows it.
+//
+// This file has now paid for the same class three times — `findings` in the temporal dead zone and
+// `payload.bugs` "lived in a variable, which a relaunch between two rounds resets to empty" are the
+// other two. The cure is the same each time and it is not a bigger variable: re-derive the fact.
 const allGreen = [];
 const allHammer = [];
 // OUTSIDE the loop, because its whole purpose is to cross a round boundary: round r's verdict is
@@ -1248,6 +1259,16 @@ while (verdict !== "pass" && round <= maxRounds) {
   const alreadyGreen = new Set(g?.green_scopes_by_round?.[String(round)] || []);
   if (alreadyGreen.size) log(`BUILD r${round} — ${alreadyGreen.size} scope(s) already green in the graph, skipping them`);
 
+  // REBUILD THE CENSUS FROM THE GRAPH THIS QUERY JUST RETURNED. Everything a prior launch learned is
+  // already on disk: a scope green in ANY round is green work, and a scope the run has touched but
+  // never got green is what GATE H has to be shown. One query, already made, re-read — so a relaunch
+  // after a paused gate carries the same census the launch that paused it would have.
+  const greenEver = new Set(Object.values(g?.green_scopes_by_round || {}).flat());
+  for (const sid of greenEver) if (!allGreen.includes(sid)) allGreen.push(sid);
+  for (const sid of (g?.scopes || [])) {
+    if (!greenEver.has(sid) && !allHammer.includes(sid) && scopes.some((x) => x.scope_id === sid)) allHammer.push(sid);
+  }
+
   // SCOPES FAN OUT. A scope contract is the definition of an independent subtask — disjoint
   // substrate, own fixtures, own ratchet — so the loop that ran them one at a time was leaving the
   // whole point of the contract on the floor. `pipeline()` has NO barrier between its stages: a
@@ -1281,13 +1302,25 @@ while (verdict !== "pass" && round <= maxRounds) {
       async (pre, s) => (pre?.pending ? buildScope(s, round) : pre),
       async (res, s) => {
         if (!res || res.__failed) return res;
-        if (res.resumed || !res.green) return res;
-        const confirmed = await query(`probe t0 --slug ${slug} --scope ${s.scope_id} --round ${round}`,
-          T0CHECK, "Build", `t0confirm:${s.scope_id}-r${round}`);
-        if (!confirmed?.green) {
-          log(`BUILD r${round} — ${s.scope_id} reported green but no T0 verdict is on disk for this ` +
-              `round; treating it as not green (the evaluator cites that artifact, and it is not there).`);
-          return { ...res, green: false, reason: "reported green with no T0 verdict artifact on disk" };
+        if (!res.green) return res;
+        // THE T0 RE-READ IS SKIPPED FOR A RESUMED SCOPE; THE LEG CHECK BELOW IS NOT.
+        //
+        // `resumed` means the graph already reported this scope green for this round, so re-reading
+        // its T0 artifact would only confirm what the resume derivation just read. But these two
+        // stages answer DIFFERENT questions, and the second one is precisely the question a resumed
+        // scope is most likely to fail: a relaunch happens because the previous launch DIED, and a
+        // leg that died between writing its result and running `reduce ingest` leaves exactly this
+        // state — green T0 on disk, result never applied, board still `pending`. The short-circuit
+        // used to cover both stages, so the one scope class known to be at risk was the one class
+        // nobody asked, and the late-ingest repair nine lines below could never fire for it.
+        if (!res.resumed) {
+          const confirmed = await query(`probe t0 --slug ${slug} --scope ${s.scope_id} --round ${round}`,
+            T0CHECK, "Build", `t0confirm:${s.scope_id}-r${round}`);
+          if (!confirmed?.green) {
+            log(`BUILD r${round} — ${s.scope_id} reported green but no T0 verdict is on disk for this ` +
+                `round; treating it as not green (the evaluator cites that artifact, and it is not there).`);
+            return { ...res, green: false, reason: "reported green with no T0 verdict artifact on disk" };
+          }
         }
         // AND ITS RESULT HAS TO HAVE REACHED THE BOARD. A green T0 says the worker's fixtures ran and
         // passed; it says nothing about whether the WorkResult was applied, and this stage used to ask
@@ -1341,8 +1374,10 @@ while (verdict !== "pass" && round <= maxRounds) {
     }
   }
 
-  allGreen.push(...roundGreen);
-  allHammer.push(...roundHammer);
+  for (const sid of roundGreen) if (!allGreen.includes(sid)) allGreen.push(sid);
+  // A scope that went green this round is no longer a cut candidate, however it was queued earlier.
+  for (const sid of roundGreen) { const i = allHammer.indexOf(sid); if (i !== -1) allHammer.splice(i, 1); }
+  for (const sid of roundHammer) if (!allHammer.includes(sid) && !allGreen.includes(sid)) allHammer.push(sid);
 
   // INNER breaker: nothing green and something queued → GATE H. The census is scope-hammer's job.
   if (roundGreen.length === 0 && roundHammer.length > 0) {