@tekyzinc/gsd-t 3.12.12 → 3.12.13

package/commands/gsd-t-setup.md

@@ -192,7 +192,7 @@ Options:
   [2] web-app  — "User-facing app: accessible, performant, visually consistent. UX is the product."
   [3] cli      — "Developer CLI: fast, predictable, clear output. Error messages explain what went wrong and how to fix it."
   [4] custom   — Write your own 1–3 sentences
-  [5] skip     — No Quality North Star (can add later via /user:gsd-t-setup)
+  [5] skip     — No Quality North Star (can add later via /gsd-t-setup)
 ```
 
 If the user picks 1–3, use the corresponding preset text from the table below.
@@ -240,7 +240,7 @@ Would you like to generate a design brief at .gsd-t/contracts/design-brief.md?
 This gives subagents a consistent visual language reference (colors, typography, spacing, patterns).
 
   [1] Yes — generate now (sources: Tailwind config if exists, then project defaults)
-  [2] No — skip for now (can generate later by re-running /user:gsd-t-setup)
+  [2] No — skip for now (can generate later by re-running /gsd-t-setup)
 ```
 
 If user picks 1: generate `.gsd-t/contracts/design-brief.md` using the format defined in `.gsd-t/contracts/design-brief-contract.md` (or the standard format):

package/commands/gsd-t-test-sync.md

@@ -322,7 +322,7 @@ Full sync:
 
 ### Standalone Mode:
 ```
-/user:gsd-t-test-sync
+/gsd-t-test-sync
 ```
 1. Full analysis of entire codebase
 2. Comprehensive report

package/commands/gsd-t-unattended-watch.md

@@ -2,7 +2,7 @@
 
 **Model**: haiku (polling a state file is mechanical — no reasoning needed)
 
-You are running one tick of the unattended supervisor watch loop. This command is **stateless**: every firing re-reads `.gsd-t/.unattended/supervisor.pid` + `state.json` + `run.log` from disk and makes a fresh decision. There is no in-memory state between ticks, and a `/clear` followed by `/user:gsd-t-resume` during a live unattended run is a no-op.
+You are running one tick of the unattended supervisor watch loop. This command is **stateless**: every firing re-reads `.gsd-t/.unattended/supervisor.pid` + `state.json` + `run.log` from disk and makes a fresh decision. There is no in-memory state between ticks, and a `/clear` followed by `/gsd-t-resume` during a live unattended run is a no-op.
 
 The watch loop is the user's visibility surface into the running supervisor. It fires every 270 seconds (inside the 5-minute prompt-cache TTL) and either:
 1. Renders a compact status block + reschedules itself, OR
@@ -245,7 +245,7 @@ The supervisor process is gone but it did not remove its PID file — this is a
 
     Recovery: inspect .gsd-t/.unattended/run.log and .gsd-t/.unattended/state.json.
     Remove the stale PID file with: rm .gsd-t/.unattended/supervisor.pid
-    Then relaunch with: /user:gsd-t-unattended
+    Then relaunch with: /gsd-t-unattended
 ```
 
 **STOP** — do NOT reschedule. End the turn.
@@ -296,7 +296,7 @@ The supervisor is still alive but has transitioned to a terminal status on its l
     Total elapsed: {Hh Mm}
     Log:           {LOG_PATH}
 
-    Stop sentinel was honored between worker iterations. Relaunch with /user:gsd-t-unattended.
+    Stop sentinel was honored between worker iterations. Relaunch with /gsd-t-unattended.
 ```
 
 **STOP** — do NOT reschedule. End the turn.
@@ -321,7 +321,7 @@ Format rules:
 📋  Tasks: {TASKS_DONE}/{TASKS_TOTAL} [{progress bar}] · elapsed {Hh Mm}
 🔧  {DOMAIN_SUMMARY or "No domains yet (pre-partition)"}
 ⏱  Iter {ITER}/{MAX_ITER} · last tick {tickAge} · last exit {LAST_EXIT} ({durationSec}s)
-⏰  Next tick in 270s · Stop: /user:gsd-t-unattended-stop
+⏰  Next tick in 270s · Stop: /gsd-t-unattended-stop
 ```
 
 Progress bar rendering (8 chars wide):
@@ -392,7 +392,7 @@ After the tool call, end the turn. Do NOT output a "Next Up" hint, do NOT contin
 ## Notes
 
 - **Stateless**: every tick re-reads state from disk. No memory between firings.
-- **Terminal = STOP**: any terminal branch (3, 4, 5) ends the loop. The user relaunches via `/user:gsd-t-unattended` if needed.
+- **Terminal = STOP**: any terminal branch (3, 4, 5) ends the loop. The user relaunches via `/gsd-t-unattended` if needed.
 - **Never spawn subagents**: this is a pure polling command — no Task, no TeamCreate, no observability logging block.
 - **No branch guard, no pre-commit gate, no doc ripple**: this command does not modify any files.
 - **Stale-tick tolerance**: if `lastTick` is >540s old but PID is still alive, warn soft (`⚠️  stale`) but still reschedule — the supervisor may be mid-worker.

package/commands/gsd-t-unattended.md

@@ -16,7 +16,7 @@ Run via Bash:
 
 ```bash
 if [ ! -f ".gsd-t/progress.md" ]; then
-  echo "ERROR: .gsd-t/progress.md not found — not a GSD-T project. Run /user:gsd-t-init first."
+  echo "ERROR: .gsd-t/progress.md not found — not a GSD-T project. Run /gsd-t-init first."
   exit 1
 fi
 ```
@@ -61,10 +61,10 @@ If `PID_RUNNING=true`, **STOP** and print:
 ```
 🔴  Unattended supervisor is already running (PID {PID}).
 
