shapeup-sdlc 3.18.3 → 4.0.0

package/skills/building/resources/stop.md

@@ -0,0 +1,127 @@
+# Stop — decide when to stop (GATE H)
+
+The census is yours: you do it in this context — no sub-agent — and GATE L4 reads one file to know it was done. The bar is Shape Up's own: as the budget runs
+out, cut perfectionist ambition by comparing the product to the **baseline** — what customers live with
+today — **never to a hypothetical ideal**. "Better than the baseline" is good enough to ship; "not as good as
+I imagined" is not a reason to keep building. You propose; the PO decides.
+
+## When you do it
+
+```
+1. The loop ended well (a PASS, or a not-evaluated round) and QA is done — the normal stop.
+2. The outer breaker tripped: `maxRounds` spent — scopes may still be open.
+3. A scope exhausted its `attemptBudget` without a green T0 — you recorded it as a proposal; it is judged here
+   instead of blocking the round.
+```
+
+What the run knows is in its files: the QA report under `.shapeup/<slug>/qa/`, the proposals you recorded, the scopes
+with a green latest trial, and which breaker, if any, ended the run. Case 1 has no unresolved scopes; cases 2 and 3 do,
+and each becomes an explicit CUT or CARRY candidate below.
+
+## Census
+
+Gather every open item into one list before judging any of them. A partial view produces a wrong cut.
+
+**Every claim cites the file it came from.** Derive, never remember:
+
+| Claim | Read | Rule |
+|---|---|---|
+| "no scope owns X" / "X is scope Y's" | the `allowed_file_substrate` and `shared_substrate` of every `<spec>scopes/*.md`, and the paths `<spec>wiring-map.md` names | Ownership is what the contracts say. A path no contract lists is an unowned seam; a path the wiring names that is not on disk is owned but never written. A census that narrated ownership from memory once told the PO no scope owned a directory a committed contract listed in plain sight. |
+| a pitch clause the run never showed working | `<spec>requirements.md`, and the verdict's criteria with their `covers:` anchors | A requirement with no passing criterion is a census item carrying its source clause (`REQ-12 ← shaping.md R12`). A clause the PO marked `CUT (PO-approved)` is an answer already given, not an item. No registry on disk → none. |
+| "scope S exhausted its attempts" | `<run>/t0/trials.jsonl` and `<run>/receipts/dispatch.jsonl` | Count the scope's attempts that have a dispatch receipt AND a result. A compiled order and a T0 verdict are both writable by the scope being judged, so neither counts alone. |
+
+Then collect, from the run's own records:
+
+- Unresolved scopes (breaker cases): uphill/downhill scopes when the round budget hit 0, and scopes with a
+  proposal — **carry candidates**, each with its hill phase and open unknowns from `hill/<scope-id>.yml`.
+- QA findings: `.shapeup/<slug>/qa/` report when present — all `~` by default.
+- Discovered-ledger entries still open (`.shapeup/<slug>/discovery/ledger.md`, `[+]` / `~` unresolved).
+- Requirements with no PASS evidence (above).
+
+**Classify every item.** MUST-HAVE: the pitch's core problem is unsolved without it. NICE-TO-HAVE (`~`): improves
+but does not block the core promise. **Default to NICE-TO-HAVE** unless the item traces directly to a pitch
+boundary or a scope's `business_goal` — a generous must-have list defeats the point of hammering.
+
+```
+⏸ GATE H0 — Census
+Must-have (unresolved)  : [N] — [list, each with source: scope | QA | discovered | requirement | advisor-overflow]
+Nice-to-have (~)        : [M]
+Carry candidates        : [scopes still uphill/downhill, or exhausted attempt budget]
+```
+
+## Baseline comparison
+
+1. Resolve the baseline: `shapeup/<slug>/shaping/baseline.md` when present (written at shaping time, first-class).
+   Absent → degrade honestly: read the pitch's problem statement as the implicit baseline and say
+   "baseline not first-class — comparison is approximate" in the report. **Do not invent one.**
+2. For each MUST-HAVE: "with this item cut or carried, is the shipped product still strictly better than the
+   baseline for the pitch's core problem?"
+   - YES → safe to cut or carry; it is a cut-list candidate anyway (the PO is still asked).
+   - NO → this item blocks shipping as it stands and is **not hammer-cuttable**. Fix it now (one more focused
+     attempt, not a full extra round) or the run genuinely fails the appetite: say so, do not ship anyway.
+3. NICE-TO-HAVE items never block; they are cut-list candidates by construction.
+
+## Cut list and verdict
+
+```
+⏸ GATE H2 — Cut List & Verdict
+Baseline      : [shapeup/<slug>/shaping/baseline.md | approximate — pitch problem statement]
+Ship-blocking : [none | MUST-HAVE items that fail the comparison — NOT cuttable]
+Proposed cuts : [N nice-to-have + N cuttable must-have, each: item — source — one-line why safe]
+Carry-forward : [scopes/items proposed for the next cycle's raw-idea list, debt-free]
+Verdict       : [SHIP now | SHIP after fixing ship-blocking items | CANNOT SHIP — escalate to PO]
+```
+
+The PO confirms every cut ("approve all / list ids to keep / none"); you never override a kept item. Whatever
+is not kept is carried to the discovery ledger as a raw idea — debt-free, never silently dropped, never
+silently promoted back into scope. A ship-blocking item the PO overrides is logged as a known gap in the ship
+report, never hidden.
+
+## The census file — what the step is done on
+
+Write the census as data (shape `HammerCensus` in the kernel's domain registry), beside the
+human-readable report, to `.shapeup/<slug>/reports/hammer-census.json`:
+
+```json
+{ "schema_version": 1, "verdict": "ship-now | ship-after-fixes | cannot-ship",
+  "cut_list": ["…"], "ship_blocking": ["…"], "breaker": "outer | inner | deadline | null", "baseline": "<path or null>" }
+```
+
+`ship_blocking` is non-empty exactly when the verdict is `cannot-ship`. **GATE L4's resolver reads this file —
+and nothing else — before it lets any answer set say `ship`:** a census that lives only in your printed blocks
+cannot be read by a gate. Still a proposal: the file grants nothing.
+
+Read it back before you cross GATE H: readable JSON, a verdict from the three, a `cut_list` array, and `ship_blocking`
+non-empty exactly when the verdict is `cannot-ship`. A census that fails that read is yours to fix now; do not cross the gate over it.
+
+## The ship report
+
+After GATE H and before GATE L4, write `shapeup/<slug>/REPORT.md` — frozen at L4, committed, so it carries no run-trace path and no board id
+(cite use cases and scope ids instead; the fence refuses the write otherwise). Its first line says what this is: **a ship is not a pass**, so
+a shipped FAIL opens with `Shipped over a FAIL verdict, with the cut list below`, never with the title alone. Then:
+
+- **Outcome** — the verdict, rounds used and judged, tasks done of planned, whether QA ran, did not run, or ran and drove nothing, and the
+  models: per role, what the launch record asked for and what the dispatch receipts (`<run>/receipts/dispatch.jsonl`, `usage.model`) name as
+  having run. Where the two differ, say so here: a cost or a verdict read against the wrong model is a figure about a different run.
+- **Verification** — one row per scope from its latest trial: fixtures passed of total, regressions, trials, last status.
+- **Requirements** — one row per registered clause: its source, the covering criterion, its verdict. A projection, never a verdict; none of it blocks the ship.
+- **The cut list and the known gaps** — every cut the PO accepted, and every ship-blocking item the PO overrode.
+- **What did not finish** — the unfinished tasks by use case. A run launched with `noEval` says nothing was evaluated and never reads as verified.
+
+Every figure is read off a file you opened in this step. A report written from memory of the run is the failure this section exists to prevent.
+
+A write the fence refuses names a live order: a dead session left a dispatch open. That is dead work, not yours to
+answer — say so to the PO (`init run --force` answers every open order and discards the round history; only the PO
+asks for it).
+
+## What never changes
+
+| Rule | Why |
+|---|---|
+| Compare to the baseline, never to a perfect ideal | the actual trade-off algorithm of the stop step |
+| Default classification is NICE-TO-HAVE | a generous must-have list defeats the point |
+| A MUST-HAVE that fails the comparison is never cut silently | the one case where the census refuses to make the run look shippable |
+| Cuts are proposals; the PO confirms every one | the census never overrides the human at the ship gate |
+| Every ownership, exhaustion and requirement claim cites its file | derived from the contracts and the receipts, never from what the report remembers |
+| You never set `status: done`, deploy, or ship | the run closes only after GATE L4 is crossed — `order close --status shipped` refuses without this run's `ship` row; the judge, the doer and the census stay separate acts |
+| Guidance never decides a gate | a knowledge-base rule may add a question to the H block, never an answer; there is no `stop` knowledge-base file — the census's claims come from files |

package/skills/orient/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: orient
-description: "Use this skill for Shape Up step 7 (Orient) — the builder-led reconnaissance pass that runs AFTER kick-off and BEFORE any task board exists. Triggers on: \"orient on this feature\", \"scout the codebase for this pitch\", \"where does this pitch touch the code\", \"do an orient pass\", \"recon before we plan\", \"spike the riskiest part before mapping scopes\". The tech-lead orchestrator invokes it at step 7 before delegating to ba-pitch-analyzer (Map Scopes, step 8). Use it even when the user describes \"read the code first and surface the unknowns\" without naming Orient. Also accepts a tech-lead --order dispatch."
+description: "Use this skill for Shape Up step 7 (Orient) — the builder-led reconnaissance pass that runs AFTER kick-off and BEFORE any task board exists. Triggers on: \"orient on this feature\", \"scout the codebase for this pitch\", \"where does this pitch touch the code\", \"do an orient pass\", \"recon before we plan\", \"spike the riskiest part before mapping scopes\". The loop (`/ship`) invokes it at step 7, before the plan activity (Map Scopes, step 8). Use it even when the user describes \"read the code first and surface the unknowns\" without naming Orient. Also accepts a the loop --order dispatch."
 ---
 
 # Orient — the Scout (Shape Up step 7)
@@ -8,16 +8,16 @@ description: "Use this skill for Shape Up step 7 (Orient) — the builder-led re
 In Shape Up, the team that builds also **orients**: after kick-off they read the real code,
 spike the scary parts, and let reality generate **Discovered tasks** — which outnumber the
 imagined ones. This skill is that pass, made explicit. It exists because the orchestrator
-(`tech-lead`) must *delegate* orientation, and the generator (`task-executor`) can't host it:
+(`building`) must *delegate* orientation, and the generator (`task-executor`) can't host it:
 its first gate needs a task file, and **at Orient time no board exists yet** — the board is
-mapped *after* this pass, by `ba-pitch-analyzer` at step 8.
+mapped *after* this pass, by the plan activity at step 8.
 
 So the Scout's whole job is to make the planner's board **reality-born instead of imagined**.
-It hands `ba` a map of where the pitch lands in real code, the findings from de-risking the
+It hands the plan step a map of where the pitch lands in real code, the findings from de-risking the
 single scariest area, and a seed list of tasks (imagined + already-discovered). Nothing more.
 
 ```
-PO: shaping → bet → kick-off ──► tech-lead ──► ORIENT (you) ──► ba (Map Scopes) ──► build
+PO: shaping → bet → kick-off ──► the loop ──► ORIENT (you) ──► plan (Map Scopes) ──► build
                                                   reads code, spikes, seeds
 ```
 
@@ -29,13 +29,13 @@ PO: shaping → bet → kick-off ──► tech-lead ──► ORIENT (you) ─
 |------|----------|
 | Read the kicked-off pitch + breadboard | Re-shape, re-bet, or question the appetite (PO already did) |
 | Trace pitch elements to real files/modules | Write production code |
-| Spike the **single** riskiest area, time-boxed | Build the scope board / tasks (that is `ba`, step 8) |
-| Seed the discovered-task list (imagined + discovered) | Keep `run-state` (tech-lead owns it) |
-| Emit raw hill **signal** (per-area unknowns) | Render the hill **report** (tech-lead renders it) |
+| Spike the **single** riskiest area, time-boxed | Build the scope board / tasks (that is the plan step, step 8) |
+| Seed the discovered-task list (imagined + discovered) | Keep `run-state` (the loop owns it) |
+| Emit raw hill **signal** (per-area unknowns) | Render the hill **report** (the loop renders it) |
 
 The Scout is a **pure worker** (the harness rule: stateless workers, one stateful
 orchestrator). It receives run metadata — `feature`, `spec` folder, `stack` — as **arguments**
-from `tech-lead`; it never reads or writes a shared run-state file.
+from `building`; it never reads or writes a shared run-state file.
 
 ---
 
@@ -52,10 +52,10 @@ write surface — the orient output dir. Anything absent = unknown: confirm at G
 `--pitch/--spec/--stack` flags below carry the same fields; the output dir derives from the
 spec path (`.shapeup/<feat>/orient/`).
 
-## Output — the four artifacts (the `orient → ba` contract) + a WorkResult
+## Output — the four artifacts (the `orient → plan` contract) + a WorkResult
 
 All four land in the orient output dir (orchestrated: the order's substrate; standalone:
-`.shapeup/<feat>/orient/`). These ARE the contract `ba` Phase 1 consumes, so `ba` does
+`.shapeup/<feat>/orient/`). These ARE the contract the plan step's Phase 1 consumes, so it does
 not re-scan the codebase. Keep them factual and link real `file:line` so the planner can trust
 them. When dispatched with an order, also write the WorkResult envelope
 (`.shapeup/<feat>/results/<order-suffix>.json`, `work-result.schema.json`): `status`,
