shapeup-sdlc 3.1.1 → 3.2.0

package/skills/orient/SKILL.md

@@ -42,7 +42,8 @@ from `tech-lead`; it never reads or writes a shared run-state file.
 ## Input contract (pure worker)
 
 Orchestrated, you are invoked as `--order <path>` (a WorkOrder): `payload.pitch` (the
-kicked-off pitch path), `payload.stack` (sweep hint), `payload.spec_folder` (the SHARED spec
+kicked-off pitch path), `payload.breadboard` (the pitch's breadboard — Places, affordances, slices;
+absent = none separate), `payload.stack` (sweep hint), `payload.spec_folder` (the SHARED spec
 deliverable dir) and `payload.feature` (the run slug), plus `substrate.allowed` naming your one
 write surface — the orient output dir. Anything absent = unknown: confirm at GATE O-A
 (standalone) or report it in the result's `deviations`, never guess. Standalone, the
@@ -104,7 +105,8 @@ Confirm (do not guess):
       Shaped signal: frontmatter status: shaped AND bet: <S1|S2|...> (or equivalent).
       If the pitch lacks appetite AND solution boundaries → STOP and tell tech-lead:
         "Orient runs on a kicked-off pitch, not a raw idea. Shape/bet first (PO upstream)."
-  - breadboard.md path — read it if it exists; record "no breadboard" if absent
+  - breadboard — read `payload.breadboard` when present; absent means the pitch has no separate
+    breadboard — look for Places and affordance tables in the pitch itself
   - spec folder target (create orient/ if absent)
   - codebase root
 ```
@@ -136,7 +138,8 @@ Useful sweeps (adapt to the stack arg):
 ```
 
 Write `code-surface.md`: one row per pitch element → `file:line` it touches (or "NEW — no
-existing home"), the seam it extends, and whether it's new vs. existing. Flag every place the
+existing home"), the seam it extends, and whether it's new vs. existing. With a breadboard, each row
+carries the P#, U# or N# of the element it locates — a Place with no existing home is a NEW screen. Flag every place the
 map is uncertain — uncertainty is signal for Phase 3, not something to hide.
 
 > **Output location.** All four orient artifacts are run-trace (recon scratch), so they
@@ -257,7 +260,7 @@ Tech-lead uses this to render the GATE L1a Hill and confirm the spike before han
 ### Flags
 | Flag | Effect |
 |------|--------|
-| `--pitch <path>` | The kicked-off pitch (+ sibling `breadboard.md` if present) |
+| `--pitch <path>` | The kicked-off pitch. Read `payload.breadboard` when present; absent means the pitch has no separate breadboard — look for Places and affordance tables in the pitch itself |
 | `--spec <path>` | SHARED spec deliverable dir (shapeup/<feat>/spec/); orient *artifacts* are written to the LOCAL root `.shapeup/<feat>/orient/` |
 | `--stack <hint>` | Stack hint to aim the code-surface sweeps |
 | `--auto` | Auto-confirm O-A and O-B; run straight through |

package/skills/scope-architect/SKILL.md

@@ -21,6 +21,7 @@ the ship report's census table.
 |---|---|
 | `operation` | `map-scopes` — the only operation this skill has. It covers first slicing after the board exists, folding discovered items in, and re-slicing a stuck scope; the payload says which of those you are doing |
 | `payload.feature` / `payload.spec_folder` | Slug + committed spec (read ux-behavior.md for manifests; usecases for flows) |
+| `payload.breadboard` | When present, every U# the spec places is one manifest entry's `source`; record which scopes deliver each V# slice in `scope-board.md` (your write surface — `scope-summary.md` is the planner's) |
 | `payload.tasks[]` | The board's tasks with their touched files — the slicing INPUT only. Each carries `use_case_refs`; those UC ids are what you write into the contract. Never copy a task id into a contract |
 | `substrate.allowed` | `scopes/*.md` + `scope-board.md` — your ONLY write surface |
 
@@ -65,6 +66,8 @@ the ship report's census table.
                                                                element as {test_id, role} +
                                                                required_states [idle, loading,
                                                                success, error, empty]
+                                                               + `source` — the U# the
+                                                               ux-behavior row cites
              e2e_verification_fixtures[]                     — the command(s)/spec file(s)
                                                                that drive this scope
                                                                end-to-end (T0 layer); too
@@ -134,6 +137,7 @@ territory — and any lint warn left standing, with why). You never touch task f
 - [ ] Every scope that consumes another's output declares it in `depends_on`
 - [ ] Substrates disjoint except declared shared_substrate (DISJOINT = 0 red)
 - [ ] Every interactive element in scope screens appears in exactly one affordance_manifest
