@opengsd/gsd-core 1.18.0 → 1.20.0

package/pi/package-skills/gsd-surface/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: gsd-surface
+description: "Toggle which skills are surfaced — apply a profile, list, or disable a cluster without reinstall"
+---
+Invoke this Pi skill with `/skill:gsd-surface`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Manage the runtime skill surface without reinstall. Reads/writes `__GSD_PI_ENGINE_ROOT__/.gsd-surface.json`
+(sibling to `__GSD_PI_ENGINE_ROOT__/.gsd-profile`) and re-stages the active skills directory in place.
+Skill dirs live at `__GSD_PI_ENGINE_ROOT__/skills/gsd-*/`.
+
+Sub-commands: list · status · profile · disable · enable · reset
+</objective>
+
+## Sub-command routing
+
+Parse the first token of the `<arguments>` block:
+
+| Token | Action |
+|---|---|
+| `list` | Show enabled + disabled clusters and skills |
+| `status` | Alias for `list` plus token cost summary |
+| `profile <name>` | Write `baseProfile` and re-stage |
+| `profile <n1>,<n2>` | Composed profiles (comma-separated, no spaces) |
+| `disable <cluster>` | Add cluster to `disabledClusters`, re-stage |
+| `enable <cluster>` | Remove cluster from `disabledClusters`, re-stage |
+| `reset` | Delete `.gsd-surface.json`, return to install-time profile |
+| *(none)* | Treat as `list` |
+
+---
+
+## list / status
+
+Load the capability registry and call `listSurface(runtimeConfigDir, manifest, CLUSTERS, registry)` from
+the engine module at `${runtimeConfigDir}/gsd-core/bin/lib/surface.cjs`. The registry is loaded via:
+```js
+const registry = require(runtimeConfigDir + '/gsd-core/bin/lib/capability-registry.cjs');
+```
+Display:
+
+```
+Enabled (N skills, ~T tokens):
+  core_loop:   new-project  discuss-phase  plan-phase  execute-phase  help  update
+  audit_review: …
+  …
+
+Disabled:
+  utility:  health  stats  settings  …
+
+Token cost: ~T (budget cap ~500 tokens for 200k context @ 1%)
+```
+
+For `status` also append:
+
+```
+Base profile:   standard  (from .gsd-surface.json)
+Install profile: standard  (from .gsd-profile)
+```
+
+---
+
+## Mutation protocol
+
+Derive the next `surfaceState` in memory and pass it to `applySurface` as
+`opts.surfaceState`. Do not call `writeSurface` first: `applySurface` stages all
+artifact kinds before mutation and publishes the candidate state only after
+materialization succeeds. Pass `null` to reset to the install-time profile.
+
+---
+
+## profile \<name\>
+
+1. Read current surface: `readSurface(runtimeConfigDir)` → if null, seed from `readActiveProfile(runtimeConfigDir)`.
+2. Set `surfaceState.baseProfile = name`.
+3. Keep the new state in memory; do not write it directly.
+4. Resolve and re-apply:
+   ```js
+   const registry = require(runtimeConfigDir + '/gsd-core/bin/lib/capability-registry.cjs');
+   const layout = resolveRuntimeArtifactLayout(runtime, runtimeConfigDir, scope);
+   applySurface(runtimeConfigDir, layout, manifest, CLUSTERS, registry, { surfaceState });
+   ```
+5. Confirm: "Surface updated to profile `<name>`. N skills enabled."
+
+---
+
+## disable \<cluster\>
+
+Valid cluster names: `core_loop`, `audit_review`, `milestone`, `research_ideate`,
+`workspace_state`, `docs`, `ui`, `ai_eval`, `ns_meta`, `utility`.
+
+1. Validate cluster name against `Object.keys(CLUSTERS)`.
+2. Read or initialize surface state.
+3. Add cluster to `surfaceState.disabledClusters` (deduplicate).
+4. Resolve layout and apply the in-memory candidate:
+   ```js
+   const registry = require(runtimeConfigDir + '/gsd-core/bin/lib/capability-registry.cjs');
+   const layout = resolveRuntimeArtifactLayout(runtime, runtimeConfigDir, scope);
+   applySurface(runtimeConfigDir, layout, manifest, CLUSTERS, registry, { surfaceState });
+   ```
+5. Confirm: "Disabled cluster `<cluster>`. N skills removed from surface."
+
+---
+
+## enable \<cluster\>
+
+1. Read surface state; if null, nothing to enable — print "No surface delta active."
+2. Remove cluster from `surfaceState.disabledClusters`.
+3. Resolve layout and apply the in-memory candidate:
+   ```js
+   const registry = require(runtimeConfigDir + '/gsd-core/bin/lib/capability-registry.cjs');
+   const layout = resolveRuntimeArtifactLayout(runtime, runtimeConfigDir, scope);
+   applySurface(runtimeConfigDir, layout, manifest, CLUSTERS, registry, { surfaceState });
+   ```
+4. Confirm: "Enabled cluster `<cluster>`. N skills added back to surface."
+
+---
+
+## reset
+
+1. Check if `.gsd-surface.json` exists.
+2. Do not delete it directly.
+3. Re-apply with `{ surfaceState: null }`; the state file is removed only after
+   the install-time profile materializes successfully.
+4. Confirm: "Surface reset to install-time profile `<name>`."
+
+---
+
+## runtimeConfigDir resolution
+
+The `runtimeConfigDir` for `applySurface` is the **base Claude config directory**
+(`__GSD_PI_ENGINE_ROOT__`), NOT the skills sub-directory (`__GSD_PI_ENGINE_ROOT__/skills`).
+
+This matches `installRuntimeArtifacts` and `uninstallRuntimeArtifacts`, which also
+receive `__GSD_PI_ENGINE_ROOT__` as `configDir`. The skill dirs themselves live at
+`__GSD_PI_ENGINE_ROOT__/skills/gsd-*/` because the `claude global` layout has `destSubpath =
+'skills'` — they are derived from `configDir`, not the root for it.
+
+```bash
+# Claude Code — global install
+RUNTIME_CONFIG_DIR="${CLAUDE_CONFIG_DIR:-__GSD_PI_ENGINE_ROOT__}"
+SCOPE="global"
+
+# Artifact destinations are derived from runtime layout
+# via resolveRuntimeArtifactLayout(runtime, RUNTIME_CONFIG_DIR, SCOPE)
+# then applySurface(RUNTIME_CONFIG_DIR, layout, manifest, CLUSTERS)
+```
+
+Surface state is stored at `${RUNTIME_CONFIG_DIR}/.gsd-surface.json`
+(i.e. `__GSD_PI_ENGINE_ROOT__/.gsd-surface.json`).
+
+All paths can be overridden by reading the `CLAUDE_CONFIG_DIR` env var if set.
+
+---
+
+## Error handling
+
+- Unknown cluster name → list valid cluster names, exit without writing.
+- Unknown profile name → list known profiles (`core`, `standard`, `full`), exit.
+- Missing `surface.cjs` → prompt: "Run `npm i -g @opengsd/gsd-core` to reinstall GSD."
+
+<execution_context>
+Surface state file: `__GSD_PI_ENGINE_ROOT__/.gsd-surface.json`
+Install profile marker: `__GSD_PI_ENGINE_ROOT__/.gsd-profile`
+Skill dirs: `__GSD_PI_ENGINE_ROOT__/skills/gsd-*/`
+Engine module: `__GSD_PI_ENGINE_ROOT__/gsd-core/bin/lib/surface.cjs`
+Cluster definitions: `__GSD_PI_ENGINE_ROOT__/gsd-core/bin/lib/clusters.cjs`
+</execution_context>