@@ -63,10 +63,10 @@ them. When dispatched with an order, also write the WorkResult envelope
 
 | File | Purpose | Consumed by |
 |------|---------|-------------|
-| `orient/code-surface.md` | where the pitch lands in real code: modules, files, existing entities, seams | `ba` Phase 1 (ingest), Phase 2 (DDD) |
-| `orient/spike-<area>.md` | findings from de-risking the single riskiest area | `ba` Phase 1b / contracts; tech-lead L1a |
-| `orient/discovered-seed.md` | imagined + already-discovered tasks, grouped by suspected scope | `ba` Phase 6 (task gen) |
-| `orient/hill-signal.md` | per-area inventory of open unknowns (raw signal, not a report) | `tech-lead` GATE L1a hill render |
+| `orient/code-surface.md` | where the pitch lands in real code: modules, files, existing entities, seams | the plan step's Phase 1 (ingest), Phase 2 (DDD) |
+| `orient/spike-<area>.md` | findings from de-risking the single riskiest area | the plan step's Phase 1b / contracts; the loop L1a |
+| `orient/discovered-seed.md` | imagined + already-discovered tasks, grouped by suspected scope | the plan step's Phase 6 (task gen) |
+| `orient/hill-signal.md` | per-area inventory of open unknowns (raw signal, not a report) | `building` GATE L1a hill render |
 
 ---
 