+- [ ] Every U# the spec places is some manifest entry's `source`
 - [ ] Every scope has fixtures or an explicit TBD flag
 - [ ] Every hill_phase written is UPHILL_UNKNOWN; superseded contracts kept
 - [ ] The WorkResult validates against `work-result.schema.json`

package/skills/solution-architect/SKILL.md

@@ -42,6 +42,7 @@ return as a WorkResult.
 |---|---|
 | `operation` | `wire` (author/refresh the wiring map after `analyze`, before `map-scopes`) |
 | `payload.feature` / `payload.spec_folder` | Slug + committed spec — read `usecases/` for the UCs and the engine each one needs, `domain-model.md`/`synthesis.md` for the module surface |
+| `payload.breadboard` | When present, name each UC's `affordance` by its U# and Place |
 | `payload.project_profile` | Path to the SHARED `project-profile.md`. Its `entry_point` is the composition root every engine must attach to — **archetype-specific** (a client-only game's `main.js` is not a web-service's `src/server.ts`). Read it; never guess the entry point |
 | `substrate.allowed` | `wiring-map.md` — your ONLY write surface (the spec core, scopes, and the profile are frozen) |
 
@@ -69,7 +70,9 @@ guessed `main.js` would make the later oracle certify nothing.
                                file:line is a build-time fact (the oracle proves reachability by
                                the import graph, it does not parse this field)
              affordance        the player-visible thing this UC exposes once wired (the human
-                               end of the chain — what a user can DO, not an internal call)
+                               end of the chain — what a user can DO, not an internal call);
+                               with a breadboard, name it by U# and Place —
+                               `U1 Pay (P1) → P2 Payment Sheet`
 3 WRITE    shapeup/<slug>/wiring-map.md (WiringMap): frontmatter for schema_version, feature
            and entry_point (echo of the profile), then entries[] as ONE MARKDOWN TABLE under a
            `## Wiring` heading — this exact shape, because it is the only one the reader parses:

package/skills/spec-evaluator/SKILL.md

