shapeup-sdlc 3.18.2 → 4.0.0

package/skills/spec-evaluator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: spec-evaluator
-description: "Use this skill whenever the user wants to evaluate, QA, or verify that an implemented task actually matches its spec and acceptance criteria — the judge in a planner→generator→evaluator harness. Trigger on: \"evaluate task TASK-NNN\", \"QA TASK-NNN\", \"verify against spec\", \"check acceptance criteria\", \"does this match the spec\", \"grade this build\", \"run evaluator\", or a tech-lead --order dispatch. Skeptical by default — absence of evidence is a FAIL; probes the running app and files file:line bugs."
+description: "Use this skill whenever the user wants to evaluate, QA, or verify that an implemented task actually matches its spec and acceptance criteria — the judge in a planner→generator→evaluator harness. Trigger on: \"evaluate task TASK-NNN\", \"QA TASK-NNN\", \"verify against spec\", \"check acceptance criteria\", \"does this match the spec\", \"grade this build\", \"run evaluator\", or a loop --order dispatch. Skeptical by default — absence of evidence is a FAIL; probes the running app and files file:line bugs."
 ---
 
 # Spec Evaluator (the single judge, pure worker v1.0)
@@ -9,7 +9,7 @@ description: "Use this skill whenever the user wants to evaluate, QA, or verify
 
 The **judge** in a planner → generator → evaluator loop. It reads the committed spec, exercises
 the **running** app, and returns a hard-threshold verdict plus a file:line bug list — as a
-WorkResult envelope the orchestrator ingests. The generator fixes; the evaluator re-runs.
+WorkResult envelope the orchestrator applies. The generator fixes; the evaluator re-runs.
 
 **Core guarantee — skeptical by default.** Out-of-the-box an LLM is a lenient QA: it finds a
 real defect, then talks itself into approving anyway. This skill inverts that posture. A
@@ -20,7 +20,7 @@ criterion with no collected evidence is a **FAIL**, never a pass-by-assumption.
 > **Dimension contract (injection interface)** → `references/dimension-contract.md`.
 > Where any reference file describes *writing* shared state (task files, `.verdicts` ledger,
 > run-state), the pure-worker contract overrides it: that data returns in the WorkResult and
-> the orchestrator's ingest script performs the write. Old gate names in reference files map
+> the orchestrator performs the write. Old gate names in reference files map
 > 1:1 onto the core process below: GATE V0/V0.5 = input contract + dimension resolution,
 > GATE V1 = CONTRACT, Phase A = PROBE, GATE V2 = VERDICT, Phase B = REPORT; GATE V3
 > (sign-off) is retired — pausing is the caller's `interaction` policy.