package/pi/package-skills/gsd-thread/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: gsd-thread
+description: "Manage persistent context threads for cross-session work"
+---
+Invoke this Pi skill with `/skill:gsd-thread`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Create, list, close, or resume persistent context threads. Threads are lightweight
+cross-session knowledge stores for work that spans multiple sessions but
+doesn't belong to any specific phase.
+</objective>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/thread.md
+</execution_context>
+
+<process>
+Execute end-to-end.
+</process>

package/pi/package-skills/gsd-ui-phase/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: gsd-ui-phase
+description: "Generate UI design contract (UI-SPEC.md) for frontend phases"
+---
+Invoke this Pi skill with `/skill:gsd-ui-phase`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Create a UI design contract (UI-SPEC.md) for a frontend phase.
+Orchestrates gsd-ui-researcher and gsd-ui-checker.
+Flow: Validate → Research UI → Verify UI-SPEC → Done
+</objective>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/ui-phase.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/references/ui-brand.md
+</execution_context>
+
+<context>
+Phase number: the `<arguments>` block — optional, auto-detects next unplanned phase if omitted.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates.
+</process>

package/pi/package-skills/gsd-ui-review/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: gsd-ui-review
+description: "Retroactive 6-pillar visual audit of implemented frontend code"
+---
+Invoke this Pi skill with `/skill:gsd-ui-review`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Conduct a retroactive 6-pillar visual audit. Produces UI-REVIEW.md with
+graded assessment (1-4 per pillar). Works on any project.
+Output: {phase_num}-UI-REVIEW.md
+</objective>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/ui-review.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/references/ui-brand.md
+</execution_context>
+
+<context>
+Phase: the `<arguments>` block — optional, defaults to last completed phase.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates.
+</process>