@@ -37,7 +37,7 @@ Invoked as `--order <path>`. Fields you may rely on (absent = unknown, never inf
 | `payload.feature` | Feature slug — scopes the probe and names the report |
 | `payload.dimensions[]` | The active dimension set (the caller resolved precedence). Absent → `[spec-conformance]` + the auto-enable rules below |
 | `payload.run_cmd` | How to start the running app. Absent standalone → ask; absent orchestrated → ESCALATE, do not guess |
-| `payload.t0_artifacts[]` | Per-scope T0 verdict paths for this round (scoped specs). An artifact listed but missing/red on disk, or a scoped spec with none listed → the round is NOT gradeable: return `status: failed` naming the scope — a structural precondition, not a criterion |
+| `payload.t0_artifacts[]` | Per-scope T0 verdict paths for this round (scoped specs), compiled from each scope's green verdict. An artifact listed but missing/red on disk, or a scoped spec with none listed → the round is NOT gradeable: return `status: failed` with the reason, naming the scope, as your FIRST deviation — a structural precondition, not a criterion |
 | `payload.browser` | `cli` (default, ~4x cheaper) \| `mcp` \| `none` |
 | `payload.tasks[]` | Traceability only (which UCs a task claims): NEVER a grading source — the committed UC text is the criterion, a paraphrase mismatch is a finding |
 | `substrate.allowed` | Your only write surface: `.shapeup/<slug>/evaluation/**` (the report + evidence) |

package/skills/tech-lead/SKILL.md

@@ -23,7 +23,7 @@ turns fighting shell quoting):
 node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" init run \
   --slug <slug-from-the-request> --intake-file <path/to/the/requirement.md> \
   --auto-level <interactive|auto|unattended> \
-  [--dimensions <a,b>] [--gate-answers <ci|guarded|path.json>] [--wall-clock-budget <seconds>] [--max-rounds 3]
+  [--dimensions <a,b>] [--gate-answers <ci|guarded|path.json>] [--wall-clock-budget <seconds>] [--max-rounds 3] [--breadboard <path>]
 ```
 
 **After a compaction, or in a fresh session over an open run, re-derive before you act.** One
@@ -43,11 +43,11 @@ counts.
 plugin and need a one-time permission grant (`npx shapeup-sdlc init` writes it). Do not route
 around it, and do not silently hand-build the feature instead.
 
-**Language gate (delegated to `translator`, not this skill):** at GATE L0, before Step 2, dispatch
-an Agent (model: exec) that calls `Skill(shapeup-sdlc-plugin:translator) --check <intake>`.
-English → proceed as-is. Non-English → dispatch a second Agent (`--auto` under auto/unattended)
-and orchestrate against the produced `<name>.en.md`. The tech lead detects and sequences; it never
-translates itself.
+**Language gate (delegated to `translator`, not this skill):** before Step 1 opens the run, dispatch
+an Agent (model: exec) calling `Skill(shapeup-sdlc-plugin:translator) --check` on the pitch *and* its
+breadboard. English → proceed as-is. Non-English → a second Agent translates both (`--auto` under
+auto/unattended); Step 1 then names the `.en.md` files (a run already open on the original: re-open
+it with `--force` — nothing is dispatched yet). The tech lead detects and sequences; never translates.
 
 **Step 2 — pin GATE L0, then launch.** Collect the L0.1–L0.9 config (spec folder, lens, stack,
 eval dims, max_rounds, the model/budget matrix — see `references/gates.md` GATE L0 for the full

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

@@ -31,13 +31,19 @@ escalates, writes nothing, and every relaunch re-dispatches it.
 
 ```
 Collect (explicit — never inferred):
-  L0.1  Kicked-off pitch source: path to a shaping.md / pitch.md (already shaped + bet by PO).
+  L0.1  Kicked-off pitch source: `shaping.md` — and its `breadboard.md`, which the run finds
+          beside it (or in `shaping/`) or takes from `--breadboard`; a `pitch.md` may carry the
+          breadboard inline. Already shaped + bet by PO.
           Not a raw idea — shaping (1-4) / betting (5) / kick-off (6) are PO-personal, upstream.
-  L0.1a Language gate: Agent (model: exec) → Skill(shapeup-sdlc-plugin:translator) --check <intake>.
-          English      → use intake as-is.
-          non-English  → Agent (model: exec) → Skill(shapeup-sdlc-plugin:translator) <intake>
-                         (--auto under auto/unattended), then use the produced <name>.en.md as
-                         the ORIENT/MAP-SCOPES input. Log in ledger.
+  L0.1a Language gate, BEFORE init run: Agent (model: exec) → Skill(shapeup-sdlc-plugin:translator)
+          --check over the pitch AND its breadboard.
+          English      → use both as-is.
+          non-English  → Agent (model: exec) → Skill(shapeup-sdlc-plugin:translator) <pitch> <breadboard>
+                         (--auto under auto/unattended), then open the run on the produced
+                         <name>.en.md — init run prefers a breadboard.en.md beside it, and warns
+                         when it can find only the untranslated breadboard. The run's intake is
+                         what every planning worker reads, so a translation made after the run
+                         opened reaches nobody: re-open with --force naming the .en.md. Log in ledger.
   L0.1b Appetite: read the `appetite` field from the pitch's YAML frontmatter (set by /shapeup).
           Surface it in the gate output. Use it to:
             - Contextualise the scope at L1b (right-size cuts to the budget).
