@tekyzinc/gsd-t 2.71.11 → 2.71.13

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [2.71.13] - 2026-04-08
+
+### Fixed (design-decompose — successor hint)
+- **Next Up points to design-build** — `design-decompose` was recommending `partition` as the next step. The natural successor after decomposing contracts is `design-build` (which handles the tiered build with review gates), not `partition`. Updated the command's Step 9 hint and added `design-decompose → design-build` to the successor mapping table in CLAUDE-global template and live CLAUDE.md.
+
+## [2.71.12] - 2026-04-08
+
+### Changed (smart router — design-to-code pipeline)
+- **Pipeline Routing** — Smart router now treats design-to-code requests as a multi-step pipeline (clean → decompose → build) instead of picking a single command. When a user says "rebuild from this Figma" or "start from scratch with this design," the router evaluates pipeline entry point based on current state and auto-advances through subsequent steps.
+- **Entry Point Detection** — "start over" / "from scratch" / "clean slate" enters at clean step (removes UI assets, then decompose, then build). Missing design contracts enters at decompose. Existing contracts enters at build.
+- **Inline Cleanup** — Clean step removes UI component files while preserving non-UI files (API, stores, router config, project scaffold). No separate `quick` command needed.
+- **Design Command Slugs** — Added `design-decompose`, `design-build`, `design-audit`, `design-review` to valid router command slugs.
+
+### Why
+User gave the router a single prompt asking to delete old assets and rebuild from a Figma design. The router could only pick one command, so it had to choose between `quick` (cleanup) and `design-decompose` (contracts). The natural workflow is a pipeline that the router should execute end-to-end.
+
 ## [2.71.11] - 2026-04-08
 
 ### Fixed (design-build — review gates and measurement)

package/commands/gsd-t-design-decompose.md

@@ -468,13 +468,13 @@ Display:
 
 ## ▶ Next Up
 
-**Partition** — decompose project into domains owning the design contracts
+**Design Build** — build UI from contracts with tiered review gates (elements → widgets → pages)
 
-`/user:gsd-t-partition`
+`/user:gsd-t-design-build`
 
 **Also available:**