-    Use /user:gsd-t-unattended-stop to request a clean halt, then wait for the
+    Use /gsd-t-unattended-stop to request a clean halt, then wait for the
     watch loop to confirm it has stopped before relaunching.
 
-    To just watch the current run: /user:gsd-t-unattended-watch
+    To just watch the current run: /gsd-t-unattended-watch
 ```
 
 Do NOT spawn a second supervisor. End the turn.
@@ -137,7 +137,7 @@ The `/gsd-t-resume` worker already knows how to chain through phases automatical
      ```
      ❌  No active milestone found and none identifiable from context.
 
-         Specify one explicitly: /user:gsd-t-unattended --milestone=M1
+         Specify one explicitly: /gsd-t-unattended --milestone=M1
      ```
    - **STOP.** Do NOT spawn.
 
@@ -230,7 +230,7 @@ If `PREFLIGHT=fail`, **STOP** and print:
       • {name}
         Install: {install}
 
-    Install the missing software and retry: /user:gsd-t-unattended
+    Install the missing software and retry: /gsd-t-unattended
 ```
 
 End the turn. Do NOT spawn.
@@ -393,7 +393,7 @@ If `LIVENESS=dead`, the supervisor crashed at startup. Print diagnostics and **S
       • Protected branch or dirty worktree rejected by safety rails
       • Permissions error on .gsd-t/.unattended/ directory
 
-    Fix the issue above and retry: /user:gsd-t-unattended
+    Fix the issue above and retry: /gsd-t-unattended
 ```
 
 End the turn without scheduling a watch tick.
@@ -415,8 +415,8 @@ Print the launch confirmation block:
     Watch:          ScheduleWakeup every 270s
 
     The supervisor is running detached — it survives /clear and terminal close.
-    Stop gracefully: /user:gsd-t-unattended-stop
-    Watch manually:  /user:gsd-t-unattended-watch
+    Stop gracefully: /gsd-t-unattended-stop
+    Watch manually:  /gsd-t-unattended-watch
 ```
 
 ## Step 5: Schedule the First Watch Tick
@@ -446,6 +446,6 @@ After the tool call, end the turn. The in-session watch loop takes over from her
 - **Platform helper**: uses `spawnSupervisor` from `bin/gsd-t-unattended-platform.cjs` — never hand-rolls `child_process.spawn` directly. This handles macOS/Linux/Windows differences.
 - **Dry-run**: `--dry-run` prints the would-be invocation without spawning. Useful for validating flags before a long overnight run.
 - **No doc ripple, no pre-commit gate**: this command spawns a background process; it does not modify any source files or contracts.
-- **watch command is stateless**: after this command returns, every `/user:gsd-t-unattended-watch` tick re-reads state from disk. There is no in-memory state to preserve.
+- **watch command is stateless**: after this command returns, every `/gsd-t-unattended-watch` tick re-reads state from disk. There is no in-memory state to preserve.
 
 $ARGUMENTS

package/commands/gsd-t-wave.md

@@ -49,7 +49,7 @@ After reading progress.md, verify it contains the required fields before proceed
 - **Domains table**: A `| Domain |` table with at least one row
 
 If ANY of these are missing or malformed, STOP and report:
-"Wave cannot proceed — progress.md is missing required fields: {list}. Run `/user:gsd-t-status` to inspect, or `/user:gsd-t-init` to repair."
+"Wave cannot proceed — progress.md is missing required fields: {list}. Run `/gsd-t-status` to inspect, or `/gsd-t-init` to repair."
 Do NOT attempt to fix progress.md yourself — that risks data loss.
 
 ## Step 2: Determine Resume Point
@@ -304,8 +304,8 @@ Summary:
 
 Next steps:
 - Push tag: git push origin milestone/{name}
-- Start next: /user:gsd-t-milestone "{next}"
-- View roadmap: /user:gsd-t-status
+- Start next: /gsd-t-milestone "{next}"
+- View roadmap: /gsd-t-status
 ═══════════════════════════════════════════════════════════════════════════════
 ```
 
@@ -313,7 +313,7 @@ Next steps:
 
 If the user interrupts or a phase agent fails:
 1. The current phase agent saves its own state to `.gsd-t/progress.md`
-2. Report: "Paused at {phase}. Run `/user:gsd-t-resume` to continue."
+2. Report: "Paused at {phase}. Run `/gsd-t-resume` to continue."
 3. Resume will pick up from the last completed phase
 
 ## Error Recovery

package/commands/gsd.md

@@ -28,7 +28,7 @@ Before semantic evaluation, determine if this is a **continuation** of an alread
 
 For non-continuation messages, decide whether the request is **conversational** (user is thinking, exploring, or articulating — no command spawn) or **workflow** (user wants work done — route to a GSD-T command via Step 2).
 
-This step replaces the retired `/user:gsd-t-prompt`, `/user:gsd-t-brainstorm`, and `/user:gsd-t-discuss` commands, whose use cases the router now handles inline.
+This step replaces the retired `/gsd-t-prompt`, `/gsd-t-brainstorm`, and `/gsd-t-discuss` commands, whose use cases the router now handles inline.
 
 ### Conversational triggers (respond inline, NO command spawn):
 
@@ -74,7 +74,7 @@ Read the **Command Summaries** section of `commands/gsd-t-help.md` (or the in-me
 - **1 match** → Route immediately
 - **2+ matches** → Pick the best fit based on scope and context. Show the runner-up:
   ```