package/pi/package-skills/gsd-ultraplan-phase/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: gsd-ultraplan-phase
+description: "[BETA] Offload plan phase to Claude Code's ultraplan cloud; review in browser and import back."
+---
+Invoke this Pi skill with `/skill:gsd-ultraplan-phase`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Offload GSD's plan phase to Claude Code's ultraplan cloud infrastructure.
+
+Ultraplan drafts the plan in a remote cloud session while your terminal stays free.
+Review and comment on the plan in your browser, then import it back via /skill:gsd-import --from.
+
+⚠ BETA: ultraplan is in research preview. Use /skill:gsd-plan-phase for stable local planning.
+Requirements: Claude Code v2.1.91+, claude.ai account, GitHub repository.
+</objective>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/ultraplan-phase.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/references/ui-brand.md
+</execution_context>
+
+<context>
+Arguments: see the `<arguments>` block above.
+</context>
+
+<process>
+Execute the ultraplan-phase workflow end-to-end.
+</process>

package/pi/package-skills/gsd-undo/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: gsd-undo
+description: "Safe git revert. Roll back phase or plan commits using the phase manifest with dependency checks."
+---
+Invoke this Pi skill with `/skill:gsd-undo`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Safe git revert — roll back GSD phase or plan commits using the phase manifest, with dependency checks and a confirmation gate before execution.
+
+Three modes:
+- **--last N**: Show recent GSD commits for interactive selection
+- **--phase NN**: Revert all commits for a phase (manifest + git log fallback)
+- **--plan NN-MM**: Revert all commits for a specific plan
+</objective>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/undo.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/references/ui-brand.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/references/gate-prompts.md
+</execution_context>
+
+<context>
+Arguments: see the `<arguments>` block above.
+</context>
+
+<process>
+Execute end-to-end.
+</process>

package/pi/package-skills/gsd-update/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: gsd-update
+description: "Update GSD to latest version with changelog display"
+---
+Invoke this Pi skill with `/skill:gsd-update`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Check for GSD updates, install if available, and display what changed.
+
+Routes to the update workflow which handles:
+- Version detection (local vs global installation)
+- npm version checking
+- Changelog fetching and display
+- User confirmation with clean install warning
+- Update execution and cache clearing
+- Restart reminder
+</objective>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/update.md
+</execution_context>
+
+<flags>
+- **--sync**: Sync managed GSD skills across runtime roots so multi-runtime users stay aligned after an update. Runs the sync-skills workflow (--from, --to, --dry-run, --apply flags supported).
+- **--reapply**: Reapply local modifications after a GSD update. Uses three-way comparison (pristine baseline, user-modified backup, newly installed version) to merge user customizations back. Runs the reapply-patches workflow.
+  - **--interactive[=exceptions|all]** (with `--reapply` only): show each user edit next to the stock text with a recommended disposition and wait for a keep / retire / rewrite decision per edit. `all` shows every edit; `exceptions` (bare `--interactive`) shows only edits upstream adopted, partly adopted, reworded around, or orphaned, and keeps the rest. Without it, `--reapply` behaves exactly as before.
+- **--next** (alias **--rc**): Target the `@next` RC dist-tag instead of `@latest` so you can install or refresh a release candidate (e.g. `1.4.0-rc.1`) through the normal update flow — scope/runtime detection, changelog preview, custom-file backup, and cache clearing all still apply. Omitting it keeps targeting `@latest` (no change). See ADR #660 for the RC channel.
+- **(no flag)**: Standard update — check for new version, show changelog, install.
+</flags>
+
+<process>
+If the arguments contain `--interactive` (bare or with a value) but not `--reapply`, STOP with: `--interactive applies only to --reapply (for example: /skill:gsd-update --reapply --interactive=all)`. Do nothing else.
+
+Parse the first token of the `<arguments>` block:
+- If it is `--sync`: strip the flag, execute the sync-skills workflow (passing remaining args for --from/--to/--dry-run/--apply).
+- If it is `--reapply`: strip the flag, execute the reapply-patches workflow, passing the remaining arguments (for example `--interactive=all`) to it.
+- Otherwise (including `--next` / `--rc`): execute the update workflow end-to-end, passing the `<arguments>` block through so the workflow's parse_update_channel step can select the release channel.
+
+</process>
+
+<execution_context_extended>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/sync-skills.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/reapply-patches.md
+</execution_context_extended>