@@ -91,10 +91,10 @@ Phase 5   │  Seed discovered tasks ► imagined + discovered, grouped by suspe
           │                         → write orient/discovered-seed.md
 Phase 6   │  Emit hill signal ────► per-area open-unknown inventory
           │                         → write orient/hill-signal.md
-✅ Done    └─► 4 artifacts in .shapeup/<feat>/orient/ — hand back to tech-lead for GATE L1a
+✅ Done    └─► 4 artifacts in .shapeup/<feat>/orient/ — hand back to the loop for GATE L1a
 ```
 
-Under `--auto` (passed by `tech-lead` when its run level is `--auto`/`--unattended`), run
+Under `--auto` (passed by `building` when its run level is `--auto`/`--unattended`), run
 straight through, auto-confirming O-A and O-B with sensible defaults.
 
 ---
@@ -105,7 +105,7 @@ straight through, auto-confirming O-A and O-B with sensible defaults.
 Confirm (do not guess):
   - kicked-off pitch path (shaping.md / pitch.md)
       Shaped signal: frontmatter status: shaped AND bet: <S1|S2|...> (or equivalent).
-      If the pitch lacks appetite AND solution boundaries → STOP and tell tech-lead:
+      If the pitch lacks appetite AND solution boundaries → STOP and tell the loop:
         "Orient runs on a kicked-off pitch, not a raw idea. Shape/bet first (PO upstream)."
   - breadboard — read `payload.breadboard` when present; absent means the pitch has no separate
     breadboard — look for Places and affordance tables in the pitch itself
@@ -160,7 +160,7 @@ Rank candidate areas by **(open unknowns) × (integration risk)**. The riskiest
 where the pitch meets an unproven seam: a third-party API, a data-shape you can't confirm from
 code, a cross-layer contract, a performance assumption. Pick the **single** highest — the
 Scout spikes one thing well, not five things shallowly. List the rest as known unknowns (they
-feed the hill signal and `ba`'s rabbit-hole handling).
+feed the hill signal and the plan step's rabbit-hole handling).
 
 ## GATE O-B — Spike scope
 
@@ -187,33 +187,33 @@ the time-box; a partial answer with a clear residual unknown is a valid result.
 
 ## Phase 5 — Seed discovered tasks → `discovered-seed.md`
 
-Write the task seed `ba` Phase 6 will turn into the board. Two kinds, clearly labelled:
+Write the task seed the plan step's Phase 6 will turn into the board. Two kinds, clearly labelled:
 - **Imagined** — what you'd expect from the pitch alone.
 - **Discovered** — what the code-surface scan and spike actually surfaced (the higher-value
   set; in Shape Up these dominate). **Every discovered task must cite `file:line` or seam.**
   If you can't cite a real location, it belongs in Imagined, not Discovered.
 
-Group by **suspected scope** so `ba` can map scopes naturally. Do **not** assign IDs, order,
+Group by **suspected scope** so the plan step can map scopes naturally. Do **not** assign IDs, order,
 or dependencies — that is the planner's job. You are handing over raw material, not a plan.
 
 > This is the seed for the planner's first board. The *in-build* discovered-task loop
-> (build WorkResults' discoveries[] ingested into the live ledger, reconciled by a planner
-reconcile order) is
+> (build WorkResults' discoveries[] applied to the live ledger, reconciled by a plan spec step
+in `reconcile` mode) is
 > a separate, later mechanism — don't conflate the two.
 
 ## Phase 6 — Emit hill signal → `hill-signal.md`
 
 For each suspected scope/area, list its **open unknowns** (unresolved spike question, `⏳ TBD`
-data shape, unproven seam, ambiguous requirement). This is the raw input `tech-lead` renders
+data shape, unproven seam, ambiguous requirement). This is the raw input `building` renders
 into the Hill at GATE L1a — a scope with open unknowns sits **uphill**; one whose approach the
-spike proved sits toward the **crest**. Emit the *facts*; let `tech-lead` position the dots.
-Keep it per-area (not per-slice) — slices don't exist until `ba` maps them at step 8.
+spike proved sits toward the **crest**. Emit the *facts*; let `building` position the dots.
+Keep it per-area (not per-slice) — slices don't exist until the plan step maps them at step 8.
 
 ---
 
 ## Done — completion output
 
-When all four artifacts are written, emit this summary (to tech-lead or directly to the user
+When all four artifacts are written, emit this summary (to the loop or directly to the user
 in standalone mode):
 
 ```
