shapeup-sdlc 3.1.2 → 3.3.0

package/skills/scope-hammer/SKILL.md

@@ -56,6 +56,14 @@ INPUT: run's finished/unfinished scopes + baseline + census sources
 piecemeal — a partial view produces a wrong cut.
 
 ```
+H0.0  Ownership is DERIVED, never stated. Before the census says "no scope owns X" or "X is
+      scope Y's", run
+        node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe owner --slug <slug> [--path <p>]...
+      and cite its row. With no --path it answers for every engine and entry call site the wiring
+      map names plus the profile's entry point; `writers: []` is an unowned seam and `missing`
+      lists seams the wiring names that are not on disk — owned but never written. A census that
+      narrated ownership from memory once told the PO no scope owned a screen directory that a
+      committed contract listed in plain sight — and pointed the ship decision at the wrong gap.
 H0.1  Unresolved scopes (breaker cases only):
         - uphill/downhill scopes when round_budget hit 0 → CARRY candidates (their own hill
           phase + open unknowns, from hill/<scope-id>.yml)
@@ -160,6 +168,10 @@ The WorkResult may carry only `files_touched`, `artifacts`, `assumptions`, `devi
 
 # Headless — no PO available; still refuses to auto-ship a ship-blocking item
 /scope-hammer --slug checkout-vnpay --unattended
+
+# The ownership query every census claim cites (H0.0)
+node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe owner --slug checkout-vnpay --format table
+node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe owner --slug checkout-vnpay --path src/pages/Cart.ets
 ```
 
 ### Flags
@@ -181,6 +193,7 @@ The WorkResult may carry only `files_touched`, `artifacts`, `assumptions`, `devi
 | Default classification is NICE-TO-HAVE unless traced to a pitch boundary or business_goal | A generous must-have list defeats the point of hammering |
 | A MUST-HAVE that fails H1.2 is never cut silently | The one case where scope-hammer refuses to make the run "look" shippable |
 | Cuts are proposals; the PO confirms every one | This skill never overrides the human at the ship gate |
+| Every ownership claim in the census cites `harness probe owner` | Ownership is what the contracts' substrates say — the same election `harness compile` uses to address a bug — never what the report remembers |
 | Cut items are carried to the discovery ledger, never silently dropped | Cool-down must stay debt-free — an idea deferred is still recorded |
 | Never sets status: done, never deploys, never ships unilaterally | Judge/doer/advisor separation holds even at the very last gate |
 | An overridden ship-blocking item is logged explicitly in the ship report | "Shipped" must never quietly mean "shipped with a known must-have gap" |

package/skills/solution-architect/SKILL.md

@@ -42,6 +42,8 @@ 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.kb_rules_path` | Team guidelines (read if the file exists) — the seams this codebase actually wires through, entry points that are not where the template says. Steering, never spec: the profile's `entry_point` still wins, and a guideline that disagrees with it is reported in `deviations`, not applied |
 | `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) |
 
@@ -52,7 +54,8 @@ guessed `main.js` would make the later oracle certify nothing.
 ## Core process
 
 ```
-1 READ     the project profile → entry_point + archetype. Read every use case in usecases/.
+1 READ     the team guidelines at payload.kb_rules_path if the file exists (absent = none),
+           then the project profile → entry_point + archetype. Read every use case in usecases/.
            For each UC, identify the engine module that carries its core logic (the file that
            WILL exist, named from the domain model / synthesis surface — not a guess at a folder).
 2 DESIGN   for each UC, design the integration path from the entry_point inward:
@@ -69,7 +72,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/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,13 +43,13 @@ 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,
+**Step 2 — pin GATE L0, then launch.** Collect the L0.1–L0.10 config (spec folder, lens, stack,
 eval dims, max_rounds, the model/budget matrix — see `references/gates.md` GATE L0 for the full
 collect-list), write the SHARED `project-profile.md` yourself (`{schema_version:1, archetype,
 entry_point}` — `shapeup-run.js` has no filesystem of its own), emit the `⏸ GATE L0` block, then

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).
@@ -90,6 +96,21 @@ Collect (explicit — never inferred):
         same GATE H proposal. attempt_budget counts ATTEMPTS and cannot see that the last two
         produced nothing; this term can, and on a flailing scope it saves three of five
         attempts. Set per scope (`no_progress_k` on the contract) or per run in the payload.
+  L0.10 knowledge base (read, never obeyed): if `shapeup/knowledge-base/tech-lead.md` exists,
+        read it now. Its **Workflow guidance** may add a question, a check or a warning line to
+        any gate block below and may name the spike to insist on at L1a; its **Suggested run
+        config** lines are PROPOSALS for L0.2–L0.9 and the profile — confirm each with the PO
+        before pinning it, and record `(source: knowledge-base)` beside a value taken from there.
+        Nothing in that file answers a gate: the answer set resolves exactly as it would without
+        it, and a line that could only be honoured by skipping, reordering or relaxing a gate is
+        reported as a suspected harness defect, not applied. If `shapeup/knowledge-base/` has no
+        file at all, offer the optional seed once — `/retro --scan` (the coach's scan operation)
+        drafts guidelines from the project on disk, or `/retro --research <stack>` (its
+        research operation) from the platform's official documentation when the project has no
+        build file to scan; both put every rule through GATE COACH-1 — and continue whether or
+        not the PO takes it. A Suggested run config line with `web-research` provenance has
+        never run in this project: confirm it like any other, and expect the first round build
+        gate to be its first execution.
 ```
 
 **L0.9b — the launch record.** Every switch the operator typed becomes a `RunArgs` field, or it