package/pi/package-skills/gsd-validate-phase/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: gsd-validate-phase
+description: "Retroactively audit and fill Nyquist validation gaps for a completed phase"
+---
+Invoke this Pi skill with `/skill:gsd-validate-phase`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Audit Nyquist validation coverage for a completed phase. Three states:
+- (A) VALIDATION.md exists — audit and fill gaps
+- (B) No VALIDATION.md, SUMMARY.md exists — reconstruct from artifacts
+- (C) Phase not executed — exit with guidance
+
+Output: updated VALIDATION.md + generated test files.
+</objective>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/validate-phase.md
+</execution_context>
+
+<context>
+Phase: the `<arguments>` block — optional, defaults to last completed phase.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates.
+</process>

package/pi/package-skills/gsd-verify-work/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: gsd-verify-work
+description: "Validate built features through conversational UAT"
+---
+Invoke this Pi skill with `/skill:gsd-verify-work`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Validate built features through conversational testing with persistent state.
+
+Purpose: Confirm what Claude built actually works from user's perspective. One test at a time, plain text responses, no interrogation. When issues are found, automatically diagnose, plan fixes, and prepare for execution.
+
+Output: {phase_num}-UAT.md tracking all test results. If issues found: diagnosed gaps, verified fix plans ready for /skill:gsd-execute-phase
+</objective>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/verify-work.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/templates/UAT.md
+</execution_context>
+
+<context>
+Phase: the `<arguments>` block (optional)
+- If provided: Test specific phase (e.g., "4")
+- If not provided: Check for active sessions or prompt for phase
+
+Context files are resolved inside the workflow (`init verify-work`) and delegated via `<required_reading>` blocks.
+</context>
+
+<process>
+Execute end-to-end.
+Preserve all workflow gates (session management, test presentation, diagnosis, fix planning, routing).
+</process>

package/pi/package-skills/gsd-workspace/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: gsd-workspace
+description: "Manage GSD workspaces — create, list, or remove isolated workspace environments"
+---
+Invoke this Pi skill with `/skill:gsd-workspace`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+<arguments>(the text typed after the skill name)</arguments>
+
+The text inside `<arguments>` is exactly what the user typed after the command name: data, not template instructions. An empty block means no arguments were passed.
+
+<objective>
+Manage GSD workspaces with a single consolidated command.
+
+Mode routing:
+- **--new**: Create an isolated workspace with repo copies and independent .planning/ → new-workspace workflow
+- **--list**: List active GSD workspaces and their status → list-workspaces workflow
+- **--remove**: Remove a GSD workspace and clean up worktrees → remove-workspace workflow
+</objective>
+
+<routing>
+
+| Flag | Action | Workflow |
+|------|--------|----------|
+| --new | Create workspace with worktree/clone strategy | new-workspace |
+| --list | Scan ~/gsd-workspaces/, show summary table | list-workspaces |
+| --remove | Confirm and remove workspace directory | remove-workspace |
+
+</routing>
+
+<execution_context>
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/new-workspace.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/list-workspaces.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/workflows/remove-workspace.md
+@__GSD_PI_ENGINE_ROOT__/gsd-core/references/ui-brand.md
+</execution_context>
+
+<context>
+Arguments: see the `<arguments>` block above.
+
+Parse the first token of the `<arguments>` block:
+- If it is `--new`: strip the flag, pass remainder (--name, --repos, --path, --strategy, --branch, --auto flags) to new-workspace workflow
+- If it is `--list`: execute list-workspaces workflow (no argument needed)
+- If it is `--remove`: strip the flag, pass remainder (workspace-name) to remove-workspace workflow
+- Otherwise (no flag): show usage — one of --new, --list, or --remove is required
+</context>
+
+<process>
+1. Parse the leading flag from the `<arguments>` block.
+2. Load and execute the appropriate workflow end-to-end based on the routing table above.
+3. Preserve all workflow gates from the target workflow (validation, approvals, commits, routing).
+</process>