@@ -225,12 +225,12 @@ in standalone mode):
     discovered-seed.md — <N imagined> + <M discovered> tasks seeded across <K> scopes
     hill-signal.md    — <summary line from hill, e.g. "No uphill areas; spike at crest.">
 
-  Ready for ba (step 8):
-    Pass --orient-dir .shapeup/<feat>/orient/ to ba-pitch-analyzer.
-    ba Phase 1 skips its own codebase scan and reads code-surface.md as its authoritative map.
+  Ready for the plan step (step 8):
+    The plan activity's spec step carries .shapeup/<feat>/orient/ as its orient directory.
+    Its INGEST phase skips its own codebase scan and reads code-surface.md as its authoritative map.
 ```
 
-Tech-lead uses this to render the GATE L1a Hill and confirm the spike before handing to `ba`.
+The loop uses this to render the GATE L1a Hill and confirm the spike before handing to the plan step.
 
 ---
 
@@ -242,25 +242,25 @@ Tech-lead uses this to render the GATE L1a Hill and confirm the spike before han
 | Writes the four artifacts, nothing else | The Scout is a pure worker; no code, no board, no run-state, no report |
 | Spike exactly one area OR declare SPIKE-NOT-NEEDED | Depth on the scariest unknown beats shallow coverage; don't spike for its own sake |
 | Every Discovered task in the seed cites `file:line` | If no real location exists, it belongs in Imagined, not Discovered |
-| Never assign task IDs/order/deps in the seed | Mapping scopes is `ba`'s job (step 8) — the Scout hands over raw material |
-| Receives `feature`/`spec`/`stack` as args; never touches run-state | `tech-lead` is the sole run-state writer |
-| Emits hill *signal*, never a hill *report* | `tech-lead` renders progress; workers emit facts |
+| Never assign task IDs/order/deps in the seed | Mapping scopes is the plan step's job (step 8) — the Scout hands over raw material |
+| Receives `feature`/`spec`/`stack` as args; never touches run-state | `building` is the sole run-state writer |
+| Emits hill *signal*, never a hill *report* | `building` renders progress; workers emit facts |
 
 ---
 
 ## Invocation
 
 ```bash