-  → Routing to /user:gsd-t-{command}: {reason}
+  → Routing to /gsd-t-{command}: {reason}
     (also considered: gsd-t-{runner-up} — Esc to switch)
   ```
 
@@ -136,7 +136,7 @@ When cleanup is needed, do it at the start of `design-decompose` before reading
 
 ### New request (from Step 2):
 ```
-→ Routing to /user:gsd-t-{command}: {brief reason}
+→ Routing to /gsd-t-{command}: {brief reason}
 ```
 
 ### Conversational (from Step 2.5):
@@ -148,13 +148,13 @@ Follow this header with your direct in-line response — ask clarifying question
 ### Design pipeline (from design-to-code routing):
 ```
 → Design pipeline: clean → decompose → build
-  Starting: /user:gsd-t-design-decompose
+  Starting: /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}
+→ /gsd ──▶ continue /gsd-t-{last-command}
 ```
 
 Where `{last-command}` is:
@@ -188,10 +188,10 @@ Valid command slugs: `quick`, `debug`, `feature`, `execute`, `milestone`, `proje
 
 **RIGHT ✅** — always use the exact command slug:
 ```
-→ Routing to /user:gsd-t-execute: implement auth feature across backend
-→ Routing to /user:gsd-t-debug: investigate login bug before fixing
-→ /gsd ──▶ continue /user:gsd-t-execute
-→ /gsd ──▶ continue /user:gsd-t-quick
+→ Routing to /gsd-t-execute: implement auth feature across backend
+→ Routing to /gsd-t-debug: investigate login bug before fixing
+→ /gsd ──▶ continue /gsd-t-execute
+→ /gsd ──▶ continue /gsd-t-quick
 ```
 
 This MUST be the very first line of your response. Then immediately execute that command's full workflow, passing `$ARGUMENTS` through.
@@ -203,16 +203,16 @@ This MUST be the very first line of your response. Then immediately execute that
 If called with no arguments, show:
 
 ```
-Usage: /user:gsd {describe what you want}
+Usage: /gsd {describe what you want}
 
 Examples:
-  /user:gsd Fix the login timeout bug
-  /user:gsd Add dark mode support
-  /user:gsd Scan the codebase for tech debt
-  /user:gsd What's the current progress?
-  /user:gsd Compare this spec against our code
-  /user:gsd Help me think through this integration before I start
-  /user:gsd I'm stuck — what are other angles?
+  /gsd Fix the login timeout bug
+  /gsd Add dark mode support
+  /gsd Scan the codebase for tech debt
+  /gsd What's the current progress?
+  /gsd Compare this spec against our code
+  /gsd Help me think through this integration before I start
+  /gsd I'm stuck — what are other angles?
 
 I'll route to the right GSD-T command — or just think out loud with you
 if you're still figuring things out (no command spawn).

package/docs/GSD-T-README.md

@@ -24,34 +24,34 @@ cd my-project
 claude
 
 # 2. Full onboarding (git + init + scan + setup in one)
-/user:gsd-t-init-scan-setup
+/gsd-t-init-scan-setup
 
 # Or step by step:
-/user:gsd-t-init my-project
+/gsd-t-init my-project
 
 # 3. Define what you're building
-/user:gsd-t-milestone "User Authentication System"
+/gsd-t-milestone "User Authentication System"
 
 # 5. Let it rip (auto-advances through all phases)
-/user:gsd-t-wave
+/gsd-t-wave
 
 # Or go phase by phase for more control:
-/user:gsd-t-partition
-/user:gsd-t-discuss
-/user:gsd-t-plan
-/user:gsd-t-impact
-/user:gsd-t-execute
-/user:gsd-t-test-sync
-/user:gsd-t-integrate
-/user:gsd-t-verify
-/user:gsd-t-complete-milestone
+/gsd-t-partition
+/gsd-t-discuss
+/gsd-t-plan
+/gsd-t-impact
+/gsd-t-execute
+/gsd-t-test-sync
+/gsd-t-integrate
+/gsd-t-verify
+/gsd-t-complete-milestone
 ```
 
 ## Resuming After a Break
 
 ```bash
 claude
-/user:gsd-t-resume
+/gsd-t-resume
 ```
 
 GSD-T reads all state files and tells you exactly where you left off.
@@ -64,86 +64,86 @@ GSD-T reads all state files and tells you exactly where you left off.
 
 | Command | Purpose | Auto |
 |---------|---------|------|
-| `/user:gsd {request}` | Describe what you need → auto-routes to the right command | Manual |
+| `/gsd {request}` | Describe what you need → auto-routes to the right command | Manual |
 | _(any plain text)_ | Auto-routed via UserPromptSubmit hook — no leading `/` needed | Auto |
 
 ### Help & Onboarding
 
 | Command | Purpose | Auto |
 |---------|---------|------|
-| `/user:gsd-t-help` | List all commands with descriptions | Manual |
-| `/user:gsd-t-help {cmd}` | Detailed help for specific command | Manual |
-| `/user:gsd-t-prompt` | Help formulate your idea before committing | Manual |
-| `/user:gsd-t-brainstorm` | Creative exploration and idea generation | Manual |
-| `/user:gsd-t-prd` | Generate a GSD-T-optimized Product Requirements Document | Manual |
+| `/gsd-t-help` | List all commands with descriptions | Manual |
+| `/gsd-t-help {cmd}` | Detailed help for specific command | Manual |
+| `/gsd-t-prompt` | Help formulate your idea before committing | Manual |
+| `/gsd-t-brainstorm` | Creative exploration and idea generation | Manual |
+| `/gsd-t-prd` | Generate a GSD-T-optimized Product Requirements Document | Manual |
 
 ### Project Initialization
 
 | Command | Purpose | Auto |
 |---------|---------|------|