-- `/user:gsd-t-execute` — build element contracts first (they're independently testable)
-- `/user:gsd-t-plan` — plan tasks around the contract hierarchy
+- `/user:gsd-t-partition` — if you need domain boundaries before building
+- `/user:gsd-t-plan` — if you need task lists before building
 
 ───────────────────────────────────────────────────────────────
 ```

package/commands/gsd.md

@@ -59,14 +59,46 @@ When the same request could fit multiple commands at different scales:
 
 ### Design-to-code routing:
 
-When the request involves UI implementation from a design (Figma, screenshots, mockups, "pixel-perfect", "match the design", "rebuild the frontend"):
-- **NEVER route to `quick`** — design-to-code requires the full workflow with design contract, token extraction, and visual verification
+When the request involves UI implementation from a design (Figma URL, screenshots, mockups, "pixel-perfect", "match the design", "rebuild the frontend", "build from this Figma"):
+
+**This is a PIPELINE, not a single command.** The router must evaluate where the user is in the pipeline and execute from that point forward, auto-advancing through subsequent steps.
+
+**Pipeline order:**
+1. **Clean** (if requested) — remove existing UI assets via inline cleanup (not a separate `quick` command)
+2. **Decompose** — `design-decompose` to extract element → widget → page contracts from the Figma design
+3. **Build** — `design-build` to implement from contracts with review gates
+
+**Pipeline entry logic — evaluate these in order, enter at the first that applies:**
+
+| Condition | Entry point | Steps executed |
+|-----------|-------------|----------------|
+| User says "start over", "from scratch", "rebuild", "remove existing", "clean slate" | **Clean → Decompose → Build** | Remove existing UI assets in `src/components/`, `src/views/`, and related style files. Then run `design-decompose` with the Figma URL. Then run `design-build`. |
+| No design contracts exist (`.gsd-t/contracts/design/` missing or empty) | **Decompose → Build** | Run `design-decompose` with the Figma URL. Then run `design-build`. |
+| Design contracts exist but UI not yet built (contracts present, source files missing) | **Build** | Run `design-build` directly. |
+| Design contracts AND source files exist | **Build** | Run `design-build` (will measure existing components against contracts). |
+
+**How to execute the pipeline:**
+
+Route to the entry point command. At the end of that command, **auto-advance to the next pipeline step** — do not stop and ask the user. Display:
+```
+→ Design pipeline: {step 1} ✓ → {step 2} (starting) → {step 3} (pending)
+```
+
+**Clean step** (inline, not a separate command):
+When cleanup is needed, do it at the start of `design-decompose` before reading the Figma:
+- Remove UI component files (`src/components/`, `src/views/`, or equivalent)
+- Remove associated style files and test files for those components
+- Keep non-UI files (API services, stores, types, utilities, router config)
+- Keep the project scaffold (App.vue/tsx, main.ts, index.html)
+- `git add -A && git commit -m "chore: clean UI assets for design rebuild"`
+
+**NEVER route design-to-code requests to `quick`** — design-to-code requires the full pipeline with contracts, measurement, and review gates.
+
+**Fallback for non-pipeline design routing** (when the request is about an existing milestone/wave, not a fresh design build):
 - **If no active milestone exists** → route to `wave` (creates milestone → partition with design contract → plan → execute with visual verification)
 - **If a milestone exists but no domains** → route to `partition` (creates design contract in Step 3.6)
 - **If domains exist but no tasks** → route to `plan`
 - **If tasks exist** → route to `execute` (design-to-code stack rule will inject)
-- The design-to-code stack rule activates automatically when `.gsd-t/contracts/design-contract.md` OR `.gsd-t/contracts/design/` exists, or Figma MCP is configured — but the **partition step must run first** to create the design contract
-- **For projects with multiple pages or reusable components** (charts, widgets, design system): route to `design-decompose` BEFORE partition to create the hierarchical contract tree (elements → widgets → pages). Single-page/one-off designs can use flat `design-contract.md` created during partition instead.
 
 ## Step 3: Confirm and Execute
 
@@ -77,6 +109,13 @@ When the request involves UI implementation from a design (Figma, screenshots, m
 → Routing to /user:gsd-t-{command}: {brief reason}
 ```
 
+### Design pipeline (from design-to-code routing):
+```
+→ Design pipeline: clean → decompose → build
+  Starting: /user:gsd-t-design-decompose
+```
+Use this format when the router detects a design-to-code pipeline. Show the full pipeline with the current step highlighted. Auto-advance between steps without returning to the router.
+
 ### Continuation (from Step 2a):
 ```
 → /gsd ──▶ continue /user:gsd-t-{last-command}
@@ -102,7 +141,7 @@ Where `{last-command}` is:
 
 **CRITICAL: `{command}` and `{last-command}` MUST be a real GSD-T command slug — never a free-form description.**
 
-Valid command slugs: `quick`, `debug`, `feature`, `execute`, `milestone`, `project`, `scan`, `gap-analysis`, `plan`, `partition`, `discuss`, `impact`, `integrate`, `verify`, `test-sync`, `complete-milestone`, `wave`, `status`, `populate`, `setup`, `init`, `health`, `log`, `pause`, `resume`, `prd`, `brainstorm`, `prompt`, `backlog-add`, `backlog-list`, `backlog-promote`, `promote-debt`, `triage-and-merge`, `version-update`, `version-update-all`
+Valid command slugs: `quick`, `debug`, `feature`, `execute`, `milestone`, `project`, `scan`, `gap-analysis`, `plan`, `partition`, `discuss`, `impact`, `integrate`, `verify`, `test-sync`, `complete-milestone`, `wave`, `status`, `populate`, `setup`, `init`, `health`, `log`, `pause`, `resume`, `prd`, `brainstorm`, `prompt`, `backlog-add`, `backlog-list`, `backlog-promote`, `promote-debt`, `triage-and-merge`, `version-update`, `version-update-all`, `design-decompose`, `design-build`, `design-audit`, `design-review`
 
 **WRONG ❌** — do not do this:
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "2.71.11",
+  "version": "2.71.13",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 56 slash commands with headless CI/CD mode, graph-powered code analysis, real-time agent dashboard, execution intelligence, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/templates/CLAUDE-global.md

@@ -567,6 +567,7 @@ Successor mapping:
 | `gap-analysis` | `milestone` | `feature` |
 | `populate` | `status` | |
 | `setup` | `status` | |
+| `design-decompose` | `design-build` | `partition` (if domains needed first) |
 
 Commands with no successor (standalone): `quick`, `debug`, `brainstorm`, `status`, `help`, `resume`, `prompt`, `log`, `health`, `pause`, backlog commands.