-# Invoked by tech-lead at step 7 (canonical) — compile-order --operation orient --slug <feat> …
+# Invoked by the loop at step 7 (canonical) — the order the loop wrote
 /orient --order .shapeup/<feat>/orders/orient.json
 
-# Standalone flags (the preamble shim compiles the same envelope)
+# Standalone flags (the preamble shim writes the same envelope by hand)
 /orient --pitch shapeup/<feat>/shaping/shaping.md --spec shapeup/<feat>/spec/ --stack "pnpm, Next 16 web :3000"
 
 # Standalone recon (no orchestrator) — still writes only the four artifacts
 /orient --pitch shapeup/<feat>/shaping/shaping.md --spec shapeup/<feat>/spec/
 
-# Auto (tech-lead passes this under --auto/--unattended): run straight through
+# Auto (the loop passes this under --auto/--unattended): run straight through
 /orient --pitch ... --spec ... --auto
 ```
 

package/skills/qa-edge-hunter/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: qa-edge-hunter
-description: "Use this skill for the post-PASS exploratory QA pass — Shape Up's \"QA is for the edges\", made explicit for the harness. Triggers on: \"hunt edge cases\", \"QA pass on this feature\", \"exploratory test the running app\", \"edge hunt before ship\", \"run qa-edge-hunter\", \"the evaluator passed — what did it miss?\". tech-lead invokes it after the run's first PASS at GATE L3, before SHIP; it also runs standalone given a spec folder, a PASS EVAL report, and a running app, or on a tech-lead --order dispatch. It charters edges OUTSIDE what the evaluator probed and hunts them through six fixed lenses. NOT for checking AC (spec-evaluator), deriving test cases (ba), or fixing bugs (task-executor)."
+description: "Use this skill for the post-PASS exploratory QA pass — Shape Up's \"QA is for the edges\", made explicit for the harness. Triggers on: \"hunt edge cases\", \"QA pass on this feature\", \"exploratory test the running app\", \"edge hunt before ship\", \"run qa-edge-hunter\", \"the evaluator passed — what did it miss?\". the loop invokes it after the run's first PASS at the Verdict gate, before ship; it also runs standalone given a spec folder, a PASS EVAL report, and a running app, or on a loop --order dispatch. It charters edges OUTSIDE what the evaluator probed and hunts them through six fixed lenses. NOT for checking AC (spec-evaluator), deriving test cases (ba), or fixing bugs (task-executor)."
 ---
 
 # QA Edge Hunter — the post-PASS edge pass (v1.1)
@@ -13,7 +13,7 @@ case* is invisible to it. The Hunter covers exactly that blind spot: behavior th
 never wrote down.
 
 ```
