shapeup-sdlc 3.16.0 → 3.16.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shapeup-sdlc-plugin",
   "displayName": "ShapeUp SDLC Plugin",
-  "version": "3.16.0",
+  "version": "3.16.1",
   "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/commands/ship.md

@@ -99,6 +99,8 @@ Additional flags, pass through to `tech-lead` only when the user names them:
 - `--rounds N` → override the outer circuit breaker (build+eval cycles, default 3).
 - `--attempts N` → override the inner circuit breaker (per-scope T0 attempts, default 5;
   no-op on specs without scope contracts).
-- `--orch-model / --exec-model / --eval-model / --qa-model <name>` → override GATE L0.8's
+- `--exec-model / --eval-model / --qa-model <name>` → override GATE L0.8's
   resolved model matrix for this run only (highest precedence over `.claude/settings.local.json`
-  / `.claude/settings.json` / skill defaults).
+  / `.claude/settings.json` / skill defaults). `--orch-model` is shown in the L0 block and changes
+  nothing: the orchestrator is the session already running this command, so its model is the one
+  that session was started with.

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, readRunId } from "./lib/paths.mjs";
+import { gateAnswerCandidates, gates as gatesPath, LOCAL, resultsDir, tasksDir, hammerCensus, readRunId, harnessRun } from "./lib/paths.mjs";
 
 export const GATE_IDS = ["L0", "L1a", "L1a.5", "L1b", "L2", "L3", "QA", "H", "L4", "COACH-1"];
 
@@ -327,6 +327,34 @@ export function appendGateLedger(cwd, slug, row) {
   } catch { return false; }
 }
 