@@ -167,8 +173,9 @@ committing to a scope map. This is the first Hill read (area-level — slices do
 ```
 Read .shapeup/<slug>/orient/. Render the 🗻 Hill from hill-signal.md (see protocol.md "Hill report"):
   - each suspected area → uphill (open unknowns) | crest (approach proven by the spike) | downhill
-Print: the code-surface headline (where it lands), the spiked area + result, the riskiest
-       open unknowns going into mapping.
+Print: `Breadboard: <source> | none` (how init run found the pitch's breadboard — flag, sibling,
+       shaping-dir, shared-root, embedded — or none), the code-surface headline (where it lands),
+       the spiked area + result, the riskiest open unknowns going into mapping.
 Ask (max 2): is the riskiest area the right one to have spiked? any unknown that must be
              resolved (another spike) before we map scopes?
 ```
@@ -186,7 +193,7 @@ Do NOT enter MAP SCOPES until Orient is accepted.
    mobile|library|data-pipeline}; entry_point is the reachability seam (a game's main.js is NOT a
    service's src/server.ts). Validate the enum — a typo must fail, not silently disable the check.
 2. WIRE — compile-order --operation wire --slug <slug> (worker→solution-architect), payload
-   {project_profile}. Sole writer of committed wiring-map.md (per-UC engine → seam → entry-point
+   {project_profile, breadboard?}. Sole writer of committed wiring-map.md (per-UC engine → seam → entry-point
    call site → affordance). ⏸ GATE L1a.5: confirm each UC has a declared seam before slicing.
    ⟐ PRECONDITION: MAP SCOPES step 1 (ANALYZE) has already run and usecases/ is
    populated. WIRE writes one entry per use case, so dispatching it against an empty spec folder
@@ -212,7 +219,7 @@ against the seams WIRE declared. Sequence: ORIENT → L1a → **ANALYZE** → **
 ```
 Two orders, two workers, one step (both model: exec — see references/protocol.md):
 1. ANALYZE + BOARD — compile-order --operation analyze --slug <slug> --worker ba-pitch-analyzer
-     --payload '{"pitch": "<path>", "lens": "<lens>", "orient_dir": ".shapeup/<slug>/orient/"}'
+     --payload '{"pitch": "<path>", "breadboard": "<the path init run printed, when it printed one>", "lens": "<lens>", "orient_dir": ".shapeup/<slug>/orient/"}'
    dispatch: Skill(shapeup-sdlc-plugin:ba-pitch-analyzer) --order <path>. The order hands it
    code-surface.md (Phase-1 ingest consumes the map, does not re-scan), discovered-seed.md
    (task gen starts from reality), spike-<area>.md (feasibility/contracts).
@@ -265,6 +272,8 @@ Scope contracts present:
     - scope board: scope_id, topology_type, substrate file count (scopes/*.md / scope-board.md)
     - any SPIKE blockers (scope-summary.md)
     - scope-summary "Done when" headline statements
+    - the Deferred Places from ux-behavior.md (breadboard Places this shape will not build) —
+      each one needs the PO's yes; a rejected deferral goes back to the planner as a screen
 No scope contracts (pre-v0.3.0, unchanged from v0.2.6):
   Read tasks/_index.md (LOCAL root). Print:
     - task count by package/variant (.shared / .be / .web / .mobile / .e2e)
@@ -280,7 +289,11 @@ this is the orchestrator's own re-confirmation before committing to a build sequ
     waiting to happen), PA1 (directory-aligned scope), PA2 (size cap), SCOPE-ANCHOR (a scope
     naming no committed use case, or one that does not resolve), TIER-DIRECTION (a committed
     contract naming LOCAL task ids), SCOPE-DEPS (a build-order id naming a scope that is not
-    in this run). Any red → HARD STOP, past a 🔴 at the architect's own checkpoint.
+    in this run), BREADBOARD-PLACE (a breadboard Place with UI affordances has no
+    `## Screen: … (P#)` in ux-behavior.md and is not deferred), BREADBOARD-UI (a U# not
+    specified on a screen of its own Place). Any red → HARD STOP, past a 🔴 at the
+    architect's own checkpoint. The breadboard reds are the planner's to fix — add the screen
+    or defer the Place; never fold it into another screen.
   - Lock the build SEQUENCE riskiest-first: order scopes by open-unknowns count (from
     hill/<scope-id>.yml if present, else the orient hill signal), not by file count or
     alphabetical — Shape Up's "solve in the right sequence" (step 10).
@@ -414,7 +427,8 @@ S.6  Harvest one signal row → append to `.shapeup/metrics/<machine-id>.jsonl`
      deliberately without colliding on one filename. The read plane is
      `harness probe stats`, or `cat .shapeup/metrics/*.jsonl`).
      Copy fields that ALREADY exist as structured output (run-state, final EVAL report,
-     discovery ledger, qa/hunt-report, breadboard B5). Two hard rules:
+     discovery ledger, qa/hunt-report, and the receipt's `breadboard.ids.V` for `slice_count` —
+     the slices init run counted in the staged breadboard, never a hand copy). Two hard rules:
        1. Harvest only fields that already exist at ship time — never evaluate something new.
        2. Record facts, never compute a new verdict (no `run_quality_score` — that would be
           a second judge behind spec-evaluator). The eval suite interprets; harvest records.

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