-tech-lead: ... GATE L2 → EVAL → GATE L3 PASS ──► QA EDGE HUNT (you) ──► SHIP S.0 triage → L4
+the loop: ... GATE L2 → EVAL → GATE L3 PASS ──► QA EDGE HUNT (you) ──► SHIP S.0 triage → L4
                                                   charters · hunts · ~ findings → ledger
             GATE L3 FAIL → fix round (never reaches you — conformance first, edges after)
 ```
@@ -22,7 +22,7 @@ tech-lead: ... GATE L2 → EVAL → GATE L3 PASS ──► QA EDGE HUNT (you)
 
 | Tier | Owner | When |
 |---|---|---|
-| Derivable tests (boundaries, error codes, no-go breaches the spec implies) | `ba` `## Test Surface` + evaluator `test-surface-conformance` | spec time / every EVAL |
+| Derivable tests (boundaries, error codes, no-go breaches the spec implies) | the plan step's `## Test Surface` + evaluator `test-surface-conformance` | spec time / every EVAL |
 | **Exploratory edges (this skill)** | `/qa-edge-hunter` | once, post-first-PASS |
 
 ---
@@ -32,7 +32,7 @@ tech-lead: ... GATE L2 → EVAL → GATE L3 PASS ──► QA EDGE HUNT (you)
 | Does | Does NOT |
 |------|----------|
 | Read EVAL-*.md to map covered territory — then hunt OUTSIDE it | Re-probe anything the evaluator already graded |