-| `/user:gsd-t-setup` | Generate or restructure project CLAUDE.md | Manual |
-| `/user:gsd-t-init` | Initialize GSD-T structure in project | Manual |
-| `/user:gsd-t-init-scan-setup` | Full onboarding: git + init + scan + setup in one | Manual |
-| `/user:gsd-t-project` | Full project → milestone roadmap | Manual |
-| `/user:gsd-t-feature` | Major feature → impact analysis + milestones | Manual |
-| `/user:gsd-t-scan` | Deep codebase analysis → techdebt.md | Manual |
-| `/user:gsd-t-gap-analysis` | Requirements gap analysis — spec vs. existing code | Manual |
-| `/user:gsd-t-promote-debt` | Convert techdebt items to milestones | Manual |
-| `/user:gsd-t-populate` | Auto-populate docs from existing codebase | Manual |
-| `/user:gsd-t-design-decompose` | Decompose design into element/widget/page contracts | Manual |
+| `/gsd-t-setup` | Generate or restructure project CLAUDE.md | Manual |
+| `/gsd-t-init` | Initialize GSD-T structure in project | Manual |
+| `/gsd-t-init-scan-setup` | Full onboarding: git + init + scan + setup in one | Manual |
+| `/gsd-t-project` | Full project → milestone roadmap | Manual |
+| `/gsd-t-feature` | Major feature → impact analysis + milestones | Manual |
+| `/gsd-t-scan` | Deep codebase analysis → techdebt.md | Manual |
+| `/gsd-t-gap-analysis` | Requirements gap analysis — spec vs. existing code | Manual |
+| `/gsd-t-promote-debt` | Convert techdebt items to milestones | Manual |
+| `/gsd-t-populate` | Auto-populate docs from existing codebase | Manual |
+| `/gsd-t-design-decompose` | Decompose design into element/widget/page contracts | Manual |
 
 ### Milestone Workflow
 
 | Command | Purpose | Auto |
 |---------|---------|------|
-| `/user:gsd-t-milestone` | Define new milestone | Manual |
-| `/user:gsd-t-partition` | Decompose into domains + contracts | In wave |
-| `/user:gsd-t-discuss` | Multi-perspective design exploration | In wave |
-| `/user:gsd-t-plan` | Create atomic task lists per domain (tasks auto-split to fit one context window) | In wave |
-| `/user:gsd-t-impact` | Analyze downstream effects | In wave |
-| `/user:gsd-t-execute` | Run tasks — task-level fresh dispatch, worktree isolation, adaptive replanning, stack rules injection | In wave |
-| `/user:gsd-t-test-sync` | Sync tests with code changes | In wave |
-| `/user:gsd-t-qa` | QA agent — test generation, execution, gap reporting | Auto-spawned |
+| `/gsd-t-milestone` | Define new milestone | Manual |
+| `/gsd-t-partition` | Decompose into domains + contracts | In wave |
+| `/gsd-t-discuss` | Multi-perspective design exploration | In wave |
+| `/gsd-t-plan` | Create atomic task lists per domain (tasks auto-split to fit one context window) | In wave |
+| `/gsd-t-impact` | Analyze downstream effects | In wave |
+| `/gsd-t-execute` | Run tasks — task-level fresh dispatch, worktree isolation, adaptive replanning, stack rules injection | In wave |
+| `/gsd-t-test-sync` | Sync tests with code changes | In wave |
+| `/gsd-t-qa` | QA agent — test generation, execution, gap reporting | Auto-spawned |
 | *Red Team* | Adversarial QA — spawns after QA passes to find bugs the builder missed | Auto-spawned |
-| `/user:gsd-t-doc-ripple` | Automated document ripple — update downstream docs after code changes | Auto-spawned |
-| `/user:gsd-t-integrate` | Wire domains together | In wave |
-| `/user:gsd-t-verify` | Run quality gates + goal-backward verification → auto-invokes complete-milestone | In wave |
-| `/user:gsd-t-complete-milestone` | Archive + git tag (auto-invoked by verify, also standalone) | In wave |
+| `/gsd-t-doc-ripple` | Automated document ripple — update downstream docs after code changes | Auto-spawned |
+| `/gsd-t-integrate` | Wire domains together | In wave |
+| `/gsd-t-verify` | Run quality gates + goal-backward verification → auto-invokes complete-milestone | In wave |
+| `/gsd-t-complete-milestone` | Archive + git tag (auto-invoked by verify, also standalone) | In wave |
 
 ### Automation & Utilities
 
 | Command | Purpose | Auto |
 |---------|---------|------|