+/**
+ * This run's earlier ship sign-off, if it already has one.
+ *
+ * A launched run crosses L4 itself and then closes, and the orchestrator's own closing step resolved
+ * it again afterwards — a second `ship` row, after the close, for a decision already taken. Once the
+ * run is closed, its decided L4 row is returned instead of resolving again. An open run still
+ * re-resolves (the census it reads may have changed), a reopened run has no close, and a paused or
+ * aborted row is not a sign-off.
+ *
+ * @param {string} cwd - Project root.
+ * @param {string} slug - Feature slug.
+ * @param {string|null} runId - The run the resolve belongs to.
+ * @returns {(object|null)} The earlier L4 row, or null.
+ */
+export function priorSignOff(cwd, slug, runId) {
+  if (!runId) return null;
+  let ledger = "";
+  try { ledger = readFileSync(harnessRun(cwd, slug), "utf8"); } catch { return null; }
+  if (!/^closed_status:[ \t]*[^\s~]/m.test(ledger)) return null;
+  let text = "";
+  try { text = readFileSync(gatesPath(cwd, slug), "utf8"); } catch { return null; }
+  for (const line of text.split("\n")) {
+    let row; try { row = JSON.parse(line); } catch { continue; }
+    if (row?.gate === "L4" && row.run_id === runId && row.status === "ok") return row;
+  }
+  return null;
+}
+
 /** Gates this lane will actually hit — used by --verify to catch a set that stalls halfway. */
 export function requiredGates({ autoLevel = "unattended", tiny = false, qa = true } = {}) {
   if (tiny) return ["L0", "L4"];
@@ -483,6 +511,10 @@ export function cli(rawArgv) {
   const gate = args.resolve ?? null;
   if (!gate) die("nothing to do — pass --init, --list, --verify, or --resolve <gate-id>");
 
+  if (gate === "L4" && args.slug) {
+    const prior = priorSignOff(cwd, args.slug, readRunId(cwd, args.slug));
+    if (prior) out({ ok: true, gate: "L4", status: prior.status, decision: prior.decision, source: prior.source, already_resolved_at: prior.at }, 0);
+  }
   const r = narrowToEvidence(resolve(found.set, gate, found.source), cwd, args.slug ?? null);
   if (r.status === "error") die(r.reason);
   // A gate with no `--slug` (e.g. `--file` used ad hoc, outside any run) has nowhere to file a

package/kernel/reduce/ship.mjs

@@ -32,7 +32,7 @@ import { runArgs } from "../lib/argv.mjs";
 import {
   report as reportPath, tasksDir, verdictsDir, trials, evaluationDir, qaDir,
   roundLedger, discoveryLedger, receipt as receiptPath, harnessRun, relShared,
-  activeOrder, runArgsPath, readReceipt, runIdFromReceipt, hammerCensus,
+  activeOrder, runArgsPath, readReceipt, runIdFromReceipt, hammerCensus, LOCAL,
 } from "../lib/paths.mjs";
 import { readTrials } from "../verify/t0.mjs";
 import { ratchetReport } from "../probe/stats.mjs";
@@ -112,16 +112,27 @@ export function boardCensus(cwd, slug) {
  * An id with no resolvable use case becomes a neutral phrase rather than the id: the report loses a
  * pointer that never resolved off this machine anyway, and keeps the sentence around it.
  *
+ * A path into the run trace is the same leak by another spelling: the QA findings section quotes
+ * the hunt report, which points at the discovery ledger by its local path, and the next run's
+ * spec-lint refused the report for it. The path becomes "the run trace", and the sentence stays.
+ *
  * @param {*} text - Any value destined for the committed report.
  * @param {Record<string, string[]>} anchors - Board id → its `use_case_refs`.
- * @returns {string} The text with every `TASK-…` replaced by a stable anchor.
+ * @returns {string} The text with every `TASK-…` replaced by a stable anchor and every run-trace
+ *   path by a phrase.
  */
 export function deboard(text, anchors = {}) {
-  return String(text ?? "").replace(/\bTASK-[A-Za-z0-9][\w.-]*/g, (id) => {
-    const ucs = anchors[id];
-    if (ucs && ucs.length) return ucs.join("/");
-    return "a board task";
-  });
+  const esc = LOCAL.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return String(text ?? "")
+    .replace(/\bTASK-[A-Za-z0-9][\w.-]*/g, (id) => {
+      const ucs = anchors[id];
+      if (ucs && ucs.length) return ucs.join("/");
+      return "a board task";
+    })
+    .replace(new RegExp(`\`?${esc}/[^\\s\`]+\`?`, "g"), (m) => {
+      const tail = (m.replace(/`/g, "").match(/[)\]},.;:'"]+$/) || [""])[0];
+      return `the run trace${tail}`;
+    });
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shapeup-sdlc",
-  "version": "3.16.0",
+  "version": "3.16.1",
   "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/SKILL.md

@@ -110,11 +110,11 @@ failed, launch from the install path and have the operator `/add-dir` the plugin
 did not actually receive from the PO — an unattended lane with no answer for a gate is meant to
 `abort` (see `harness gate`'s `on_missing`), not silently proceed.
 
-## Step 4 — GATE L4 — Ship Sign-Off (this skill's own gate; the workflow never sees it)
+## Step 4 — GATE L4 — Ship Sign-Off
 
-FIRST freeze the evidence — run state is gitignored, so `shapeup/<slug>/REPORT.md` (already
-written by `shapeup-run.js` via `harness reduce ship`, or write it now on a `gate_h` close) is all a
-teammate sees. Then RESOLVE the gate — `references/gates.md` GATE L4 has the call — and emit:
+A `shipped`/`escalated` return already crossed L4 in the run and froze `REPORT.md`: never resolve it
+again (a row after the close is a second sign-off). A return that did not reach L4 freezes the report
+now and RESOLVES the gate (`references/gates.md` GATE L4). Either way, emit:
 
 ```
 ⏸ GATE L4 — Ship Sign-Off

package/skills/tech-lead/references/gates.md

@@ -571,7 +571,9 @@ On confirm:
 - If the PO provides substantive feedback (not just 'y' or empty) → automatically delegate via Agent (model: exec — see references/protocol.md "Invocation mechanism"): Skill(shapeup-sdlc-plugin:coach) with the provided feedback for RLHF. The coach runs its own GATE COACH-1 to have the PO categorize each rule, then files it under the responsible skill in `shapeup/knowledge-base/<skill>.md` (committed → team-shared). Coachable: `task-executor`, `ba-pitch-analyzer`, `qa-edge-hunter`, `orient`, `scope-architect`, `solution-architect` (each reads its own file at the top of its next run) and `tech-lead` (workflow guidance, read at the next GATE L0). Guidance never decides a gate: a filed rule may add a question or a check to a gate block, never an answer. The tech lead does not categorize the feedback itself — that is the coach's gate, by design (no assumptions).
 - Then output → `✅ [slug] [shipped & deployed | built & verified, deploy pending] — [r] rounds, verdict PASS.`
 
-**Resolve the gate itself before any of the above** — this is the decision that shipped the run,
+**A launched run already crossed L4 — never resolve it again after a `shipped` or `escalated`
+return; a second row after the close is a second sign-off.** In the prose lane, **resolve the gate
+itself before any of the above** — this is the decision that shipped the run,
 and without it the trace holds no record of that decision at all: `node
 "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" gate --resolve L4 --slug <slug>
 [--file <path>|--preset <name>]`. Exit 0 (`decision=ship|hold`) — render the block above and close

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

@@ -112,6 +112,10 @@ const argProblems = validateArgs(args);
 if (argProblems.length) return { status: "aborted", aborted_at: "args", reason: argProblems.join("; ") };
 
 const slug          = args.slug;
+// The report's path, never the ship command's one-line `detail`: that is a sub-agent's sentence, and
+// it reached the RunReturn's `report` field in place of the path the orchestrator opens. The
+// committed root is a fixed name, so the path is known without reading anything.
+const REPORT_PATH = `shapeup/${slug}/REPORT.md`;
 const KERNEL        = `${args.pluginRoot}/kernel/harness.mjs`;
 const execModel     = args.models.exec;
 const evalModel     = args.models.eval;
@@ -697,7 +701,7 @@ async function settleAtGateH(ret) {
     status: "shipped", verdict, rounds_used: round, after: "gate_h", breaker: ret.breaker ?? null,
     census: h.verdict, cut_list: h.cut_list, green_scopes: ret.green_scopes,
     unapplied_results: ret.unapplied_results || [], qa_findings: 0,
-    report: ship.detail || `shapeup/${slug}/REPORT.md`,
+    report: REPORT_PATH,
   });
 }
 
@@ -2012,7 +2016,7 @@ return await withWarnings({
   rounds_used: round,
   dims_not_evaluated: ALL_DIMS.filter((d) => !evalDims.includes(d)),
   qa_findings: qaFindings,
-  report: ship.detail || `shapeup/${slug}/REPORT.md`,
+  report: REPORT_PATH,
 });
 
 // =============================================================================================