@@ -134,9 +155,11 @@ Intake lang  : [English | translated via /translator → <name>.en.md]
 Appetite     : [~1 week | ~2 weeks | ~6 weeks | ⚠️ missing — scope uncapped]
 Spec folder  : [path]   (lens: [lite|standard])
 Eval dims    : [spec-conformance]   max_rounds: [N, appetite-informed]   auto: [interactive|auto|unattended]
-Run commands : [web: ... | api: ... | mobile: ...]
+Run commands : [web: ... | api: ... | mobile: ...]   (run_cmd → the round build gate, every round before EVAL)
+Build gate   : build_probe [set | —]   launch_probe [set | — ⚠ mobile: the install/launch risk has no owner]
 Model matrix : orch=[model] exec=[model] eval=[model] qa=[model] digester=[script|sonnet]  (source: [flags|settings.local|settings.json|default])
 Budgets      : round_budget=[N] (outer)   attempt_budget=[N] (inner, per scope)
+Knowledge    : [tech-lead.md — N workflow rules, M suggested values (confirmed above) | none — `/retro --scan` or `/retro --research <stack>` seeds it (optional)]
 ```
 Do NOT start ORIENT until confirmed (interactive/auto). Under --unattended, proceed.
 
@@ -167,8 +190,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?
 ```
@@ -182,11 +206,17 @@ Do NOT enter MAP SCOPES until Orient is accepted.
 
 ```
 1. PROFILE (you write it at L0 — compile-order stays pipeline-blind): SHARED project-profile.md
-   = {schema_version:1, archetype, entry_point}. archetype ∈ {client-only-game|web-service|
-   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.
+   = {schema_version:1, archetype, entry_point, build_probe?, launch_probe?}. archetype ∈
+   {client-only-game|web-service|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. The two probes feed the round build gate (`harness verify
+   build`, every round before EVAL): build_probe asserts the BUILT ARTIFACT covers what the run
+   wrote (a green exit code is not proof the feature compiled when the toolchain compiles only what
+   an entry point reaches); launch_probe installs, starts and asserts the first screen. A `mobile`
+   profile without a launch_probe is warned about every round — nothing else in the loop launches
+   the app.
 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 +242,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 +295,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 +312,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).
@@ -315,8 +351,16 @@ Do NOT enter BUILD until the board is accepted.
 Feature   : [slug]
 Round     : [r]
 Scopes    : [N] green, [M] queued for hammer
+Build gate: [green | red — <failing step> | undeclared]
 ```
 
+The build gate is `harness verify build --slug <slug> --round <r>` — the ledger's `run_cmd`, then
+the profile's `build_probe` and `launch_probe`, stopping at the first failure. It runs before this
+gate so the block shows it; `red` means EVAL is NOT dispatched this round (the judge grades a running
+feature) and the failing step is compiled into round r+1's orders as `payload.bugs`. `undeclared`
+means L0 pinned no run command and the profile names no probe — the round proceeds over an
+unproven build, and the block says so.
+
 Under `--interactive` / `--auto`, the hook warns if the board is not truly green (advisory) and requires explicit PO approval to proceed. Under `--unattended`, it automatically aborts on a red board or proceeds on a green one.
 
 ---
@@ -344,6 +388,10 @@ PASS:
   → --no-qa or skill absent: proceed straight to SHIP; ledger records `qa: skipped`.
 
 FAIL:
+  → a round whose build gate was red never reached the judge: the block carries `build_gate: red`,
+    the "bug list" is the gate's failing step (its command, exit and output tail), and round r+1
+    is a fix round over exactly that. Nothing the evaluator would have said is missing — it was
+    never asked.
   → print the bug list grouped by task/severity. For each bug: task ID + failed Done-when criterion + repro.
     DO NOT prescribe fix options or root cause hypotheses — that is the implementer's job.
     The tech lead names scope; the implementer diagnoses and fixes.