-| `/user:gsd-t-unattended` | Launch detached supervisor — runs active milestone to completion with zero human intervention | Manual |
-| `/user:gsd-t-unattended-watch` | Watch tick — fires every 270s via ScheduleWakeup, reports supervisor status | Auto |
-| `/user:gsd-t-unattended-stop` | Touch stop sentinel — supervisor halts after current worker finishes | Manual |
-| `/user:gsd-t-wave` | Full cycle, auto-advances all phases | Manual |
-| `/user:gsd-t-status` | Cross-domain progress view with token breakdown, global ELO and cross-project rankings | Manual |
-| `/user:gsd-t-resume` | Restore context, continue | Manual |
-| `/user:gsd-t-quick` | Fast task with GSD-T guarantees | Manual |
-| `/user:gsd-t-visualize` | Launch browser dashboard — SSE server + React Flow agent visualization | Manual |
-| `/user:gsd-t-debug` | Systematic debugging with state | Manual |
-| `/user:gsd-t-metrics` | View task telemetry, process ELO, signal distribution, domain health, and cross-project comparison (`--cross-project`) | Manual |
-| `/user:gsd-t-health` | Validate .gsd-t/ structure, optionally repair | Manual |
-| `/user:gsd-t-pause` | Save exact position for reliable resume | Manual |
-| `/user:gsd-t-log` | Sync progress Decision Log with recent git activity | Manual |
-| `/user:gsd-t-version-update` | Update GSD-T to latest version | Manual |
-| `/user:gsd-t-version-update-all` | Update GSD-T + all registered projects | Manual |
-| `/user:gsd-t-triage-and-merge` | Auto-review, merge, and publish GitHub branches | Manual |
-| `/user:gsd-t-design-audit` | Compare built screen against Figma — per-widget deviation report with severity | Manual |
+| `/gsd-t-unattended` | Launch detached supervisor — runs active milestone to completion with zero human intervention | Manual |
+| `/gsd-t-unattended-watch` | Watch tick — fires every 270s via ScheduleWakeup, reports supervisor status | Auto |
+| `/gsd-t-unattended-stop` | Touch stop sentinel — supervisor halts after current worker finishes | Manual |
+| `/gsd-t-wave` | Full cycle, auto-advances all phases | Manual |
+| `/gsd-t-status` | Cross-domain progress view with token breakdown, global ELO and cross-project rankings | Manual |
+| `/gsd-t-resume` | Restore context, continue | Manual |
+| `/gsd-t-quick` | Fast task with GSD-T guarantees | Manual |
+| `/gsd-t-visualize` | Launch browser dashboard — SSE server + React Flow agent visualization | Manual |
+| `/gsd-t-debug` | Systematic debugging with state | Manual |
+| `/gsd-t-metrics` | View task telemetry, process ELO, signal distribution, domain health, and cross-project comparison (`--cross-project`) | Manual |
+| `/gsd-t-health` | Validate .gsd-t/ structure, optionally repair | Manual |
+| `/gsd-t-pause` | Save exact position for reliable resume | Manual |
+| `/gsd-t-log` | Sync progress Decision Log with recent git activity | Manual |
+| `/gsd-t-version-update` | Update GSD-T to latest version | Manual |
+| `/gsd-t-version-update-all` | Update GSD-T + all registered projects | Manual |
+| `/gsd-t-triage-and-merge` | Auto-review, merge, and publish GitHub branches | Manual |
+| `/gsd-t-design-audit` | Compare built screen against Figma — per-widget deviation report with severity | Manual |
 | `/global-change` | Apply file changes (copy/insert/update/delete) across all GSD-T projects | Manual |
 
 ### Backlog Management
 
 | Command | Purpose | Auto |
 |---------|---------|------|
-| `/user:gsd-t-backlog-add` | Capture item, auto-categorize, append to backlog | Manual |
-| `/user:gsd-t-backlog-list` | Filtered, ordered view of backlog items | Manual |
-| `/user:gsd-t-backlog-move` | Reorder items by position (priority) | Manual |
-| `/user:gsd-t-backlog-edit` | Modify backlog entry fields | Manual |
-| `/user:gsd-t-backlog-remove` | Drop item with optional reason | Manual |
-| `/user:gsd-t-backlog-promote` | Refine, classify, launch GSD-T workflow | Manual |
-| `/user:gsd-t-backlog-settings` | Manage types, apps, categories, defaults | Manual |
+| `/gsd-t-backlog-add` | Capture item, auto-categorize, append to backlog | Manual |
+| `/gsd-t-backlog-list` | Filtered, ordered view of backlog items | Manual |
+| `/gsd-t-backlog-move` | Reorder items by position (priority) | Manual |
+| `/gsd-t-backlog-edit` | Modify backlog entry fields | Manual |
+| `/gsd-t-backlog-remove` | Drop item with optional reason | Manual |
+| `/gsd-t-backlog-promote` | Refine, classify, launch GSD-T workflow | Manual |
+| `/gsd-t-backlog-settings` | Manage types, apps, categories, defaults | Manual |
 
 ---
 
@@ -293,7 +293,7 @@ Run the active milestone to completion over hours or days with zero human interv
 
 **Relay model**: Each iteration spawns a fresh `claude -p` session with a compact prompt derived from `.gsd-t/progress.md` state. The supervisor waits for the worker to exit, records the exit code in `state.json`, runs safety checks (gutter detection, blocker sentinel scan), and spawns the next worker. Workers never overlap. Context rot is impossible — each worker starts clean.
 