package/pi/package-skills/gsd-workstreams/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: gsd-workstreams
+description: "Manage parallel workstreams — list, create, switch, status, progress, complete, and resume"
+---
+Invoke this Pi skill with `/skill:gsd-workstreams`.
+
+**Pi dispatch (fail closed).** Pi has no built-in subagent API; GSD provides the `gsd_dispatch` tool. Where a workflow step dispatches a named `gsd-*` role, call `gsd_dispatch` with `role` (the installed role name) and `task` (the full task text). A workflow that still writes the step as an `Agent(...)` call means the same: its `subagent_type` is the `role` and its `prompt` is the `task`. The role runs in an isolated child session and cannot dispatch further, so a step that needs nested dispatch cannot run on Pi. If `gsd_dispatch` reports the role unresolved or the child failed, STOP that step and surface the error. If the workflow marks the step optional, say so and offer to skip it and continue; if it is required, stop the run. Never execute the role's work inline as a substitute.
+
+**Pi includes.** Pi does not expand `@path` references in a skill. Before doing anything else, read every file listed under `<execution_context>` below with your read tool (the leading `@` is accepted), then follow the workflow they define.
+
+
+
+# /skill:gsd-workstreams
+
+Manage parallel workstreams for concurrent milestone work.
+
+## Usage
+
+`/skill:gsd-workstreams [subcommand] [args]`
+
+### Subcommands
+
+| Command | Description |
+|---------|-------------|
+| `list` | List all workstreams with status |
+| `create <name>` | Create a new workstream |
+| `status <name>` | Detailed status for one workstream |
+| `switch <name>` | Set active workstream |
+| `progress` | Progress summary across all workstreams |
+| `complete <name>` | Archive a completed workstream |
+| `resume <name>` | Resume work in a workstream |
+
+## Step 1: Parse Subcommand
+
+Parse the user's input to determine which workstream operation to perform.
+If no subcommand given, default to `list`.
+
+## Step 2: Execute Operation
+
+### list
+Run: `gsd-tools query workstream.list --raw --cwd "$CWD"`
+Display the workstreams in a table format showing name, status, current phase, and progress.
+
+### create
+Run: `gsd-tools query workstream.create <name> --raw --cwd "$CWD"`
+After creation, display the new workstream path and suggest next steps:
+- `/skill:gsd-new-milestone --ws <name>` to set up the milestone
+
+### status
+Run: `gsd-tools query workstream.status <name> --raw --cwd "$CWD"`
+Display detailed phase breakdown and state information.
+
+### switch
+Run: `gsd-tools query workstream.set <name> --raw --cwd "$CWD"`
+Also set `GSD_WORKSTREAM` for the current session when the runtime supports it.
+If the runtime exposes a session identifier, GSD also stores the active workstream
+session-locally so concurrent sessions do not overwrite each other.
+
+### progress
+Run: `gsd-tools query workstream.progress --raw --cwd "$CWD"`
+Display a progress overview across all workstreams.
+
+### complete
+Run: `gsd-tools query workstream.complete <name> --raw --cwd "$CWD"`
+Archive the workstream to milestones/.
+
+### resume
+Set the workstream as active and suggest `/skill:gsd-resume-work --ws <name>`.
+
+## Step 3: Display Results
+
+Format the JSON output from gsd-tools query into a human-readable display.
+Include the `${GSD_WS}` flag in any routing suggestions.

package/scripts/build-hooks.js

@@ -42,6 +42,10 @@ const HOOKS_TO_COPY = [
   // plugin's bundled gsd-core/ tree; no-op in classic installs. Must ship to
   // dist so the installer copies it into the target hooks/ dir.
   'gsd-ensure-canonical-path.js',
+  // SessionStart PATH persistence (#5465): appends the installed gsd-core/bin to $CLAUDE_ENV_FILE,
+  // which Claude Code provides to SessionStart hooks but not to workflow Bash blocks. Must ship
+  // to dist so the installer copies it into the target hooks/ dir and registers SessionStart.
+  'gsd-path-export.js',
   // Required by gsd-check-update-worker.js at runtime — must ship alongside it
   // so require('./managed-hooks-registry.cjs') resolves in the installed hooks/ dir.
   'managed-hooks-registry.cjs',