shapeup-sdlc 3.18.0 → 3.18.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shapeup-sdlc-plugin",
   "displayName": "ShapeUp SDLC Plugin",
-  "version": "3.18.0",
+  "version": "3.18.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/AGENTS.md

@@ -10,7 +10,7 @@ Skills and commands are named short throughout this file; every one of them reso
 - Hook-denied: dispatching a worker without a schema-valid WorkOrder, writing outside the scope's substrate, writing the result of a live order your own dispatch did not take, writing a committed file whose text names a run-trace path or a board id, stopping a run with no receipt (the run's first act writes one).
 - **The tier-direction rule is refused at the write, not argued at L1b.** A committed file cannot carry a `.shapeup/` path or a `TASK-NNN` id — boards renumber per machine and the run trace is gitignored, so either one resolves only where it was written. Spec-lint has always red'd this at Board Review; the same rule now also refuses the write itself, naming the token, because four producers hit it and one of them hit it twice in one session — a worker carries no lesson across a dispatch, and by L1b the phase that wrote the line is over. The knowledge base is outside the rule: those files are instructions, not references anyone resolves.
 - Attested, not assumed: a dispatch leaves a receipt naming the skill that ran, and ingest refuses an orchestrated result that has none. A dispatch that fails is answered by the sub-agent improvising the craft, which every other check accepts — so "the artifact exists" is not evidence that the shipped skill produced it. `--no-receipt-check` is the way through when the receipt channel itself fails.