-**Watch loop**: `/user:gsd-t-unattended` starts an in-session ScheduleWakeup loop that ticks every 270 seconds. Each tick reads `state.json` and `supervisor.pid` to render a live progress block. When the supervisor reaches a terminal state (`done`, `failed`, `stopped`), the watch loop stops rescheduling and prints a final summary. A `/clear` + `/user:gsd-t-resume` transparently re-attaches: the resume command checks for a live `supervisor.pid` and re-starts the watch loop automatically.
+**Watch loop**: `/gsd-t-unattended` starts an in-session ScheduleWakeup loop that ticks every 270 seconds. Each tick reads `state.json` and `supervisor.pid` to render a live progress block. When the supervisor reaches a terminal state (`done`, `failed`, `stopped`), the watch loop stops rescheduling and prints a final summary. A `/clear` + `/gsd-t-resume` transparently re-attaches: the resume command checks for a live `supervisor.pid` and re-starts the watch loop automatically.
 
 **Safety rails**: Branch protection (refuses to run on `main`/`master`/`release/*` by default), dirty-tree check (whitelists GSD-T runtime files), per-iteration gutter detection (repeated error patterns, file thrash, no-progress stall), wall-clock and iteration caps, and a blocker sentinel that halts on unrecoverable worker errors.
 
