@tekyzinc/gsd-t 3.12.10 → 3.12.13

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

package/docs/prd-gsd2-hybrid.md

@@ -279,7 +279,7 @@ User immediately sees that notifications domain is consuming disproportionate to
 **Architecture**:
 ```
 gsd-t headless wave M25
-  └── claude -p "/user:gsd-t-wave M25"
+  └── claude -p "/gsd-t-wave M25"
         └── Agent tool dispatches phases (fresh context per phase)
               └── Execute phase dispatches domains (parallel, worktree isolation)
                     └── Each domain dispatches tasks (fresh context per task)

package/docs/prd-harness-evolution.md

@@ -333,7 +333,7 @@ Evolve GSD-T from a static methodology framework into a self-calibrating quality
 4. **Per-spawn telemetry** (`bin/token-telemetry.js`, `token-telemetry-contract.md` v1.0.0 — m35-token-telemetry):
    - Every Task subagent spawn is wrapped in a token bracket that records `{timestamp, milestone, command, phase, step, domain, task, model, duration_s, input_tokens_before, input_tokens_after, tokens_consumed, context_window_pct_before, context_window_pct_after, outcome, halt_type, escalated_via_advisor}` to `.gsd-t/token-metrics.jsonl`.
    - `gsd-t metrics --tokens [--by model,command,phase,milestone]`, `gsd-t metrics --halts`, `gsd-t metrics --context-window` surface the history.
-   - Telemetry feeds the runway estimator (historical cost-per-phase) and the optimization backlog (`bin/token-optimizer.js` → `.gsd-t/optimization-backlog.md`, detect-only — user selectively promotes via `/user:gsd-t-optimization-apply|reject`).
+   - Telemetry feeds the runway estimator (historical cost-per-phase) and the optimization backlog (`bin/token-optimizer.js` → `.gsd-t/optimization-backlog.md`, detect-only — user selectively promotes via `/gsd-t-optimization-apply|reject`).
 
 **Files affected (M35 active set)**:
 - MODIFY: `bin/token-budget.js` — three-band `getDegradationActions`, `WARN_THRESHOLD_PCT = 70`, `STOP_THRESHOLD_PCT = 85`

package/docs/requirements.md

@@ -255,9 +255,9 @@
 | REQ-077 | Headless auto-spawn on runway refusal — user never sees a `/clear` prompt | headless-auto-spawn | T1–T5 | SUPERSEDED by REQ-088 (M38) — headless-by-default promotes auto-spawn from emergency pivot to default primitive |
 | REQ-078 | Structural elimination of native compact messages — `halt_type: native-compact` count is 0 during M35 execution | runway-estimator + headless-auto-spawn | T1–T5 (RE), T1–T5 (HAS) | SUPERSEDED by REQ-088 (M38) — achieved via structural headless-default spawn, not runway projection |
 | REQ-079 | `gsd-t unattended` CLI subcommand runs an active milestone to completion unattended on macOS and Linux (24h+ multi-worker relay, detached OS process) | m36-supervisor-core | T1–T5 | complete (M36 Wave 1–2) |
-| REQ-080 | `/user:gsd-t-unattended` slash command launches the supervisor from within a Claude session without blocking the terminal | m36-supervisor-core + m36-watch-loop | T1, T3 | complete (M36 Wave 1–3) |
+| REQ-080 | `/gsd-t-unattended` slash command launches the supervisor from within a Claude session without blocking the terminal | m36-supervisor-core + m36-watch-loop | T1, T3 | complete (M36 Wave 1–3) |
 | REQ-081 | In-session watch loop ticks every 270s via `ScheduleWakeup` (inside 5-min prompt-cache TTL) to report live supervisor state | m36-watch-loop | T1–T2 | complete (M36 Wave 3) |
-| REQ-082 | `/clear` + `/user:gsd-t-resume` during a live unattended run transparently re-attaches to the watch loop (Step 0 auto-reattach, no user-visible disruption) | m36-watch-loop | T4 | complete (M36 Wave 3) |
+| REQ-082 | `/clear` + `/gsd-t-resume` during a live unattended run transparently re-attaches to the watch loop (Step 0 auto-reattach, no user-visible disruption) | m36-watch-loop | T4 | complete (M36 Wave 3) |
 | REQ-083 | Supervisor survives `/compact` and context resets — each worker is a fresh `claude -p` session; context exhaustion is structurally irrelevant | m36-supervisor-core | T1–T5 | complete (M36 Wave 1–2) |
 | REQ-084 | Safety rails prevent infinite loops: gutter detection, blocker sentinels (`BLOCKED_NEEDS_HUMAN`, `DISPATCH_FAILED`), max-hours and max-iterations timeouts | m36-safety-rails | T1–T5 | complete (M36 Wave 2) |
 | REQ-085 | Cross-platform support — macOS (caffeinate sleep-prevention) + Linux (systemd-inhibit or no-op) + Windows (claude.cmd via PATH; sleep-prevention not supported — see docs/unattended-windows-caveats.md) | m36-cross-platform | T1–T5 | complete (M36 Wave 2) |

package/docs/unattended-config.md

@@ -15,7 +15,7 @@ supervisor never silently falls back on a broken config.
 
 From highest to lowest:
 
-1. **CLI flags** passed to `/user:gsd-t-unattended` (e.g. `--hours=48`)
+1. **CLI flags** passed to `/gsd-t-unattended` (e.g. `--hours=48`)
 2. **Environment variables** (`GSD_T_HOURS`, `GSD_T_MAX_ITERATIONS`, etc.)
 3. **`.gsd-t/.unattended/config.json`** fields
 4. **Hardcoded defaults** in `bin/gsd-t-unattended-safety.js` → `DEFAULTS`

package/docs/unattended-windows-caveats.md

@@ -9,7 +9,7 @@
 
 ## 0. Required Software (All Platforms)
 
-The launch command (`/user:gsd-t-unattended`) pre-flights required software in
+The launch command (`/gsd-t-unattended`) pre-flights required software in
 Step 1e and refuses to spawn if anything is missing. Install these before
 launching:
 

package/docs/workflows.md

@@ -197,7 +197,7 @@ Every commit must pass applicable checks:
 2. `gsd-t-auto-route.js` UserPromptSubmit hook fires
 3. Script checks if `.gsd-t/progress.md` exists in cwd
 4. If yes: injects `[GSD-T AUTO-ROUTE]` signal into prompt context
-5. Claude agent sees signal and routes the plain text message through `/user:gsd {message}`
+5. Claude agent sees signal and routes the plain text message through `/gsd {message}`
 6. Smart router interprets intent and launches appropriate GSD-T command
 
 **Note:** Only fires in GSD-T projects (`.gsd-t/progress.md` must exist). Silently passes through in all other directories.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.12.10",
+  "version": "3.12.13",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/scripts/context-meter/threshold.test.js

@@ -183,7 +183,7 @@ test("buildAdditionalContext — marker is machine-readable and short (< 40 char
   assert.ok(result.length < 40, `marker too long: ${result.length}`);
 });
 
-test("buildAdditionalContext — marker contains NO user-facing language (no MANDATORY, STOP, /user:, /clear)", () => {
+test("buildAdditionalContext — marker contains NO user-facing language (no MANDATORY, STOP, /, /clear)", () => {
   const result = buildAdditionalContext({
     pct: 80,
     modelWindowSize: 200000,
@@ -191,7 +191,7 @@ test("buildAdditionalContext — marker contains NO user-facing language (no MAN
   });
   assert.ok(!/MANDATORY/.test(result));
   assert.ok(!/STOP/.test(result));
-  assert.ok(!/\/user:/.test(result));
+  assert.ok(!/\//.test(result));
   assert.ok(!/\/clear/.test(result));
   assert.ok(!/Destructive/.test(result));
 });

package/scripts/gsd-t-auto-route.js

@@ -29,7 +29,7 @@ process.stdin.on("end", () => {
     // Plain text prompt in a GSD-T project — inject routing signal
     process.stdout.write(
       "[GSD-T AUTO-ROUTE] The user typed a plain text message (no leading /). " +
-      "Route it automatically through the /gsd smart router — execute the /user:gsd " +
+      "Route it automatically through the /gsd smart router — execute the /gsd " +
       "command with the user's full message as the argument."
     );
   } catch {

package/scripts/gsd-t-context-meter.e2e.test.js

@@ -272,7 +272,7 @@ test("E2E 2. above threshold — stdout additionalContext with large transcript"
   // v3.12 (M38): additionalContext is a short silent marker, not a MANDATORY STOP banner.
   assert.equal(parsed.additionalContext, "next-spawn-headless:true");
   assert.ok(!/MANDATORY STOP/.test(parsed.additionalContext));
-  assert.ok(!/\/user:gsd-t-pause/.test(parsed.additionalContext));
+  assert.ok(!/\/gsd-t-pause/.test(parsed.additionalContext));
 
   const state = sandbox.readState();
   assert.ok(state);

package/scripts/gsd-t-context-meter.test.js

@@ -145,7 +145,7 @@ test("3. check-frequency hit — at/over threshold → silent marker emitted, ba
   assert.equal(out.additionalContext, "next-spawn-headless:true");
   // No user-facing banner strings.
   assert.ok(!/MANDATORY STOP/.test(out.additionalContext));
-  assert.ok(!/\/user:gsd-t-pause/.test(out.additionalContext));
+  assert.ok(!/\/gsd-t-pause/.test(out.additionalContext));
 
   const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
   assert.equal(state.checkCount, 5);

package/scripts/gsd-t-event-writer.js

@@ -71,11 +71,17 @@ function nullify(val) {
 }
 
 function buildEvent(args) {
+  // Env-var fallbacks: workers spawned by supervisor/headless-auto-spawn inherit
+  // GSD_T_COMMAND and GSD_T_PHASE so tool_call events are tagged even when the
+  // worker doesn't pass --command/--phase explicitly (Fix 2, v3.12.12).
+  const envCommand = process.env.GSD_T_COMMAND || null;
+  const envPhase = process.env.GSD_T_PHASE || null;
+
   return {
     ts: new Date().toISOString(),
     event_type: nullify(args["type"]),
-    command: nullify(args["command"]),
-    phase: nullify(args["phase"]),
+    command: nullify(args["command"]) || envCommand,
+    phase: nullify(args["phase"]) || envPhase,
     agent_id: nullify(args["agent-id"]),
     parent_agent_id: nullify(args["parent-id"]),
     trace_id: nullify(args["trace-id"]),

package/scripts/gsd-t-update-check.js

@@ -49,7 +49,7 @@ function doAutoUpdate(latest, installed) {
       : latest;
     console.log(`[GSD-T AUTO-UPDATE] v${installed} → v${updated}. Changelog: ${CHANGELOG}`);
   } catch {
-    console.log(`[GSD-T UPDATE] v${installed} — update available (v${installed} → v${latest}). Auto-update failed — run manually: /user:gsd-t-version-update-all. Changelog: ${CHANGELOG}`);
+    console.log(`[GSD-T UPDATE] v${installed} — update available (v${installed} → v${latest}). Auto-update failed — run manually: /gsd-t-version-update-all. Changelog: ${CHANGELOG}`);
   }
 }