@@ -311,14 +311,15 @@ workers keep only their own product-idempotency key and emit domain artifacts.
 
 ## 0. LANGUAGE GATE → translator (GATE L0, only if non-English)
 ```
-Invoke via Agent (model: exec): Skill(shapeup-sdlc-plugin:translator) --check "<intake path>"
+Invoke via Agent (model: exec), BEFORE init run: Skill(shapeup-sdlc-plugin:translator) --check "<intake path>" "<breadboard path>"
                  # detect-only, writes nothing
   English      → skip; ORIENT against the original.
-  non-English  → Agent (model: exec): Skill(shapeup-sdlc-plugin:translator) "<intake path>" [--auto]
-                 # full pass
-                 Writes: <name>.en.md (English copy; original untouched) + glossary.md
+  non-English  → Agent (model: exec): Skill(shapeup-sdlc-plugin:translator) "<intake path>" "<breadboard path>" [--auto]
+                 # full pass — the pitch AND its breadboard, before init run
+                 Writes: <name>.en.md per file (English copy; original untouched) + glossary.md
                          + translation-report.md.
-                 ORIENT against the <name>.en.md copy.
+                 Open the run on the .en.md pitch: init run stages breadboard.en.md beside it,
+                 and every planning worker reads what init run pinned — never a later copy.
 Read back: the detect table (--check) / the .en.md path + residual scan result (full pass).
 Authority: translator normalizes language only — it does not orient/plan/build/judge. The tech
 lead never translates itself; it only detects and sequences this step before ORIENT.
@@ -340,7 +341,7 @@ Authority: pure worker — no code, no board, no run-state, no reporting.
 ```
 Order A (the spec tree + board):
   compile-order --operation analyze --slug <slug> --worker ba-pitch-analyzer
-    --payload '{"pitch": "<path>", "lens": "<lens>", "orient_dir": ".shapeup/<slug>/orient/"}'
+    --payload '{"pitch": "<path>", "breadboard": "<the path init run printed, when it printed one>", "lens": "<lens>", "orient_dir": ".shapeup/<slug>/orient/"}'
   Agent (model: exec): Skill(shapeup-sdlc-plugin:ba-pitch-analyzer) --order <path>
   The order hands it code-surface.md (Phase-1 ingest, no re-scan), discovered-seed.md (task
   gen from reality), spike-<area>.md (feasibility/contracts).