@@ -405,7 +405,7 @@ copy *.md %USERPROFILE%\.claude\commands\
 cp *.md ~/.claude/commands/
 ```
 
-Verify with: `/user:gsd-t-help`
+Verify with: `/gsd-t-help`
 
 ---
 

package/docs/architecture.md

@@ -52,7 +52,7 @@ The framework has no runtime — it is consumed entirely by Claude Code's slash
 - **Pre-task experience retrieval (execute, debug)**: Grep Decision Log for `[failure]`/`[learning]` entries matching current domain before spawning subagent — Reflexion pattern without fine-tuning. Writes `experience_retrieval` event.
 - **Distillation step (complete-milestone Step 2.5)**: Scans `.gsd-t/events/*.jsonl` for patterns seen ≥3 times, proposes CLAUDE.md / constraints.md rule additions, user confirms before write.
 ### Auto-Route + Auto-Update Hooks (M16 — complete)
-- **`scripts/gsd-t-auto-route.js`** (39 lines): UserPromptSubmit hook. Reads JSON from stdin (`{ prompt, cwd, session_id }`). If `.gsd-t/progress.md` does not exist in cwd → exits silently. If prompt starts with `/` → exits silently. If plain text in a GSD-T project → emits `[GSD-T AUTO-ROUTE]` signal to Claude's context, routing the message through `/user:gsd`. Catches all exceptions — never blocks the prompt.
+- **`scripts/gsd-t-auto-route.js`** (39 lines): UserPromptSubmit hook. Reads JSON from stdin (`{ prompt, cwd, session_id }`). If `.gsd-t/progress.md` does not exist in cwd → exits silently. If prompt starts with `/` → exits silently. If plain text in a GSD-T project → emits `[GSD-T AUTO-ROUTE]` signal to Claude's context, routing the message through `/gsd`. Catches all exceptions — never blocks the prompt.
 - **`scripts/gsd-t-update-check.js`** (79 lines): SessionStart hook. Reads `~/.claude/.gsd-t-version`. Reads/refreshes `~/.claude/.gsd-t-update-check` cache (1h TTL). If newer version available: runs `npm install -g @tekyzinc/gsd-t@{latest}` + `gsd-t update-all` via execSync. Outputs `[GSD-T AUTO-UPDATE]`, `[GSD-T UPDATE]`, or `[GSD-T]` banner. NOTE: No module.exports — untestable as module (TD-081). Version string not validated before execSync (SEC-N28).
 
 ### Scan Visual Output (M17 — complete v2.34.10)
@@ -72,9 +72,9 @@ The framework has no runtime — it is consumed entirely by Claude Code's slash
 
 ### Headless Mode (M23 — complete)
 - **doHeadless(args)**: Dispatch function for the `headless` CLI subcommand.
-- **doHeadlessExec(command, cmdArgs, flags)**: Wraps `claude -p "/gsd-t-{command}"` via `execFileSync`. Verifies claude CLI availability, enforces timeout, writes log file if `--log` requested. Returns structured JSON if `--json` flag set. (M36 Phase 0: prompt form is `/gsd-t-X`, NOT `/user:gsd-t-X` — non-interactive mode rejects the `/user:` namespace prefix.)
+- **doHeadlessExec(command, cmdArgs, flags)**: Wraps `claude -p "/gsd-t-{command}"` via `execFileSync`. Verifies claude CLI availability, enforces timeout, writes log file if `--log` requested. Returns structured JSON if `--json` flag set. (M36 Phase 0: prompt form is `/gsd-t-X`, NOT `/gsd-t-X` — non-interactive mode rejects the `/` namespace prefix.)
 - **parseHeadlessFlags(args)**: Extracts `--json`, `--timeout=N`, `--log` from raw args. Returns `{ flags, positional }`.
-- **buildHeadlessCmd(command, cmdArgs)**: Builds the bare `/gsd-t-{command}` prompt string. Interactive-mode `/user:` prefix deliberately omitted — see `.gsd-t/M36-spike-findings.md` Spike A.
+- **buildHeadlessCmd(command, cmdArgs)**: Builds the bare `/gsd-t-{command}` prompt string. Interactive-mode `/` prefix deliberately omitted — see `.gsd-t/M36-spike-findings.md` Spike A.
 - **mapHeadlessExitCode(processExitCode, output)**: Maps process exit code + output text patterns to GSD-T exit codes (0–5).
 - **headlessLogPath(projectDir, timestamp)**: Generates `.gsd-t/headless-{timestamp}.log` path.
 - **doHeadlessQuery(type)**: Dispatches to one of 7 query functions. All pure Node.js file reads, no LLM calls, <100ms.
@@ -130,7 +130,7 @@ gsd-t init [name] → templates/ → applyTokens()
 
 ### Runtime Command Execution (within Claude Code)
 ```
-User types /user:gsd-t-{command} [args]
+User types /gsd-t-{command} [args]
   → Claude Code loads ~/.claude/commands/gsd-t-{command}.md
   → Claude interprets step-by-step instructions
   → Reads state files → Executes workflow → Pre-Commit Gate → Updates progress.md
@@ -284,7 +284,7 @@ The unattended supervisor is a cross-session relay engine that runs an active GS
 
 ```
 Interactive Claude session
-  └── /user:gsd-t-unattended (launch command)
+  └── /gsd-t-unattended (launch command)
         ├── Pre-flight safety checks (branch, dirty tree)
         └── spawn(detached) → Supervisor process (bin/gsd-t-unattended.js)
                                ├── writes .gsd-t/.unattended/supervisor.pid
@@ -296,7 +296,7 @@ Interactive Claude session
                                       → worker exits → post-worker safety check → next iter
 
 In-session watch loop (every 270s via ScheduleWakeup)
-  └── /user:gsd-t-unattended-watch
+  └── /gsd-t-unattended-watch
         ├── reads supervisor.pid  (kill -0 liveness)
         ├── reads state.json      (status, iter, lastTick)
         └── reschedules or reports final status
@@ -349,7 +349,7 @@ Closes the M35 parent/child race in `bin/headless-auto-spawn.js`. When the runwa
 
 ### Resume Auto-Reattach
 
-`/user:gsd-t-resume` Step 0 checks for a live supervisor before any other resume logic. If `supervisor.pid` exists and `kill -0` succeeds and `state.json.status` is non-terminal, the resume command skips normal resume flow entirely, prints the current watch block, and calls `ScheduleWakeup(270, '/gsd-t-unattended-watch', ...)`. The user transparently re-enters the watch loop without any manual step.
+`/gsd-t-resume` Step 0 checks for a live supervisor before any other resume logic. If `supervisor.pid` exists and `kill -0` succeeds and `state.json.status` is non-terminal, the resume command skips normal resume flow entirely, prints the current watch block, and calls `ScheduleWakeup(270, '/gsd-t-unattended-watch', ...)`. The user transparently re-enters the watch loop without any manual step.
 
 ---
 
@@ -533,7 +533,7 @@ Orchestrator Context Gate — v3.0.0 semantics:
 
 **Supporting components** (outside the context-meter dataflow):
 - `bin/model-selector.js` — declarative rules table mapping phases to haiku/sonnet/opus; consulted at plan time, never at runtime under pressure
-- `bin/check-headless-sessions.js` — renders the read-back banner on `/user:gsd-t-resume` and `/user:gsd-t-status` for completed-but-not-yet-surfaced headless sessions
+- `bin/check-headless-sessions.js` — renders the read-back banner on `/gsd-t-resume` and `/gsd-t-status` for completed-but-not-yet-surfaced headless sessions
 - `bin/event-stream.cjs` (M38) — shared library for JSONL event emission and cursor-based tailing; used by supervisor, watch tick, and dashboard
 
 **Installer integration** (`bin/gsd-t.js`):

package/docs/context-budget-recovery-plan.md

@@ -20,7 +20,7 @@
 
 ## Per-invocation cost (where the regression actually hides)
 
-A typical `/user:gsd-t-execute` invocation loads:
+A typical `/gsd-t-execute` invocation loads:
 
 | Item | Tokens | Notes |
 |------|--------|-------|
@@ -85,7 +85,7 @@ Note: these savings only apply when a command is invoked. If you only ever run `
 **Current size**: 9,679 tokens (4.8% of window — always loaded)
 **Target size**: ~4,500 tokens
 **Method**:
-- The entire "Commands Reference" table (51 rows) duplicates `commands/gsd-t-help.md` — DELETE the table, replace with `Run /user:gsd-t-help for the full command list.`
+- The entire "Commands Reference" table (51 rows) duplicates `commands/gsd-t-help.md` — DELETE the table, replace with `Run /gsd-t-help for the full command list.`
 - The "Update Notices" / "Auto-Init Guard" / "Playwright Readiness Guard" / "QA Agent" / "Design Verification Agent" / "Red Team" sections (~3,000 tokens combined) are duplicated in the relevant command files. Move them to the command files only and replace with one-line summaries here.
 - The "Pre-Commit Gate" decision tree (~1,500 tokens) is also in project CLAUDE.md — keep one, link from the other
 - The "Document Ripple Completion Gate" (~1,500 tokens) is duplicated in `gsd-t-doc-ripple.md` — reference only

package/docs/infrastructure.md

@@ -123,7 +123,7 @@ Headless mode enables non-interactive GSD-T execution for CI/CD pipelines and ov
 
 ### headless exec
 
-Wraps `claude -p "/user:gsd-t-{command} {args}"` for unattended execution.
+Wraps `claude -p "/gsd-t-{command} {args}"` for unattended execution.
 
 ```bash
 gsd-t headless verify --json --timeout=1200 --log
@@ -314,16 +314,16 @@ The unattended supervisor runs an active GSD-T milestone to completion in a deta
 
 ```bash
 # From within an interactive Claude session:
-/user:gsd-t-unattended
+/gsd-t-unattended
 
 # From the terminal (detached — returns immediately):
 gsd-t unattended --hours=24 --milestone=M36
 
 # Watch current run status (in-session, 270s tick):
-/user:gsd-t-unattended-watch
+/gsd-t-unattended-watch
 
 # Request a graceful stop:
-/user:gsd-t-unattended-stop
+/gsd-t-unattended-stop
 ```
 
 ### CLI Flags
@@ -395,18 +395,18 @@ kill -0 $(cat .gsd-t/.unattended/supervisor.pid) && echo "alive" || echo "stale
 rm .gsd-t/.unattended/supervisor.pid
 
 # Or request a graceful stop:
-/user:gsd-t-unattended-stop
+/gsd-t-unattended-stop
 # (or) touch .gsd-t/.unattended/stop
 ```
 
 **Watch loop stopped firing**
-- Re-invoke `/user:gsd-t-resume` from a fresh session
+- Re-invoke `/gsd-t-resume` from a fresh session
 - Step 0 auto-reattach reads `supervisor.pid` — if the supervisor is still alive, it re-enters the watch loop automatically (no manual steps needed)
 
 **Supervisor crashed mid-run**
 - The watch loop detects crash via `kill -0` failure
 - Check `.gsd-t/.unattended/run.log` and final `state.json` for diagnostics
-- Resume normally with `/user:gsd-t-resume` — the milestone continues from its last checkpoint
+- Resume normally with `/gsd-t-resume` — the milestone continues from its last checkpoint
 
 ---
 

package/docs/methodology.md

@@ -124,7 +124,7 @@ Between v2.74 and v2.75, GSD-T attempted to cope with context pressure through *
 
 M34 gave GSD-T a real measurement of how much context window each session had consumed. M35 used that signal to refuse starting new work that would exceed the 85% threshold, auto-spawning a detached headless process instead so the user never had to manually run `/clear`. Both milestones still had a ceiling: the headless continuation was a single shot — it ran one Claude session, and if the milestone wasn't complete when that session exhausted its context, a human had to intervene again to trigger the next continuation. Long-running milestones (multi-day builds, large waves) still required periodic human attention to keep the relay going.
 
-M36 (v2.77.10) makes the relay automatic and indefinite. The unattended supervisor (`bin/gsd-t-unattended.js`) is a long-lived OS process, fully detached from any Claude Code terminal session, that drives the relay itself: it spawns a fresh `claude -p "/gsd-t-resume"` worker, waits for it to exit, reads the outcome, and immediately spawns the next worker — repeating until the milestone reaches COMPLETED status or a wall-clock cap is hit. Each worker gets a pristine context window. The `/compact` that inevitably fires in a long session is irrelevant because the *next* session has already started fresh. The supervisor IS the orchestrator of runway handoffs. Safety rails (`bin/gsd-t-unattended-safety.js`) prevent infinite-loop scenarios: gutter detection catches stall patterns, blocker sentinels catch unrecoverable errors, and iteration/hour caps ensure the machine doesn't run forever on a broken state. A cross-platform abstraction layer handles macOS sleep-prevention (`caffeinate`), Linux equivalents, and Windows limitations. From the user's perspective: invoke `/user:gsd-t-unattended`, walk away, and receive a native OS notification when the milestone is done — hours or days later.
+M36 (v2.77.10) makes the relay automatic and indefinite. The unattended supervisor (`bin/gsd-t-unattended.js`) is a long-lived OS process, fully detached from any Claude Code terminal session, that drives the relay itself: it spawns a fresh `claude -p "/gsd-t-resume"` worker, waits for it to exit, reads the outcome, and immediately spawns the next worker — repeating until the milestone reaches COMPLETED status or a wall-clock cap is hit. Each worker gets a pristine context window. The `/compact` that inevitably fires in a long session is irrelevant because the *next* session has already started fresh. The supervisor IS the orchestrator of runway handoffs. Safety rails (`bin/gsd-t-unattended-safety.js`) prevent infinite-loop scenarios: gutter detection catches stall patterns, blocker sentinels catch unrecoverable errors, and iteration/hour caps ensure the machine doesn't run forever on a broken state. A cross-platform abstraction layer handles macOS sleep-prevention (`caffeinate`), Linux equivalents, and Windows limitations. From the user's perspective: invoke `/gsd-t-unattended`, walk away, and receive a native OS notification when the milestone is done — hours or days later.
 
 The in-session watch loop (270-second `ScheduleWakeup` ticks, chosen to stay inside the 5-minute prompt-cache TTL) closes the feedback loop for users who keep a Claude session open. And the `gsd-t-resume` Step 0 auto-reattach means that even a `/clear` or accidental session close is transparent: the next resume detects the live supervisor and silently re-enters the watch loop without any manual step. Taken together, M34 + M35 + M36 form a complete three-layer system: measure the context accurately, refuse to degrade when it runs low, and relay execution automatically across as many fresh sessions as the work requires.
 

package/docs/neo4j-setup.md

@@ -89,7 +89,7 @@ that doesn't exist.
 After indexing is complete, run a full codebase scan in each project to generate the baseline analysis. From within each project directory:
 
 ```
-/user:gsd-t-scan
+/gsd-t-scan
 ```
 
 Or to scan all projects at once, paste this prompt into Claude Code:
@@ -98,7 +98,7 @@ Or to scan all projects at once, paste this prompt into Claude Code:
 For each project listed in ~/.claude/.gsd-t-projects that has source code
 files (.js, .ts, .py, .jsx, .tsx):
 1. cd into the project directory
-2. Run /user:gsd-t-scan
+2. Run /gsd-t-scan
 3. Report: project name, scan status, tech debt items found, test count
 
 Use team mode with parallel agents. Skip documentation-only projects