@@ -378,6 +426,9 @@ S.0  GATE H — delegate to scope-hammer (this IS Shape Up's "Decide When to Sto
              (no --breaker flag)              normal stop — all scopes FINISHED, post-QA-hunt
      Feeds it: qa/hunt-report.md findings (when present), discovery/ledger.md open items,
                the hammer-proposal queue from BUILD (attempt-budget exhaustions).
+     Ownership facts in its census — "no scope owns X", "X belongs to scope Y" — come from
+       node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" probe owner --slug <slug> [--path <p>]...
+       which elects the owner from the committed contracts' substrates, never from prose.
      Reads back: its GATE H0/H1/H2 output — census, baseline comparison, cut list + verdict.
      Authority: scope-hammer proposes; the tech lead records the PO's decision in
        round-ledger.md and performs the actual close (S.1 onward). It never ships on its own.
@@ -414,7 +465,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.
@@ -465,7 +517,7 @@ Ledger    : harness-run.md
 ```
 Question (max 1): "Anything to record before I close the run? (y/n) or provide feedback for the next sprint."
 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 skills: `task-executor`, `ba-pitch-analyzer`, `qa-edge-hunter`; each reads its own file at the top of its next run. The tech lead does not categorize the feedback itself — that is the coach's gate, by design (no assumptions).
+- 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.`
 
 ---

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

@@ -68,7 +68,9 @@ approval of the new tasks and estimates before resuming the BUILD loop.
 
 ## The EVAL timing rule (the core constraint)
 
-EVAL fires **once** per round and **only** when GATE L2 has confirmed the board is 100% done.
+EVAL fires **once** per round and **only** when GATE L2 has confirmed the board is 100% done
+and the round build gate (§3d) is not red — a feature that does not build or launch has nothing
+for a judge to grade, and the gate's failing step is what round r+1 fixes.
 It is never:
 - called per task,
 - called inside the BUILD loop,
@@ -311,14 +313,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 +343,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).
@@ -462,6 +465,27 @@ Read back: the stdout JSON — {path, sha256, trial, overall, regression, score,
         (harness verify t0 calls its sibling harness probe digest internally on failure).
 ```
 
+## 3d. Round build gate → `harness verify build` (once per round, before EVAL)
+```
+Invoke via Bash directly — deterministic tooling, not a worker:
+  node "${CLAUDE_PLUGIN_ROOT}/kernel/harness.mjs" verify build --slug <slug> --round <N>
+Effect: runs, in order and stopping at the first failure, the ledger's `run_cmd` (the build), then
+        project-profile.md's `build_probe` (the built artifact covers what the run wrote — a green
+        exit code is not proof the feature compiled when the toolchain compiles only what an entry
+        point reaches) and `launch_probe` (install, start, assert the first screen, fail on fatal
+        logs). Writes .shapeup/<slug>/build/r<N>-t<T>.json, immutable per run of the gate.
+Read back: stdout JSON — {overall: green|red, steps[], warnings[], failed_step?, stderr_tail?}.
+        Exit 0 green · 1 red · 3 nothing declared (no run_cmd, no probes — logged, never green).
+        A `mobile` profile with no launch_probe is warned about on stderr every round, and so is
+        every scope none of whose fixtures invoke the tool run_cmd builds with — advisory, because a
+        green T0 from such fixtures is not evidence the scope compiles.
+Consequences, both mechanical and both read off the artifact, never off this prose:
+        red → EVAL is not dispatched this round; `harness compile` turns each failing step into a
+              `payload.bugs` entry for round N+1, addressed to the scope whose substrate holds the
+              files the tool's output names (unowned → every scope, marked).
+        red → `reduce hill` withholds DOWNHILL_EXECUTION from every T0-green verdict of round N.
+```
+
 ## 4. EVAL → spec-evaluator (once per round)
 ```
 compile-order --operation evaluate --slug <slug> --worker spec-evaluator --round <r>
@@ -526,6 +550,7 @@ Read back: the proposed cut list + verdict (SHIP now | SHIP after fixing ship-bl
 | `harness-run.md` | **tech lead (sole writer)** | tech lead (round ledger + Hill + run-state), PO (audit) |
 | `scopes/<scope-id>.md` | `scope-architect` (sole writer) | tech lead (substrate/sequence), sandbox hook (write-whitelist), compile-order (inlined into orders) |
 | `t0/verdicts/r<N>-a<M>-t<T>.json` | `harness verify t0` (skill-local, mechanical — not a worker) | spec-evaluator (required citation), tech lead (hill derivation), compile-order (digested errors) |
+| `build/r<N>-t<T>.json` (the round build gate) | `harness verify build` (mechanical — run_cmd + build_probe + launch_probe, once per round before EVAL) | tech lead (GATE L2 block), `harness reduce hill` (a red round moves no dot), compile-order (`payload.bugs` for round N+1) |
 | `t0/trials.jsonl` (the ratchet ledger, append-only, `baseline_trial` as the parent link) | `harness verify t0` (one row per attempt: score, status, delta, tree_ref) | compile-order (`trial_history` into the next order), ship-report (T0 + Ratchet sections), `harness probe stats --ratchet` |
 | `round-ledger.md` | **tech lead (sole writer)** | compile-order (decisions into every order), PO (audit) |
 | `hill/<scope-id>.yml` + `hill-chart.md` | **tech lead (sole writer)** | PO ("status without asking"), scope-hammer (H0 census) |
@@ -826,7 +851,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,