-- **The single writer is asked, never assumed.** A dispatch's result is applied by exactly one act — the ingest step — and that act leaves a leg row. Every phase post-condition and every settled build scope asks the leg ledger whether the row exists before any verdict on the phase or the scope, whatever the worker reported: a result on disk that nothing applied is ingested there if the scope is green, and otherwise named at the close as `unapplied_results=N`, never folded into "not green". A round that ends with nothing green names `breaker=none` and `stalled=no_green` unless the attested attempt census says a scope tripped — the close cannot name a breaker the census denies. The run graph carries a `Leg` node with an `INGESTED` edge from its `Result`, and the export a `leg` table, so "which results were never read" is one query.
+- **The single writer is asked, never assumed.** A dispatch's result is applied by exactly one act — the ingest step — and that act leaves a leg row. Every phase post-condition and every settled build scope asks the leg ledger whether the row exists before any verdict on the phase or the scope, whatever the worker reported: a planning leg that left its artifacts and no result at all is dispatched again once, told its artifacts stand; a result on disk that nothing applied is ingested there if the scope is green, and otherwise named at the close as `unapplied_results=N`, never folded into "not green". A round that ends with nothing green names `breaker=none` and `stalled=no_green` unless the attested attempt census says a scope tripped — the close cannot name a breaker the census denies. The run graph carries a `Leg` node with an `INGESTED` edge from its `Result`, and the export a `leg` table, so "which results were never read" is one query.
 - GATE L2 is advisory — warns when EVAL runs over unfinished tasks, permits the call (per-machine board, operator asked; ADR-0001) — a signal, not a bug.
 - Sign-off is a file: each gate resolves from the answer set (`ci`/`guarded`/`interactive`) — cross, stop for the PO, or abort; the decision's source is ledgered.
 - **Every ending a run does not come back from records a close** — its status, its cause and its timestamp — derived from the ending itself rather than from a hand-kept pair, so an ending nobody enumerated cannot silently record nothing. The same close derives the ledger's verdict, its round count and its Rounds and Decisions tables from the run's own records — the ones the export reads — so the file a teammate opens first cannot contradict its own close line. A breaker trip that routes to GATE H closes the run as `escalated`, carrying the breaker in its cause; a pause records no close **by design**, because a relaunch resumes it. A relaunch that resumes a run which *did* close reopens it on the record: the earlier close is kept under `prior_closes`, the close fields clear, the run pointer the close retired comes back (so the resumed run's hook decisions carry its key again), and the run's next ending is recorded as its own — so a run that aborted, was resumed and then shipped reads `shipped` with the abort beside it, never an abort under a `shipped` status. Opening a run over one that closed says it is closed, not open.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shapeup-sdlc",
-  "version": "3.18.0",
+  "version": "3.18.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/workflows/shapeup-run.js

@@ -1017,10 +1017,22 @@ const attest = (phaseKey, phaseName, label) =>
  * @returns {Promise<(object|null)>} An aborted RunReturn, or null when the leg closed (or the
  *   question could not be asked — a probe that did not run proves nothing, and is logged as such).
  */
-async function requireLeg(gate, phaseKey, phaseName, orderStem = phaseKey) {
+async function requireLeg(gate, phaseKey, phaseName, orderStem = phaseKey, again = null) {
   const ask = () => query(`probe leg --slug ${slug} --order "${orderStem}"`, ORDERLEG, phaseName, `legcheck:${orderStem}`);
   let leg = await ask();
   if (!leg || !leg.found) { log(`${gate} — could not ask the leg ledger about "${phaseKey}" (probe returned ${leg ? "no order" : "nothing"}); proceeding on the artifact alone.`); return null; }
+  // SENT BACK ONCE FOR THE ENVELOPE. A dispatched leg that wrote its artifacts and no WorkResult has
+  // done the craft and skipped the last step, and it recurs on the same phase run after run. The
+  // worker is dispatched again with the reason, told its artifacts stand; only a second miss is named
+  // at the close.
+  if (!leg.has_result && leg.has_receipt && again) {
+    log(`${gate} — "${phaseKey}" was dispatched and returned no WorkResult; sending it back once for the envelope.`);
+    await again(` Your previous dispatch of this order wrote the phase's artifacts and returned NO WorkResult. ` +
+      `The artifacts are on disk and stand: do not redo them. Write the WorkResult the order names ` +
+      `(its substrate's own results path), then ingest it as the steps above say.`);
+    leg = await ask();
+    if (!leg || !leg.found) return null;
+  }
   if (!leg.has_result) {
     // The artifact is on disk and the envelope never came back. Measured live: the first dispatch of
     // a run wrote its four artifacts and no WorkResult, every later phase read the artifacts, and
@@ -1055,9 +1067,9 @@ async function requireLeg(gate, phaseKey, phaseName, orderStem = phaseKey) {
  * @param {string} phaseName - Progress group.
  * @returns {Promise<(object|null)>} An aborted RunReturn, or null when the artifact is there.
  */
-async function requirePhase(gate, phaseKey, phaseName, orderStem = phaseKey) {
+async function requirePhase(gate, phaseKey, phaseName, orderStem = phaseKey, again = null) {
   const r = await attest(phaseKey, phaseName, `require:${phaseKey}`);
-  if (r.exit_code === 0) return await requireLeg(gate, phaseKey, phaseName, orderStem);
+  if (r.exit_code === 0) return await requireLeg(gate, phaseKey, phaseName, orderStem, again);
   // Exit 6 is `probe resume --require`'s OWN documented code for "the artifact really is not on
   // disk" (kernel/probe/resume.mjs banner). Any other value — including -1, the courier's sentinel
   // for a tool call that never ran — is not that predicate answering "no"; it is the predicate never
@@ -1381,8 +1393,8 @@ let spikedArea = "~", spikeResult = "~", riskiest = [];
 if (!rs.has_orient_artifacts) {
   log(`ORIENT — dispatching (slug ${slug})`);
   await setRunStatus("orienting", "Orient");
-  const o = await worker({
-    skill: "orient", operation: "orient", schema: ORIENT, phase: "Orient", label: "orient",
+  const dispatchOrient = (note = "") => worker({
+    skill: "orient", operation: "orient", schema: ORIENT, phase: "Orient", label: note ? "orient:again" : "orient",
     payload: { pitch: rs.intake_path, breadboard: rs.breadboard_path, spec_folder: specFolder, feature: slug, stack: rs.stack },
     // NAME THE FILES. "write the orient/ artifacts" was the whole instruction, while completion is
     // decided by four exact filenames — so a leg that did the work and called its output
@@ -1396,10 +1408,11 @@ if (!rs.has_orient_artifacts) {
       "named exactly: `code-surface.md`, " +
       "`discovered-seed.md`, `hill-signal.md`, and one `spike-<area>.md` (or `spike-not-needed.md` " +
       "when the risk scan came back rank 0). Any other filename leaves the phase incomplete and " +
-      "the run aborts, however good the contents are.",
+      "the run aborts, however good the contents are." + note,
   });
+  const o = await dispatchOrient();
   if (o.__failed) return await withWarnings(diedAt("ORIENT", o));
-  const post = await requirePhase("ORIENT", "orient", "Orient");
+  const post = await requirePhase("ORIENT", "orient", "Orient", "orient", dispatchOrient);
   if (post) return await withWarnings(post);
   await advisory(`reduce graph --slug ${slug}`, "Orient", "graph:orient");
   spikedArea = o.spiked_area; spikeResult = o.spike_result; riskiest = o.riskiest_unknowns || [];
@@ -1521,13 +1534,14 @@ if (!rs.has_wiring_map) {
       `resolve against. Write the profile, then relaunch.`));
   }
   log(`WIRE — dispatching (slug ${slug})`);
-  const w = await worker({
-    skill: "solution-architect", operation: "wire", schema: PHASE_OK, phase: "Wire", label: "wire",
+  const dispatchWire = (note = "") => worker({
+    skill: "solution-architect", operation: "wire", schema: PHASE_OK, phase: "Wire", label: note ? "wire:again" : "wire",
     payload: { feature: slug, spec_folder: specFolder, project_profile: rs.project_profile_path, breadboard: rs.breadboard_path },
-    extra: "Write the wiring map: per use case, engine → seam → entry-point call site → affordance.",
+    extra: "Write the wiring map: per use case, engine → seam → entry-point call site → affordance." + note,
   });
+  const w = await dispatchWire();
   if (w.__failed) return await withWarnings(diedAt("WIRE", w));
-  const post = await requirePhase("WIRE", "wire", "Wire");
+  const post = await requirePhase("WIRE", "wire", "Wire", "wire", dispatchWire);
   if (post) return await withWarnings(post);
   await advisory(`reduce graph --slug ${slug}`, "Wire", "graph:wire");
 } else {