-| Charter edges via six fixed lenses, minus covered territory | Author or extend `## Test Surface` (that is the planner's retrofit-surface operation) |
+| Charter edges via six fixed lenses, minus covered territory | Author or extend `## Test Surface` (that is the planner's `retrofit-surface` spec mode) |
 | Execute charters against the **running deliverable** (session-based exploratory) | Read-only speculate from code ("this looks racy") — every finding needs a live repro |
 | Return each finding in the WorkResult's `discoveries[]`, **always `~`** | Promote `~` → must-have (PO/TL at SHIP S.0; severity-hint is advice, not a decision) |
 | Emit `qa/hunt-report.md` — charters run/cut, findings by lens | Render a verdict, score, or PASS/FAIL of any kind |
@@ -48,7 +48,7 @@ zero exit as the deliverable reached; `build_gate` records that the round's gate
 Drive it with the tools the project's knowledge base names, by the path it gives.
 Do not refuse the hunt, and do not invent a URL. Its write surface is
 `.shapeup/<feature>/qa/**` only. The Hunter never touches the discovery ledger itself —
-ingest appends its `discoveries[]` under a `## Discovered` section, preserving single-writer
+the loop appends its `discoveries[]` under a `## Discovered` section, preserving single-writer
 mechanically.
 
 ---
@@ -77,18 +77,18 @@ HARD (any miss → STOP, report which):
      real invocation of the entry point (not a ping, not a guess that a tool is missing). When the
      order carries `launch_cmd`, run it before concluding anything; the report names the command
      and its exit. A hunt that reached nothing returns `status: failed`, never `done`. A hunt that
-     reached the app runs at least one charter: ingest refuses a `done` whose report says
+     reached the app runs at least one charter: the loop sends back a `done` whose report says
      `charters: 0/…` while the order carried `launch_cmd` or `app_url`.
   ✅ EVAL-FEATURE-<slug>.md exists with verdict: PASS
   ✅ if discovery/ledger.md exists: ledger.feature == <feature> (read-only context check —
-     a missing ledger is fine; ingest creates it when your findings land)
+     a missing ledger is fine; the loop creates it when your findings land)
 SOFT:
   ⚠️ any usecases/UC-*.md has `## Test Surface`?
      NO → DEGRADED MODE:
        "Test Surface absent — derivable cases (boundaries, error codes, no-go breaches)
         were never systematically probed. Lenses ① and ⑤ will widen to compensate
         (charters tagged [derivable-fallback]). Better: run
-        a ba-pitch-analyzer retrofit-surface order + one evaluator pass first, then hunt
+        a plan spec step in `retrofit-surface` mode + one evaluator pass first, then hunt
         with a narrower charter. Continue degraded? [y/n]"
      Degraded is first-class, not an error — for old specs, a degraded hunt beats no hunt.
 Questions: max 2. The standing one: "Any areas OUT OF BOUNDS for exploratory testing?
@@ -101,7 +101,7 @@ from charters and listed in the report, never silently skipped.
 ⏸ GATE Q0 — Preflight
 App       : [url] ✅ reachable
 EVAL      : EVAL-FEATURE-[slug].md — PASS (dims: [...])
-Ledger    : [✅ feature match | absent — ingest will create it]
+Ledger    : [✅ feature match | absent — the loop will create it]
 Surface   : [present | ABSENT → degraded mode]
 Out-of-bounds? (max 2 questions) …
 ```
@@ -111,7 +111,7 @@ Out-of-bounds? (max 2 questions) …
 ## Phase Q1 — Charter Map
 
 A **charter** is a hunting ground + a mission — NOT a test case (test cases are the
-derivable tier; writing them here would re-do `ba`'s job badly). Generate charters by
+derivable tier; writing them here would re-do the plan step's job badly). Generate charters by
 crossing the UC tree with the **six fixed lenses**, then subtract covered territory.
 
 | Lens | Mission | Typical prey |
@@ -137,7 +137,7 @@ A charter is a license to deviate within a hunting ground; a test case is a scri
 
 ```
 Q1.0  Read team guidelines: the file at `payload.kb_rules_path` (if present; absent field = none).
-      `/coach`-distilled edge classes that kept biting past features (e.g. "session-expiry
+      retro-distilled edge classes that kept biting past features (e.g. "session-expiry
       mid-form keeps surfacing"). Steering, never spec and never a verdict: use them to
       PRIORITIZE charters within the six fixed lenses — never to add a seventh lens, skip
       covered-territory subtraction, or promote a finding on their say-so. Absent = none recorded.
@@ -209,7 +209,7 @@ Per charter:
          "severity_hint": "data-integrity | boundary-breach | ux-degradation | cosmetic",
          "test_gap": "unit | integration | exploratory-only" }
 
-       Always `~` — ingest appends these to the discovery ledger verbatim; you never open
+       Always `~` — the loop appends these to the discovery ledger verbatim; you never open
        the ledger file. severity_hint is the Hunter's advice to triage — the promotion
        decision is PO/TL's at SHIP S.0, never made here.
        test_gap is advisory for reconciliation: unit = a targeted unit test would have
@@ -307,7 +307,7 @@ hammered out at GATE Q1 (not hunted): […]
 | ① Boundary | C-01, C-05 | 2 | 0 |
 | … | | | |
 → details live in .shapeup/<feature>/discovery/ledger.md under the `## Discovered` section
-  ingest appends for this hunt's order
+  the loop appends for this hunt's order
 
 ## Shaping-quality signal (advisory, for the PO — next cycle's input)
 - lens ⑤ findings ≈ No-gos written loosely (breach routes left open)
@@ -353,7 +353,7 @@ No verdict line exists in this file by design. The Hunter's last words:
 1. **Never a verdict.** The run's verdict is the evaluator's PASS. One judge.
 2. **Never promote.** Every finding is born `~`. severity-hint advises; PO/TL decide.
 3. **Never fix.** Read-only on code; execute-only on the app; write-only to
-   qa/hunt-report.md + its own WorkResult (findings return as data; ingest owns the ledger).
+   qa/hunt-report.md + its own WorkResult (findings return as data; the loop owns the ledger).
 4. **Never block ship.** A hunt with 40 findings and a hunt with 0 both end the same way:
    report, then triage at L4. The circuit breaker outranks the Hunter.
 5. **Never re-probe covered territory.** EVAL-*.md territory is subtracted at Q1; an

package/skills/shapeup/SKILL.md

@@ -237,7 +237,7 @@ INPUT: raw idea / brief / feature description
    ✅ rabbit holes listed  ✅ fit check clean  ✅ ≤9 slices
    ▼
 OUTPUT: shaping.md + breadboard.md (+ spike-[part].md if applicable)
-        → kicked-off pitch, ready for /ba-pitch-analyzer or /tech-lead
+        → kicked-off pitch, ready for `/ship` (the plan activity takes it from here)
 ```
 
 ### Progress Markers
@@ -368,7 +368,7 @@ Two roots, separated by artifact **nature** (full design →
 | Root | Contents | Nature | Git |
 |---|---|---|---|
 | `shapeup/[slug]/shaping/` | shaping · breadboard · spike · pitch · kickoff | **durable source** | commit, shared |
-| `shapeup/[slug]/spec/` | domain model · UC · contracts · tasks (ba-pitch-analyzer output) | **durable deliverable** | commit, shared |
+| `shapeup/[slug]/spec/` | domain model · UC · contracts · tasks (the plan activity's output) | **durable deliverable** | commit, shared |
 | `.shapeup/[slug]/` | run-state · gate log · **digest.md** · orient/ · evaluation/ · qa/ · ledger | **ephemeral / derived** | **gitignore (hidden)** |
 
 - **Shared** root `shapeup/[slug]/` = what the team contributes to
@@ -378,7 +378,7 @@ Two roots, separated by artifact **nature** (full design →
   harvest shards `.shapeup/metrics/*.jsonl`, lives under the local root.
 - `digest.md` is the run's derived decision context (the 4-field, two-zone read
   model the gates consume). It is **never** the source of truth and never crosses
-  a skill boundary — `ba-pitch-analyzer` reads `pitch.md`/`shaping.md`, never the
+  a skill boundary — the plan activity reads `pitch.md`/`shaping.md`, never the
   digest.
 - **Ripple-check rule (mandatory):** the digest carries **no `shaping: true`** —
   it is a sink, not a node. The ripple-check **must glob-exclude
@@ -387,14 +387,14 @@ Two roots, separated by artifact **nature** (full design →
 
 ---
 
-## Integration with ba-pitch-analyzer
+## Integration with the plan activity
 
 ```
 /shapeup shaping          → shaping.md
 /shapeup spike            → spike-[part].md  (as needed)
 /shapeup breadboarding    → breadboard.md (with slices)
          ↓
-/ba-pitch-analyzer shapeup/[feature-slug]/shaping/shaping.md
+/ship shapeup/[feature-slug]/shaping/shaping.md   (its plan step reads the pitch)
          ↓
 shapeup/[feature-slug]/spec/  (domain model, contracts, use cases, tasks)
 ```

package/skills/shapeup/resources/breadboarding.md

@@ -357,7 +357,7 @@ status: breadboarded
 |---|-------|-----------|------|
 ```
 
-**Note:** This file is the second half of the kicked-off pitch (with `shaping.md`). `/ba-pitch-analyzer` and `/tech-lead` consume it as-is — affordance IDs (U[N], N[N]) are the traceability anchors downstream tasks and commits reference.
+**Note:** This file is the second half of the kicked-off pitch (with `shaping.md`). `/ship` (its plan step) consumes it as-is — affordance IDs (U[N], N[N]) are the traceability anchors downstream tasks and commits reference.
 
 ---
 

package/skills/shapeup/resources/context-compaction.md

@@ -161,7 +161,7 @@ mostly: *on confirm, demote the block from prose to a frozen one-liner + wikilin
 | *Pitch* | betting handoff | everything → 5 ingredients | compaction already exists |
 
 **Benefit is back-loaded.** GATE 0–1 have almost nothing to compact; the wins are
-at GATE 3–4 and especially the **handoff to ba-pitch-analyzer**. If staging the
+at GATE 3–4 and especially the **handoff to the plan activity**. If staging the
 work, build the digest for the B-phases + pitch first.
 
 ---
@@ -183,8 +183,8 @@ Everything keys off the feature `<slug>`. Two roots, split by **who needs it**:
   fully gitignorable, dies with the run. It is derived from the same `<slug>`.
 - `.gitignore`: one line — `.shapeup/`. The whole local root is ignored; no
   carve-out is needed because everything machine-written at run time lives there,
-  including the harvested signal shards `.shapeup/metrics/*.jsonl` (written by
-  the tech-lead at SHIP, fact-only; see the tech-lead skill's SHIP step). The
+  including the harvested signal shards `.shapeup/metrics/*.jsonl` (an earlier release wrote
+  a fact-only row there at SHIP; nothing does now). The
   committed report surface is the frozen `shapeup/[slug]/REPORT.md`.
 - All paths are **project-relative, resolved from the project root / cwd.** Never
   `/mnt/...` — that is the claude.ai authoring sandbox and dies in a user repo.
@@ -196,13 +196,13 @@ mandates *status without asking* — hill position, verdict, ship sign-off, and
 surprise count are signals, not noise. Split inside the workspace:
 - **live scratch** (raw ledger, gate transition log, digest) → ephemeral, hidden;
 - **report surface** (hill / surprise / verdict / sign-off) → harvested at ship
-  (the tech-lead's metrics row), surfaced or archived to a `run-summary.md`.
+  (the ship report and the run export), surfaced or archived to a `run-summary.md`.
 
 ---
 
 ## Handoff boundary — the digest never crosses a skill
 
-**`ba-pitch-analyzer` does NOT read the digest. It reads `pitch.md` / `shaping.md`.**
+**The plan activity does NOT read the digest. It reads `pitch.md` / `shaping.md`.**
 
 The digest lives in `.shapeup/` — ephemeral, gitignored, run-scoped;
 it dies when the shaping run ends. `pitch.md`/`shaping.md` are durable source,

package/skills/shapeup/resources/shaping.md

@@ -178,7 +178,7 @@ A2: ...
 - [ ] [unknown 1] → spike-[slug].md
 ```
 
-**Note:** This file is a kicked-off pitch. `/ba-pitch-analyzer` and `/tech-lead` consume it as-is — the appetite, rabbit holes, and no-goes inform scope decisions downstream.
+**Note:** This file is a kicked-off pitch. `/ship` (its plan step) consumes it as-is — the appetite, rabbit holes, and no-goes inform scope decisions downstream.
 
 ---