@@ -465,7 +466,9 @@ Read back: the stdout JSON — {path, sha256, trial, overall, regression, score,
 ## 4. EVAL → spec-evaluator (once per round)
 ```
 compile-order --operation evaluate --slug <slug> --worker spec-evaluator --round <r>
-  --payload '{"dimensions": ["spec-conformance"], "run_cmd": "<cmd>", "t0_artifacts": [...]}'
+  --payload '{"dimensions": ["spec-conformance"], "run_cmd": "<cmd>"}'
+  t0_artifacts is compiled from each scope's green T0 verdict for round <r> — pass it only to
+  override. A scope with no green verdict is named on stderr: the judge has nothing to cite for it.
 Invoke via Agent (model: eval), ONCE, after GATE L2:
   Skill(shapeup-sdlc-plugin:spec-evaluator) --order <path>
 Effect: one feature-level pass over the running app against all AC + Done-when; writes
@@ -473,6 +476,8 @@ Effect: one feature-level pass over the running app against all AC + Done-when;
         verdicts, refuted boxes, T0 citations). It touches NO task file and NO board.
 ingest-result <results/evaluate-r<r>.json>: appends the .verdicts JSONL ledger, un-ticks the
         refuted AC boxes, sets eval_verdict frontmatter — the judge returns data, ingest writes.
+        A verdict on a scoped spec that cites no T0 artifact is refused and the round stays
+        open: re-dispatch the evaluator, do not advance the round.
 Read back: EVAL-FEATURE-<slug>.md → verdict (pass|fail) + the bug list (each bug has
         task ref, severity, file:line, expected vs actual).
 ```
@@ -822,7 +827,7 @@ fixtures run in isolation and do not consume it.
 | `spike_unresolved_count` | `SPIKE-UNRESOLVED` markers at bet | shaping quality — open risk into bet |
 | `scope_cut_count` | `~` items cut at SHIP S.0 | appetite pressure / scope hammer |
 | `qa_findings` | `.shapeup/<slug>/qa/hunt-report.md` + triage → `{total, promoted, held}` | edge quality |
-| `slice_count` | breadboard B5 (≤9) | **normalizer / denominator** |
+| `slice_count` | `receipt.json` → `breadboard.ids.V` (the V# slices init run counted in the staged breadboard; omit the field when `breadboard` is null) | **normalizer / denominator** |
 | `sources` | path to each **SHARED** source artifact — never a LOCAL `.shapeup/` path (the run-trace is superseded run by run, so a LOCAL path dangles by the time anyone reads the row; SHARED paths resolve on any clone — tier-direction rule) | auditability |
 
 - `slice_count` is the **denominator**: `round_count=4` on a 2-slice feature is alarming,

package/skills/tech-lead/schemas/domain.schema.json

@@ -314,6 +314,7 @@
     ],
     "ba-pitch-analyzer": [
       "pitch",
+      "breadboard",
       "lens",
       "orient_dir",
       "spec_folder",
@@ -324,12 +325,14 @@
     "scope-architect": [
       "feature",
       "spec_folder",
-      "tasks"
+      "tasks",
+      "breadboard"
     ],
     "solution-architect": [
       "feature",
       "spec_folder",
-      "project_profile"
+      "project_profile",
+      "breadboard"
     ],
     "spec-evaluator": [
       "spec_folder",
@@ -342,6 +345,7 @@
     ],
     "orient": [
       "pitch",
+      "breadboard",
       "stack",
       "spec_folder",
       "feature"
@@ -709,6 +713,10 @@
             "type": "string"
           },
           "description": "Subset of [idle, loading, success, error, empty] the element must express via data-state."
+        },
+        "source": {
+          "type": "string",
+          "description": "The breadboard UI affordance (U#) this element implements; absent without a breadboard."
         }
       }
     },
@@ -2248,6 +2256,10 @@
           "type": "string",
           "description": "ba-pitch-analyzer (analyze) / orient: the kicked-off pitch path (shaped + bet; frontmatter appetite/status/bet)."
         },