@@ -42,7 +42,7 @@ Invoked as `--order <path>`. Fields you may rely on (absent = unknown, never inf
 | `payload.launch_cmd` | The project profile's launch probe: installs the built artifact, starts it and asserts the first screen. This is how the app is brought up for `[ui]` probing. A non-zero exit is a finding to cite, not a reason to try another way. Absent → the profile declares none; fall back to `run_cmd` |
 | `payload.build_gate` | This run's newest round build gate artifact — each step's exit code and output tail. It records that the build ran and whether the app launched, and the launch step's output names what it captured. Read it before grading any `[ui]` row NO EVIDENCE: a launch that succeeded is evidence the app can be probed, and the row is graded on the app, not on its absence. Absent → the gate never ran |
 | `payload.revised_checks[]` | Rows that FAILed in one trial of this round and PASS in a later one whose own check file changed in between — a pass obtained by editing the check. Read each listed file against its row's Expect before you let its PASS count; a check that no longer asserts what the row asks makes that row a FAIL, and the bug names the check. Absent → no check was rewritten |
-| `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.t0_artifacts[]` | Per-scope T0 verdict paths for this round (scoped specs), listed by the orchestrator from each scope's latest 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.scopes_without_t0[]` | Scopes with no green T0 this round while others have one. The round IS gradeable: grade every row such a scope owns as FAIL, evidence "no green T0 for scope <id>" with the scope contract as its locator (`…/scopes/<id>.md:1`). Never refuse the round for them — a refusal ends the run before the next round or GATE H can act. Absent → every scope is green |
 | `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 |
@@ -101,15 +101,13 @@ Done-when statements; `_index.md` Non-Go list. Which UCs are in scope comes from
 - Re-probe every FAIL once before finalizing: agree → confidence high; disagree → keep FAIL
   (no stable pass = FAIL), confidence low, note flaky.
 - Read any existing `.verdicts-*.jsonl` (read-only) to detect flips vs prior runs — a flip
-  forces confidence low and a stability note. The new lines return in your envelope; ingest
+  forces confidence low and a stability note. The new lines return in your envelope; the loop
   appends them (never rewrite history).
 - Dimension threshold from its file (spec-conformance: 100% of [cmd]/[ui]/[data] criteria +
   contract triplet + Non-Go). Overall PASS only if ALL active dimensions pass — the halo
   effect is banned; a strong dimension never lifts a failing one.
 - **T0 citation (scoped specs).** Recompute each cited artifact's sha256 from disk — never
-  trust a handed hash. Use any hasher you may run; when none is available to you,
-  `harness probe t0 --slug <slug> --scope <scope_id> --round <r>` prints the digest of that
-  scope's green verdict as the file is at that moment. A digest from any other place — a ledger
+  trust a handed hash. Use any hasher you may run (`shasum -a 256 <path>`, or `node -e` with `node:crypto`). A digest from any other place — a ledger
   line, an earlier report, an error message — is a handed hash, however correct it looks. A verdict on a scoped spec without a T0 citation is structurally
   invalid, regardless of how convincing your own probing looked; generator prose ("tests
   pass", "verified locally") is never admissible evidence.
@@ -177,8 +175,8 @@ round. Write it so someone without your context can answer it in one reply.
 ```
 
 **Every Test Surface row is its own criterion.** Name the row's id (`TS-05-05`) in `criterion`, one
-row per entry — never a range (`TS-01-04/05`) and never a group ("device rows"). Ingest refuses a
-PASS that leaves any row of the spec unnamed, because the requirement matrix, the next round's bugs
+row per entry — never a range (`TS-01-04/05`) and never a group ("device rows"). A PASS that
+leaves any row of the spec unnamed is incomplete, because the requirement matrix, the next round's bugs
 and the rewritten-check list all read the verdict one row at a time.
 
 **`traces_to` is copied, not invented.** Fill it from the `(covers: REQ-…)` clause of the
@@ -188,15 +186,15 @@ clause yields no anchor — leave the array empty rather than guessing, and neve
 supply one. This changes nothing you grade: the anchor is a navigation path, never a grading input,
 and a criterion passes or fails on its evidence exactly as before. It matters downstream because
 the requirement matrix at GATE L4 and the census at GATE H are projected from these anchors; a
-verdict that drops them grades the build and says nothing about what the pitch asked for. Ingest refuses a verdict that anchors no criterion at all while the board's ACs carry `covers:` clauses, and you are sent back once.
+verdict that drops them grades the build and says nothing about what the pitch asked for. A verdict that anchors no criterion at all while the board's ACs carry `covers:` clauses has dropped the link the loop reads.
 
 **Every FAIL criterion's `evidence` MUST carry a `file:line` locator** — schema-enforced, not
-advice: the envelope is validated against `work-result.schema.json` at ingest and a locatorless
+advice: the envelope is validated against `work-result.schema.json` when the loop reads it and a locatorless
 FAIL is rejected before any write. A PASS may cite plain output. (Observed, not theorized: a
 correct FAIL verdict with no locator anywhere is unactionable without re-investigating — the
 rule used to live in prose and be enforced nowhere; it is now data in `domain.schema.json`.)
 
-The orchestrator's ingest appends the verdict ledger, un-ticks the `refuted` boxes, and sets
+The orchestrator's the loop appends the verdict ledger, un-ticks the `refuted` boxes, and sets
 `eval_verdict` frontmatter. You never touch a task file, a board, or run-state — and you
 NEVER set `status: done`: the judge issues verdicts; closure belongs elsewhere. That
 separation is the whole point of the architecture.
@@ -212,7 +210,7 @@ separation is the whole point of the architecture.
 - [ ] Every FAIL was re-probed once; confidence assigned per the ledger rule
 - [ ] Scoped spec → T0 citations present with recomputed sha256 (else the run returned `failed`)
 - [ ] Report written inside `evaluation/**` only; no other file touched
-- [ ] `refuted[]` lists exactly the boxes your evidence disproves (un-ticking is ingest's act)
+- [ ] `refuted[]` lists exactly the boxes your evidence disproves (un-ticking is the loop's act)
 - [ ] The WorkResult validates against `work-result.schema.json`
 
 ---
@@ -233,17 +231,15 @@ bug_template). Adding one (e.g. security) = write `references/dimensions/securit
 # Orchestrated (once per round, after GATE L2) — the canonical form
 /spec-evaluator --order .shapeup/checkout-vnpay/orders/evaluate-r2.json
 
-# Standalone — the preamble shim compiles a minimal order, then the single code path runs:
-#   node "<kernel>" compile --operation evaluate --slug <slug> \
-#        --worker spec-evaluator [--payload '{"dimensions": [...], "run_cmd": "..."}']
+# Standalone — the preamble shim writes a minimal order by hand, then the single code path runs:
 /spec-evaluator --spec shapeup/checkout-vnpay/spec/ --task TASK-007
 /spec-evaluator --spec shapeup/checkout-vnpay/spec/ --feature checkout-vnpay --single-pass
 ```
 
 Standalone keeps `--task` (per-task check, not round-gated) and `--single-pass` (feature-level)
 — the shim maps them onto the order's payload; missing run command → ask. After writing the
-WorkResult, run `node "<kernel>" reduce ingest <result path>` and show its
-summary — standalone has no orchestrator to ingest for you.
+WorkResult, show the user its
+summary — standalone has no orchestrator to apply it for you.
 
 ---
 
@@ -254,10 +250,10 @@ summary — standalone has no orchestrator to ingest for you.
 | Absence of evidence = FAIL | Kills pass-by-assumption, the core QA failure mode |
 | Halo effect banned | A strong dimension never lifts a failing one |
 | Disabled dimensions are out of scope | No silent scope creep |
-| Evaluator never sets `status: done`, never edits task files/boards | Judge ≠ doer; refuted boxes return as data, ingest writes |
+| Evaluator never sets `status: done`, never edits task files/boards | Judge ≠ doer; refuted boxes return as data, the loop writes |
 | Untestable AC blocks a clean PASS | Forces the spec to be verifiable, not vibes |
 | Probe the RUNNING app, not the source alone | Apps that look right still break when used |
 | Re-probe every FAIL; flip ⇒ confidence low | A single snapshot lies; the ledger makes it visible |
-| Verdict-ledger lines are returned, appended by ingest, never rewritten | Verdict history is how a single-snapshot judge becomes measurable |
+| Verdict-ledger lines are returned, appended by the loop, never rewritten | Verdict history is how a single-snapshot judge becomes measurable |
 | A verdict on a scoped spec without a T0 citation is structurally invalid | T0 is a machine fact the generator cannot fabricate |
 | UI assertions target affordances only (test_id/role/data-state) | Layer-3 styling is frozen; grading it resurrects the freeze through the judge |

package/skills/spec-evaluator/references/dimension-contract.md

@@ -16,7 +16,7 @@ enabled: true                   # core loads it only if true (or named in --dime
 weight: 1.0                     # informational; thresholds are hard, not weighted averages
 hard_threshold: all-pass        # see "Threshold vocabulary" below
 applies_to:                     # scoping — omit a key to mean "all"
-  lens: [lite, standard]        # which ba-pitch-analyzer lenses
+  lens: [lite, standard]        # which planning lenses
   package: any                  # apps/api | apps/web | apps/mobile | packages/shared | any
   variant: any                  # shared | be | web | mobile | e2e | any
 requires_browser: true          # does this dimension need the running app in a browser?

package/skills/spec-evaluator/references/dimensions/completeness.md

@@ -14,7 +14,7 @@ requires_browser: false
 # Completeness Dimension
 
 > **Auto-enable rule (read at GATE V0.5):** This dimension stays `enabled: false` by
-> default so it is a no-op on every spec generated before `ba-pitch-analyzer` v2.8.
+> default so it is a no-op on every spec generated before the planner wrote Invariants sections.
 > The core flips it ON for a run **only when** the spec's `usecases/` contains at least
 > one `## Invariants` section. A pre-v2.8 spec has no invariants → this dimension never
 > activates → existing audit scores and verdicts are unchanged (non-regression guarantee).
@@ -25,7 +25,7 @@ criteria?"* — it grades the tasks that exist. It cannot see the task that was
 written. Shape Up's discovered-task philosophy says the real bulk of work is found while
 building; an invariant declared on a UC but never backed by a regression task is exactly
 that blind spot. This dimension converts "absence of a task" from invisible into a graded
-**GAP** — the judge surfaces it; the planner (a ba-pitch-analyzer `reconcile` order) fills it.
+**GAP** — the judge surfaces it; the planner (a plan spec step in `reconcile` mode) fills it.
 Judge never fills it itself.
 
 **Distinction held:** conformance = *the tasks that exist are correct*; completeness =
@@ -98,5 +98,5 @@ location: [usecases/UC-Name.md#Invariants INV-NN | usecases/UC-Name.md | discove
 repro: <how the gap was detected — e.g. "grep use_case_refs across tasks/ found 0 backing TASK for INV-02">
 expected: <e.g. "≥1 regression task referencing UC-ConnectObjects covering INV-02">
 actual: <e.g. "no task references INV-02; invariant declared but unverified">
-next: <handoff — e.g. "a ba-pitch-analyzer reconcile order over <ledger> to generate the missing regression task">
+next: <handoff — e.g. "a plan spec step in reconcile mode over <ledger> to generate the missing regression task">
 ```

package/skills/spec-evaluator/references/dimensions/spec-conformance.md

@@ -77,7 +77,7 @@ dimensions, off by default.
     Inspect the diff / changed files. No file outside the feature's declared package/scope is
     modified, and no item in _index.md's ## Non-Go list is touched. Any out-of-scope change
     FAILS with file:line. (A local task file's own Non-Go section, when present, is consistent
-    with _index.md by construction — ba-pitch-analyzer derives it from the pitch — but the
+    with _index.md by construction — the plan activity derives it from the pitch — but the
     committed _index.md is the grading source since the task file may not exist locally.)
   source: index
 

package/skills/spec-evaluator/references/dimensions/test-surface-conformance.md

@@ -14,9 +14,9 @@ requires_browser: true
 # Test Surface Conformance Dimension
 
 > **Auto-enable rule (read at GATE V0.5):** stays `enabled: false` by default — a no-op on
-> every spec generated before `ba-pitch-analyzer` v2.9. The core flips it ON for a run
+> every spec generated before the planner wrote a Test Surface. The core flips it ON for a run
 > **only when** the spec's `usecases/` contains at least one `## Test Surface` section
-> (fresh v2.9 spec, or a pre-v2.9 spec retrofitted via a retrofit-surface order). Pre-surface
+> (fresh v2.9 spec, or a pre-v2.9 spec retrofitted by a plan spec step in `retrofit-surface` mode). Pre-surface
 > specs → never activates → existing verdicts unchanged (non-regression guarantee).
 > Explicit `--dimensions ...,test-surface-conformance` always wins over the auto rule.
 
@@ -27,7 +27,7 @@ that the spec already implies. The BA now derives that matrix into each UC's
 `## Test Surface` (D1 Invariants · D2 Error Cases · D3 Contract shapes · D4 No-gos,
 mechanical-only); this dimension is the judge-side half: probe every derived row against
 the running app. Judge probes; it never authors rows — a missing or thin Test Surface is
-reported as a finding and routed back to the planner's retrofit-surface operation, never filled in here.
+reported as a finding and routed back to the planner's `retrofit-surface` spec mode, never filled in here.
 
 **Distinctions held:**
 - conformance = *the AC that were written pass* · test-surface = *the matrix the spec
@@ -63,7 +63,7 @@ reported as a finding and routed back to the planner's retrofit-surface operatio
   pass_rule: >
     Cross-check each UC: Invariants ↔ TS-INV rows, Error Cases codes ↔ TS-ERR rows, and
     every row's Source cites D1–D4. A UC with `## Test Surface` whose own sources are
-    uncovered → FAIL at `major` with `next: retrofit-surface order (ba)` (judge surfaces the gap;
+    uncovered → FAIL at `major` with `next: a plan spec step in retrofit-surface mode` (judge surfaces the gap;
     generator fills it — this dimension NEVER authors rows). A UC carrying the explicit
     empty-sources line passes TSC-2 vacuously. A v2.9+ spec UC with NO `## Test Surface`
     section at all → FAIL at `major`, same routing.
@@ -90,7 +90,7 @@ ts_row: <the full row probed, verbatim>
 repro: <probe executed — command / UI steps>
 expected: <the Expect cell>
 actual: <observed evidence — response, state, screenshot ref>
-next: <TSC-1 → task-executor fix via tech-lead round r+1 | TSC-2 → retrofit-surface order re-run>
+next: <TSC-1 → task-executor fix via the loop round r+1 | TSC-2 → retrofit-surface re-run>
 ```
 
 ## Report obligation (the QA handoff)

package/skills/task-executor/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: task-executor
-description: "Use this skill whenever a user wants to execute, implement, or run a specific task generated by the ba-pitch-analyzer skill. Triggers on: \"execute task TASK-NNN\", \"implement TASK-NNN\", \"run this task\", \"start working on TASK-NNN\", \"implement the task in [folder]\", \"run task from spec folder\", \"pick up the next task\", or a tech-lead --order dispatch. Implements a task's acceptance criteria exactly — minimum code, surgical diffs, verified observable outcomes."
+description: "Use this skill whenever a user wants to execute, implement, or run a specific task generated by the plan activity (`/ship plan`). Triggers on: \"execute task TASK-NNN\", \"implement TASK-NNN\", \"run this task\", \"start working on TASK-NNN\", \"implement the task in [folder]\", \"run task from spec folder\", \"pick up the next task\", or a loop --order dispatch. Implements a task's acceptance criteria exactly — minimum code, surgical diffs, verified observable outcomes."
 ---
 
 # Task Executor (pure worker, v2.0)
@@ -23,8 +23,8 @@ rely on (anything absent = **unknown**; never invent it):
 
 | Field | What it is |
 |---|---|
-| `payload.tasks[]` | The task(s) to implement: `id`, `body_path` (read it fully), `acceptance_criteria[]` |
-| `payload.scope_contract` | The active scope: `affordance_manifest`, `e2e_verification_fixtures`, topology |
+| `payload.tasks[]` | The task(s) to implement: `id` and `body_path` — read the file fully; its acceptance criteria are in it |
+| `payload.scope_contract` | The path of the active scope's contract (`scopes/<id>.md`) — read it: `affordance_manifest`, `e2e_verification_fixtures`, topology |
 | `substrate.allowed` / `substrate.shared` | The ONLY globs you may write. A needed file outside them → ESCALATE, never a write (a sandbox hook blocks it anyway) |
 | `payload.decisions[]` | Adjudicated answers from prior escalations — binding precedent, apply them |
 | `payload.digested_errors[]` | `{file, line, core_message}` triples from the previous attempt's failed verification (a test that failed by name with no file:line — `FAIL TS-05-05 step 4: …` — arrives with `file: null` and the whole line as its message) — your starting bug list |
@@ -165,13 +165,13 @@ suffix come from `order_id`) matching `work-result.schema.json`, and print its p
 }
 ```
 
-`ac` carries the checkbox text **verbatim** — the ingest script ticks boxes by matching it.
+`ac` carries the checkbox text **verbatim** — the loop ticks boxes by matching it.
 Failing/skipped ACs are reported as such, never omitted. Discovered work is *reported*, never
 self-planned: no new task files, no spec edits — one raw line per discovery.
 
 You do NOT: tick AC boxes, edit `tasks/_index.md`, write `run-state.md`, touch the discovery
 ledger, mark anything done outside your result, or update any other spec document. The
-orchestrator's `harness reduce ingest` does all of that from your envelope.
+orchestrator's loop does all of that from your envelope.
 
 ---
 
@@ -191,20 +191,16 @@ orchestrator's `harness reduce ingest` does all of that from your envelope.
 ## Invocation
 
 ```bash
-# Orchestrated (tech-lead's build loop) — the canonical form
+# Orchestrated (the loop's build step) — the canonical form
 /task-executor --order .shapeup/checkout-vnpay/orders/r2-a3.json
 
-# Standalone — the preamble shim compiles a minimal WorkOrder from the flags, then the
-# single code path above runs. Requires the harness scripts (plugin install):
-#   node "<kernel>" compile --task TASK-003 --slug checkout-vnpay
-#   node "<kernel>" compile --next --slug checkout-vnpay
+# Standalone — the preamble shim writes a minimal WorkOrder by hand from the flags (the loop's
+# `resources/orders.md` has the shape), then the single code path above runs:
 /task-executor --spec shapeup/checkout-vnpay/spec/ --task TASK-003
 /task-executor --spec shapeup/checkout-vnpay/spec/ --next
 ```
 
-Standalone shim: derive `<slug>` from the `--spec` path (`shapeup/<slug>/spec`),
-run `harness compile` with the matching flags (mode becomes `standalone`), then proceed
-against the compiled order exactly as if dispatched. After writing the WorkResult, run
-`node "<kernel>" reduce ingest <result path>` yourself and show the user its
-summary — standalone has no orchestrator to ingest for you. One code path inside; two entry
+Standalone shim: derive `<slug>` from the `--spec` path (`shapeup/<slug>/spec`), write a minimal order
+by hand with `"mode": "standalone"`, then proceed against it exactly as if dispatched. After writing the
+WorkResult, show the user its summary — standalone has no orchestrator to apply it for you. One code path inside; two entry
 points outside.

package/commands/hill.md

@@ -1,10 +0,0 @@
----
-description: Render the Hill Chart dashboard — a portfolio of pitches, or one pitch's detail
----
-Use the **hill-chart** skill on $ARGUMENTS.
-
-Renders a self-contained dashboard from committed hill shards (`shapeup/<slug>/hill/*.yml`) and
-each pitch's local run graph (`.shapeup/<slug>/graph.jsonl`): a portfolio card per pitch, and
-per-pitch detail with a mechanical Hill Chart, an attention list, a scope board, round history,
-and the full run graph one click deeper. Give a slug to render one pitch only; no argument
-renders the whole portfolio.

package/hooks/gate-intake.mjs

@@ -1,109 +0,0 @@
-#!/usr/bin/env node
-// GATE L0.0 — intake precondition. PreToolUse hook.
-//
-// Denies a `tech-lead` dispatch that carries no pitch, no spec folder, and no requirement text.
-//
-// WHY THIS EXISTS (reproduced, not theorized). The orchestrator was reached as
-//
-//     Skill(tech-lead, args: "--unattended")
-//
-// — the flag survived the hand-off, the requirement text did not. With nothing to orchestrate,
-// the run printed the gate names, a confident plan, and wrote no code, while *looking* like a
-// successful run. The same harness invoked with --pitch/--spec built the feature. Whether a model
-// happens to inline the text and recover is a property of the model, not of the harness.
-//
-// That is the "agent claims done" failure this project exists to prevent, happening at the
-// project's own front door. Every other invariant that matters here lives in the runtime; this one
-// was living in a prompt, and a prompt is exactly what gets dropped on a hand-off. So it becomes a
-// hook, like GATE L2.
-//
-// Design mirrors the GATE L2 block deliberately:
-//   • Scope — only `Skill` → tech-lead. Anything else defers instantly.
-//   • Fail-CLOSED only on a provably empty intake, with an actionable re-invocation in the reason.
-//   • Fail-OPEN on anything ambiguous (unparseable payload, unknown arg shape, an envelope
-//     --order). A gate that blocks legitimate runs gets disabled, and a disabled gate enforces
-//     nothing.
-//
-// Contract: PreToolUse stdin JSON { tool_name, tool_input:{skill_name|skill, skill_args|args}, ... }
-// Deny via { hookSpecificOutput: { hookEventName, permissionDecision:"deny", permissionDecisionReason } }.
-
-// RECEIPTS (v1.5). This gate has been scored `No effect` on a re-run where the acceptance rate did
-// not move — because the hook CORRECTLY never fired and the cause was elsewhere. That distinction
-// is unprovable from a hook that answers "inspected and permitted" and "never ran" with the same
-// silence. Every decision below is now recorded (hooks/lib/decision.mjs).
-
-import { runHook, readStdin, settle } from "./lib/decision.mjs";
-
-await runHook("gate-intake", async () => {
-/** Fail-open, with the reason on the record. */
-const defer = (reason, rule) => settle({ verdict: "allow", event: "PreToolUse", tool: p?.tool_name ?? null, reason, rule });
-
-const raw = await readStdin();
-
-let p;
-try { p = JSON.parse(raw || "{}"); }
-catch (e) { settle({ verdict: "error", event: "PreToolUse", reason: `unparseable payload: ${e.message}` }); }
-
-if (p.tool_name !== "Skill") defer(`not a Skill call (${p.tool_name ?? "no tool_name"}) — out of scope`);
-
-// The Skill tool's field names differ by surface: `skill_name`/`skill_args` in the hook payload,
-// `skill`/`args` in the model-facing stream. Accept both — assuming one was already wrong once.
-const skillRaw = p.tool_input?.skill_name ?? p.tool_input?.skill ?? "";
-const args = String(p.tool_input?.skill_args ?? p.tool_input?.args ?? "");
-
-// Plugin skills arrive namespaced, e.g. "shapeup-sdlc-plugin:tech-lead".
-const skill = String(skillRaw).split(":").pop();
-if (skill !== "tech-lead") defer(`Skill(${skill}) is not the orchestrator — out of scope`);
-
-// The envelope port supplies its own intake; `harness verify envelope` owns that path.
-if (/--order\b/.test(args)) defer("envelope dispatch — validate-envelope owns this path", "--order");
-
-// Intake is satisfied by ANY of: a pitch path, a spec folder, or free requirement text.
-const hasPitch = /--pitch\s+\S/.test(args);
-const hasSpec = /--spec\s+\S/.test(args);
-const hasResume = /--from\s+\S/.test(args); // resuming an existing run has its state on disk
-
-// Free text = anything left once flags and their values are removed.
-// Every flag that TAKES A VALUE must be listed here. A flag whose value is not stripped reads as
-// free requirement text, and the gate then defers on an empty intake — the exact dispatch it
-// exists to deny. This is a live failure mode, not a hypothetical: adding `--gate-answers` and
-// `--wall-clock-budget` without listing them here silently blinded the gate, and the very next run
-// reached tech-lead as `args:"--unattended --gate-answers ci --wall-clock-budget 2400"` — no
-// requirement text at all — and was waved straight through, because "ci" and "2400" counted as
-// the spec.
-// Adding a valued flag anywhere in the harness means adding it here, and structural test §39
-// enforces exactly that against commands/ship.md.
-const VALUED_FLAGS = /--(pitch|spec|from|lens|rounds|attempts|parallel-scopes|orch-model|exec-model|eval-model|qa-model|feature|task|gate-answers|wall-clock-budget|slug|auto-level|max-rounds|intake-file|intake-text|spec-folder|cwd|out|by|preset|file|order|breadboard)\s+\S+/g;
-const BARE_FLAGS = /--[a-z0-9-]+/g;
-const freeText = args.replace(VALUED_FLAGS, " ").replace(BARE_FLAGS, " ").trim();
-
-if (hasPitch || hasSpec || hasResume || freeText.length > 0) {
-  const via = hasPitch ? "--pitch" : hasSpec ? "--spec" : hasResume ? "--from" : "free requirement text";
-  defer(`intake resolvable via ${via} — inspected and permitted`, via);
-}
-
-// Provably empty intake → deny, and say exactly how to fix it.
-const reason = [
-  "✋ GATE L0.0 — NO INTAKE. tech-lead was dispatched with no pitch, no spec folder, and no",
-  "requirement text; only flags survived the hand-off (args: " + JSON.stringify(args.slice(0, 80)) + ").",
-  "",
-  "An orchestrator with no spec has nothing to orchestrate. Proceeding would print the gate list",
-  "and build nothing — output that reads like a successful run and contains no work.",
-  "",
-  "Re-dispatch with the requirement text or an on-disk spec:",
-  "  Skill(tech-lead, \"<the full requirement text>\")",
-  "  Skill(tech-lead, \"--pitch <shaping.md> --spec <spec/>\")",
-].join("\n");
-
-return {
-  verdict: "deny", event: "PreToolUse", tool: "Skill", subject: "tech-lead", rule: "empty-intake",
-  reason: "no pitch, no spec folder, and no requirement text survived the hand-off",
-  payload: {
-    hookSpecificOutput: {
-      hookEventName: "PreToolUse",
-      permissionDecision: "deny",
-      permissionDecisionReason: reason,
-    },
-  },
-};
-});