+        "breadboard": {
+          "type": "string",
+          "description": "orient / ba-pitch-analyzer (analyze) / solution-architect / scope-architect: the run's staged breadboard — Places (P#), UI and code affordances (U#, N#), stores (S#), slices (V#). Absent = the pitch has no separate breadboard (it may carry one inline); never inferred from the pitch's folder."
+        },
         "lens": {
           "type": "string",
           "enum": [
@@ -2379,6 +2391,20 @@
           "type": "string",
           "description": "Resolved path to the run's intake — the pitch a fresh ORIENT dispatch is compiled against."
         },
+        "breadboard_path": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "Resolved path to the run's staged breadboard (`.shapeup/<slug>/breadboard.md`), the pitch's second half, handed to the four planning dispatches as payload.breadboard. Null when the pitch had no separate breadboard file."
+        },
+        "breadboard_source": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "How `init run` found the breadboard — flag | sibling | shaping-dir | shared-root | embedded — read from the receipt. Null when there was none or the receipt is unreadable."
+        },
         "spec_folder": {
           "type": [
             "string",
@@ -2512,7 +2538,7 @@
           "items": {
             "type": "integer"
           },
-          "description": "Round numbers with an evaluate-r<n>.json result — the resumed run's round counter starts one past the maximum."
+          "description": "Round numbers whose evaluate-r<n>.json holds a verdict the run may act on (PASS/FAIL, citing T0 artifacts when the spec is scoped) — the resumed run's round counter starts one past the maximum. A refused or uncited round is not done: the relaunch re-enters it."
         },
         "next_phase": {
           "type": "string",

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

@@ -400,6 +400,7 @@ const RESUME = {
   type: "object",
   properties: {
     intake_path: nullable("string"), spec_folder: nullable("string"), orient_dir: nullable("string"),
+    breadboard_path: nullable("string"), breadboard_source: nullable("string"),
     project_profile_path: nullable("string"), status: nullable("string"),
     lens: nullable("string"), stack: nullable("string"),
     run_cmd: nullable("string"), app_url: nullable("string"),
@@ -560,6 +561,10 @@ const EVAL_VERDICT = {
     bug_count: nullable("integer"),
     report_path: nullable("string"),
     round: { type: "integer" },
+    // Why the round holds no verdict it may act on — the evaluator's own first deviation when it
+    // refused, or what is structurally wrong with the verdict it returned. Null when `ok`.
+    status: nullable("string"),
+    reason: nullable("string"),
   },
   required: ["ok", "round"],
 };
@@ -968,7 +973,7 @@ if (!rs.has_orient_artifacts) {
   await setRunStatus("orienting", "Orient");
   const o = await worker({
     skill: "orient", operation: "orient", schema: ORIENT, phase: "Orient", label: "orient",
-    payload: { pitch: rs.intake_path, spec_folder: specFolder, feature: slug, stack: rs.stack },
+    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
     // `code-surface-map.md` and `discovered-tasks.md` aborted the run at the post-condition, having
@@ -994,8 +999,10 @@ if (!rs.has_orient_artifacts) {
 }
 
 {
+  // `breadboard` travels in the block because a missing one is invisible anywhere later: every
+  // downstream artifact reads the same whether or not the pitch's second half reached the run.
   const g = await crossGate("L1a", "Orient", ["proceed", "ask", "abort"],
-    { spiked_area: spikedArea, spike_result: spikeResult, riskiest_unknowns: riskiest });
+    { breadboard: rs.breadboard_source ?? "none", spiked_area: spikedArea, spike_result: spikeResult, riskiest_unknowns: riskiest });
   if (g.stop) return withWarnings(g.stop);
 }
 
@@ -1011,7 +1018,7 @@ if (!rs.has_spec_tree) {
   await setRunStatus("mapping", "Analyze");
   const a = await worker({
     skill: "ba-pitch-analyzer", operation: "analyze", schema: PHASE_OK, phase: "Analyze", label: "analyze",
-    payload: { pitch: rs.intake_path, spec_folder: specFolder, feature: slug, lens: rs.lens, orient_dir: rs.orient_dir },
+    payload: { pitch: rs.intake_path, breadboard: rs.breadboard_path, spec_folder: specFolder, feature: slug, lens: rs.lens, orient_dir: rs.orient_dir },
     extra: "Write the spec tree and the board from the orient artifacts — do not re-scan the code.",
   });
   if (a.__failed) return diedAt("ANALYZE", a);
@@ -1043,7 +1050,7 @@ if (!rs.has_wiring_map) {
   log(`WIRE — dispatching (slug ${slug})`);
   const w = await worker({
     skill: "solution-architect", operation: "wire", schema: PHASE_OK, phase: "Wire", label: "wire",
-    payload: { feature: slug, spec_folder: specFolder, project_profile: rs.project_profile_path },
+    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.",
   });
   if (w.__failed) return diedAt("WIRE", w);
@@ -1074,7 +1081,7 @@ if (scopes.length === 0) {
   log(`MAP SCOPES — dispatching (slug ${slug})`);
   const m = await worker({
     skill: "scope-architect", operation: "map-scopes", schema: MAPSCOPES, phase: "MapScopes", label: "map-scopes",
-    payload: { feature: slug },
+    payload: { feature: slug, breadboard: rs.breadboard_path },
     // SAY THE PASS RULE, for the same reason ORIENT's filenames are named above: the rule lives in
     // `verify t0` (a fixture passes iff it exits 0) and the architect never saw it. Given a contract
     // that said only "commands that drive this scope end-to-end", it wrote the scope's error paths
@@ -1159,11 +1166,13 @@ if (waves.length > 1 || excluded.added || ceiling < maxParallelScopes) {
       `${ceiling < maxParallelScopes ? ` (the window is ${maxParallelScopes}; the substrate the contracts declared is what caps it, not the dial)` : ""}`);
 }
 
-// Advisory lints at L1b. spec-lint is hard — a substrate overlap makes parallel builds unsafe;
-// trace-lint stays advisory until `covers:` is populated; hill-derive is a projection.
+// Advisory lints at L1b. spec-lint is hard — a substrate overlap makes parallel builds unsafe, and
+// a breadboard Place with no screen builds the wrong thing; trace-lint stays advisory until
+// `covers:` is populated; hill-derive is a projection. The abort names no cause of its own: spec-lint
+// has more than one kind of red, and the detail says which.
 const specLint = await cmd(`verify spec --slug ${slug}`, "MapScopes", "spec-lint");
 if (!specLint.ok) {
-  return aborted("L1b", `spec-lint reported a disjointness or size problem before BUILD: ${specLint.detail || `exit ${specLint.exit_code}`}`);
+  return aborted("L1b", `spec-lint reported red findings before BUILD: ${specLint.detail || `exit ${specLint.exit_code}`}`);
 }
 await advisory(`verify trace --slug ${slug} --quiet`, "MapScopes", "trace-lint");
 await advisory(`reduce hill --slug ${slug}`, "MapScopes", "hill-derive");
@@ -1358,14 +1367,22 @@ while (verdict !== "pass" && round <= maxRounds) {
     const e = await worker({
       skill: "spec-evaluator", operation: "evaluate", schema: EVAL, phase: "Eval", label: `eval:r${round}`,
       model: evalModel, round,
+      // No `t0_artifacts` here, deliberately: `harness compile` derives them from the round's green
+      // T0 verdicts on disk, for every lane — this script could only name paths it was told about.
       payload: { dimensions: evalDims, run_cmd: rs.run_cmd, round },
-      extra: "Evaluate the running feature against every acceptance criterion and Done-when. One feature-level pass; cite the T0 artifact you re-hash yourself.",
+      extra: "Evaluate the running feature against every acceptance criterion and Done-when. One feature-level pass; cite every artifact the order lists under t0_artifacts, re-hashing each yourself.",
     });
     if (e.__failed) return diedAt("L3", e);
     // The pass/fail branch is decided from the WorkResult on disk, not from the dispatching
     // agent's own summary of it (`e.overall`) — see EVAL_VERDICT's comment for why.
     const ev = await query(`probe eval --slug ${slug} --round ${round}`, EVAL_VERDICT, "Eval", `verdict:r${round}`);
-    if (!ev || !ev.ok || !ev.overall) return diedAt("L3", nullFail(`verdict:r${round}`));
+    if (!ev) return diedAt("L3", nullFail(`verdict:r${round}`));
+    // A round with no verdict to act on is NOT a dead worker. An evaluator that refused the round
+    // wrote a result saying why, and `probe eval` carries it as `reason`; reported as "died after
+    // retries", the one sentence naming the cause stayed in a file nobody was pointed at.
+    if (!ev.ok || !ev.overall) {
+      return diedAt("L3", { __failed: `verdict:r${round}: no verdict this round can act on — ${ev.reason || `status ${ev.status || "unknown"}`}` });
+    }
     verdict = ev.overall === "PASS" ? "pass" : "fail";
     findings = e.findings || [];
   }