@ktpartners/dgs-platform 2.6.2

package/commands/dgs/fast.md

@@ -0,0 +1,38 @@
+---
+name: dgs:fast
+description: Make a trivial edit with a single atomic commit — no subagents, no ceremony
+argument-hint: "<description> [--dry-run]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - AskUserQuestion
+---
+<objective>
+Make a trivial edit and commit it atomically. Fast mode is the lightest DGS command.
+
+- No subagents — the orchestrator makes edits directly
+- Infers conventional commit prefix (fix:/feat:/chore:/docs:/refactor:/style:/test:)
+- Updates STATE.md quick tasks table (shared counter with /dgs:quick)
+- Warns if scope exceeds 3 files or 30 lines (suggests /dgs:quick instead)
+
+**`--dry-run` flag:** Shows proposed changes as a diff, then asks "Apply these changes?" before committing.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/quick.md
+</execution_context>
+
+<context>
+--fast $ARGUMENTS
+
+Context files are resolved inside the workflow (`init quick`) and delegated inline.
+</context>
+
+<process>
+Execute the quick workflow from @~/.claude/deliver-great-systems/workflows/quick.md end-to-end.
+The --fast flag triggers the fast path which bypasses planner/executor spawning.
+</process>

package/commands/dgs/find-related-ideas.md

@@ -0,0 +1,43 @@
+---
+name: dgs:find-related-ideas
+description: Find pending ideas related to a selected idea with multi-signal scoring
+argument-hint: "<idea-id> [--threshold high|medium|low]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+---
+
+<objective>
+Find pending ideas related to a selected idea using multi-signal scoring (tag overlap, semantic similarity, implementation overlap), display results grouped by match level, and optionally flow into consolidation.
+
+**Two modes:**
+- **With idea ID** (`/dgs:find-related-ideas 42`): Scores all other pending ideas against idea #42
+- **Without idea ID** (`/dgs:find-related-ideas`): Lists pending ideas and prompts for anchor selection
+
+The workflow uses the CLI's tag overlap scoring as a first pass, then applies AI-powered semantic similarity and implementation overlap analysis. Results are displayed grouped by HIGH/MEDIUM/LOW with per-idea reasoning. The user can then select ideas from the results and flow directly into consolidation.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/find-related-ideas.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (idea ID and optional --threshold flag)
+</context>
+
+<process>
+**Follow the find-related-ideas workflow** from `@~/.claude/deliver-great-systems/workflows/find-related-ideas.md`.
+
+The workflow handles all logic including:
+1. Argument parsing (idea ID, --threshold flag)
+2. Getting tag overlap scores from CLI
+3. Loading project context files (codebase/, docs/product/)
+4. AI scoring for semantic similarity and implementation overlap
+5. Applying threshold filter and grouping by match level
+6. Displaying results grouped by HIGH/MEDIUM/LOW with per-idea reasoning
+7. Offering to flow into consolidation with selected ideas
+</process>

package/commands/dgs/health.md

@@ -0,0 +1,28 @@
+---
+name: dgs:health
+description: Validate DGS project health including planning directory and jobs
+argument-hint: "[--repair] [--jobs]"
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - AskUserQuestion
+---
+<objective>
+Validate `.planning/` directory integrity and jobs directory structure. Reports actionable issues for both planning health and job management health.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/health.md
+</execution_context>
+
+<process>
+Execute the health workflow from @~/.claude/deliver-great-systems/workflows/health.md end-to-end.
+Parse --repair flag from arguments and pass to workflow.
+
+Additionally, validate jobs directory structure:
+1. Run `node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs jobs health` and parse JSON result.
+2. If `healthy: true`: Display `Jobs directory healthy. {job_count} job(s) across {directories.length} directories.` with directory listing.
+3. If `healthy: false`: Display issues list with suggestions for each.
+4. Report any auto-created directories.
+</process>

package/commands/dgs/help.md

@@ -0,0 +1,22 @@
+---
+name: dgs:help
+description: Show available DGS commands and usage guide
+---
+<objective>
+Display the complete DGS command reference.
+
+Output ONLY the reference content below. Do NOT add:
+- Project-specific analysis
+- Git status or file context
+- Next-step suggestions
+- Any commentary beyond the reference
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/help.md
+</execution_context>
+
+<process>
+Output the complete DGS command reference from @~/.claude/deliver-great-systems/workflows/help.md.
+Display the reference content directly — no additions or modifications.
+</process>

package/commands/dgs/import-spec.md

@@ -0,0 +1,36 @@
+---
+name: dgs:import-spec
+description: Import an external document into the DGS spec pipeline as a structured 9-section PRD
+argument-hint: <file-path>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+---
+
+<objective>
+Import an external document and convert it into a structured 9-section PRD format using AI-powered restructuring. The command reads the source file, transforms its content into the standard PRD sections (preserving every detail), and presents the result for user review with revision support.
+
+This is a conversion pipeline -- the source document's structure is dissolved and its content is redistributed into the 9 standard PRD sections. No content is lost; the document is restructured, not summarised.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/import-spec.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (file path to import)
+</context>
+
+<process>
+**Follow the import-spec workflow** from `@~/.claude/deliver-great-systems/workflows/import-spec.md`.
+
+The workflow handles:
+1. Argument parsing (extract file path)
+2. File reading with error handling (not found, cannot read)
+3. AI conversion to 9-section PRD with full content preservation
+4. Review loop with Save, Revise (free-text feedback, unlimited rounds), and Cancel options
+</process>

package/commands/dgs/init-product.md

@@ -0,0 +1,28 @@
+---
+name: dgs:init-product
+description: Initialize a v2 multi-project product folder
+argument-hint: "[product-name]"
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - AskUserQuestion
+---
+<objective>
+Initialize a v2 product folder with repo discovery, REPOS.md, PROJECTS.md, and config setup. First step in the v2 multi-project workflow.
+
+Handles three cases: fresh install (creates everything), v1 detected (graceful message), and already initialized (helpful guidance).
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/init-product.md
+</execution_context>
+
+<context>
+$ARGUMENTS (optional product name)
+</context>
+
+<process>
+Execute the init-product workflow from @~/.claude/deliver-great-systems/workflows/init-product.md end-to-end.
+Preserve all workflow gates (v1 detection, git init, repo display, next-step routing).
+</process>

package/commands/dgs/insert-phase.md

@@ -0,0 +1,32 @@
+---
+name: dgs:insert-phase
+description: Insert urgent work as decimal phase (e.g., 72.1) between existing phases
+argument-hint: <after> <description>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Insert a decimal phase for urgent work discovered mid-milestone that must be completed between existing integer phases.
+
+Uses decimal numbering (72.1, 72.2, etc.) to preserve the logical sequence of planned phases while accommodating urgent insertions.
+
+Purpose: Handle urgent work discovered during execution without renumbering entire roadmap.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/insert-phase.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (format: <after-phase-number> <description>)
+
+Roadmap and state are resolved in-workflow via `init phase-op` and targeted tool calls.
+</context>
+
+<process>
+Execute the insert-phase workflow from @~/.claude/deliver-great-systems/workflows/insert-phase.md end-to-end.
+Preserve all validation gates (argument parsing, phase verification, decimal calculation, roadmap updates).
+</process>

package/commands/dgs/join-discord.md

@@ -0,0 +1,18 @@
+---
+name: dgs:join-discord
+description: Join the DGS Discord community
+---
+
+<objective>
+Display the Discord invite link for the DGS community server.
+</objective>
+
+<output>
+# Join the DGS Discord
+
+Connect with other DGS users, get help, share what you're building, and stay updated.
+
+**Invite link:** https://discord.gg/5JJgD5svVS
+
+Click the link or paste it into your browser to join.
+</output>

package/commands/dgs/list-docs.md

@@ -0,0 +1,40 @@
+---
+name: dgs:list-docs
+description: List all supporting documents grouped by scope (product, ideas, specs)
+argument-hint: [--scope <product|idea:id|spec:id>]
+allowed-tools:
+  - Read
+  - Bash
+---
+
+<objective>
+List all supporting documents grouped by scope (product first, then ideas, then specs) with metadata tables and optional --scope filtering.
+
+Routes to the list-docs workflow which handles:
+- Argument parsing for --scope filter
+- Fetching document inventory via dgs-tools CLI
+- Grouped display with scope headers and metadata tables
+- Empty-state messaging
+- Total count summary
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/list-docs.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional --scope filter)
+
+Document data is fetched in-workflow via `dgs-tools.cjs docs list`.
+</context>
+
+<process>
+**Follow the list-docs workflow** from `@~/.claude/deliver-great-systems/workflows/list-docs.md`.
+
+The workflow handles all logic including:
+1. Parsing --scope filter flag from arguments
+2. Fetching documents via dgs-tools with scope grouping
+3. Rendering grouped output with scope headers and metadata tables
+4. Empty-state hint when no documents exist
+5. Total count summary line
+</process>

package/commands/dgs/list-ideas.md

@@ -0,0 +1,42 @@
+---
+name: dgs:list-ideas
+description: List all ideas grouped by state with optional filters
+argument-hint: [--tag TAG] [--pending|--done|--rejected]
+allowed-tools:
+  - Read
+  - Bash
+---
+
+<objective>
+List all ideas grouped by state (Pending, Done, Rejected) with tag and state filtering, orphan detection for done ideas, and a helpful empty-state message.
+
+Routes to the list-ideas workflow which handles:
+- Argument parsing (--tag, --pending/--done/--rejected)
+- Fetching ideas via dgs-tools.cjs with orphan check
+- Grouped display with state headers and idea tables
+- Inline orphan markers on done ideas with no spec reference
+- Summary line with total counts
+- Empty-state hint when no ideas exist
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/list-ideas.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional filter flags)
+
+Idea data is fetched in-workflow via `dgs-tools.cjs ideas list`.
+</context>
+
+<process>
+**Follow the list-ideas workflow** from `@~/.claude/deliver-great-systems/workflows/list-ideas.md`.
+
+The workflow handles all logic including:
+1. Parsing filter flags from arguments
+2. Fetching ideas with orphan detection
+3. Formatting grouped output with state headers
+4. Applying inline orphan markers to done ideas
+5. Displaying summary counts
+6. Showing helpful hint for empty state
+</process>

package/commands/dgs/list-jobs.md

@@ -0,0 +1,22 @@
+---
+name: dgs:list-jobs
+description: List all milestone jobs with status and progress
+allowed-tools:
+  - Read
+  - Bash
+---
+<objective>
+Display all milestone jobs grouped by status (In Progress, Pending, Completed) with progress fractions.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/list-jobs.md
+</execution_context>
+
+<context>
+No arguments needed. State resolved via `dgs-tools.cjs jobs list-jobs` CLI call.
+</context>
+
+<process>
+Execute the list-jobs workflow from @~/.claude/deliver-great-systems/workflows/list-jobs.md end-to-end.
+</process>

package/commands/dgs/list-phase-assumptions.md

@@ -0,0 +1,46 @@
+---
+name: dgs:list-phase-assumptions
+description: Surface Claude's assumptions about a phase approach before planning
+argument-hint: "[phase]"
+allowed-tools:
+  - Read
+  - Bash
+  - Grep
+  - Glob
+---
+
+<objective>
+Analyze a phase and present Claude's assumptions about technical approach, implementation order, scope boundaries, risk areas, and dependencies.
+
+Purpose: Help users see what Claude thinks BEFORE planning begins - enabling course correction early when assumptions are wrong.
+Output: Conversational output only (no file creation) - ends with "What do you think?" prompt
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/list-phase-assumptions.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+Project state and roadmap are loaded in-workflow using targeted reads.
+</context>
+
+<process>
+1. Validate phase number argument (error if missing or invalid)
+2. Check if phase exists in roadmap
+3. Follow list-phase-assumptions.md workflow:
+   - Analyze roadmap description
+   - Surface assumptions about: technical approach, implementation order, scope, risks, dependencies
+   - Present assumptions clearly
+   - Prompt "What do you think?"
+4. Gather feedback and offer next steps
+</process>
+
+<success_criteria>
+
+- Phase validated against roadmap
+- Assumptions surfaced across five areas
+- User prompted for feedback
+- User knows next steps (discuss context, plan phase, or correct assumptions)
+  </success_criteria>

package/commands/dgs/list-projects.md

@@ -0,0 +1,57 @@
+---
+name: dgs:list-projects
+description: Show all projects with status and repos
+allowed-tools:
+  - Read
+  - Bash
+---
+<objective>
+Show all projects (active and completed) with their status, repos touched, current phase, and progress. Informational only.
+</objective>
+
+<process>
+
+## 1. Fetch Project List
+
+```bash
+RESULT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs projects list --raw)
+```
+
+Parse JSON response. Extract `active`, `completed`, and `warnings` arrays.
+
+## 2. Display Results
+
+**If no active or completed projects:**
+```
+DGS > PROJECTS
+
+No projects found. Run `/dgs:init-product` to set up v2 multi-project mode, then `/dgs:new-project` to create your first project.
+```
+
+**If active projects exist:**
+```
+DGS > PROJECTS
+
+### Active Projects
+
+| Project | Status | Repos Touched | Current Phase | Progress |
+|---------|--------|---------------|---------------|----------|
+| {name} | {status} | {repos_touched} | {current_phase} | {progress}% |
+```
+
+**If completed projects exist**, add:
+```
+### Completed Projects
+
+| Project | Completed |
+|---------|-----------|
+| {name} | {date} |
+```
+
+**If warnings exist**, append:
+```
+### Warnings
+- {warning}
+```
+
+</process>

package/commands/dgs/list-specs.md

@@ -0,0 +1,40 @@
+---
+name: dgs:list-specs
+description: List all specs with status, source ideas, and dates
+argument-hint: [--draft] [--review] [--final]
+allowed-tools:
+  - Read
+  - Bash
+---
+
+<objective>
+List all specs grouped by status (Draft, In Review, Final) with source ideas, creation dates, and filtering support. Read-only display command.
+
+Routes to the list-specs workflow which handles:
+- Argument parsing (--draft, --review, --final)
+- Fetching specs via dgs-tools.cjs specs list
+- Grouped display with status headers and spec tables
+- Summary line with total counts
+- Empty-state hint directing to /dgs:write-spec
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/list-specs.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional filter flags)
+
+Spec data is fetched in-workflow via `dgs-tools.cjs specs list`.
+</context>
+
+<process>
+**Follow the list-specs workflow** from `@~/.claude/deliver-great-systems/workflows/list-specs.md`.
+
+The workflow handles all logic including:
+1. Parsing filter flags from arguments
+2. Fetching specs via dgs-tools.cjs
+3. Formatting grouped output with status headers
+4. Displaying summary counts
+5. Showing helpful hint for empty state
+</process>

package/commands/dgs/map-codebase.md

@@ -0,0 +1,92 @@
+---
+name: dgs:map-codebase
+description: Analyze registered repos with parallel mapper agents to produce per-repo .planning/codebase/<repo>/ documents and cross-repo analysis
+argument-hint: "[<repo-name>]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Write
+  - Task
+---
+
+<objective>
+Analyze registered repos using parallel dgs-codebase-mapper agents to produce structured codebase documents per repo.
+
+Supports two modes:
+- **Refresh mode** (default, no flags): Clears all existing codebase maps and remaps everything from scratch.
+- **Update mode** (`<repo-name>` or `--only <repo-name>`): Re-maps only the specified repo and regenerates unified files from all repos.
+
+Reads REPOS.md to discover registered repos, then spawns 4 mapper agents per repo (or just the targeted repo in update mode). Each agent explores the repo's actual path and writes documents directly to `.planning/codebase/<repo-name>/`. The orchestrator only receives confirmations.
+
+Output: .planning/codebase/<repo-name>/ folders, each with 7 structured documents about that repo's codebase state, plus 7 unified top-level files synthesized from per-repo content, plus CROSS-REPO.md with cross-repo comparison tables (when 2+ repos).
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/map-codebase.md
+</execution_context>
+
+<context>
+**Reads REPOS.md** to discover registered repos and their paths.
+
+**Load project state if exists:**
+Check for .planning/STATE.md - loads context if project already initialized
+
+**This command can run:**
+- Before /dgs:new-project (brownfield codebases) - creates codebase maps first
+- After /dgs:new-project (greenfield codebases) - updates codebase maps as code evolves
+- Anytime to refresh codebase understanding across all registered repos
+- With `<repo-name>` (or `--only <repo-name>`) to refresh just one repo's maps after changes
+</context>
+
+<when_to_use>
+**Use map-codebase for:**
+- Brownfield projects before initialization (understand existing code first)
+- Refreshing codebase maps after significant changes in any registered repo
+- Onboarding to an unfamiliar multi-repo codebase
+- Before major refactoring (understand current state across repos)
+- After adding a new repo with /dgs:add-repo
+- After making changes in a specific repo (use `/dgs:map-codebase <repo>` to refresh just that repo's maps)
+
+**Skip map-codebase for:**
+- No repos registered yet (run /dgs:add-repo first)
+- Greenfield projects with no code in any repo yet (nothing to map)
+</when_to_use>
+
+<process>
+1. Read REPOS.md via init, detect mode (refresh vs update from <repo-name> argument or --only flag)
+2. Validate repo paths (warn on invalid, proceed with valid)
+3. Mode-aware cleanup:
+   - Refresh: Delete all existing codebase docs and per-repo subdirectories
+   - Update: Delete only the targeted repo's subdirectory (other repos untouched)
+4. Create .planning/codebase/<repo-name>/ directories (all repos or just targeted repo)
+5. Spawn 4 parallel dgs-codebase-mapper agents per repo (all run in parallel):
+   - Agent 1: tech focus -> writes STACK.md, INTEGRATIONS.md
+   - Agent 2: arch focus -> writes ARCHITECTURE.md, STRUCTURE.md
+   - Agent 3: quality focus -> writes CONVENTIONS.md, TESTING.md
+   - Agent 4: concerns focus -> writes CONCERNS.md
+   Note: In update mode, only the targeted repo is mapped
+6. Wait for agents to complete, show per-repo progress, track success/failure
+7. Verify all 7 documents exist per repo with line counts
+8. Synthesize unified top-level files from all repos with content
+9. Generate CROSS-REPO.md with cross-repo analysis (2+ repos only)
+10. Run secret scanning per repo and on unified files
+11. Commit codebase maps
+12. Show mapping summary with success/fail counts
+13. Offer next steps (typically: /dgs:new-project or /dgs:plan-phase)
+</process>
+
+<success_criteria>
+- [ ] .planning/codebase/<repo-name>/ directories created for each registered repo (or targeted repo in update mode)
+- [ ] All 7 codebase documents written per repo by mapper agents
+- [ ] Documents follow template structure
+- [ ] Parallel agents completed without errors
+- [ ] Per-repo progress shown during mapping
+- [ ] Refresh mode clears all repos and remaps
+- [ ] Update mode with `--only` clears only targeted repo and regenerates unified files
+- [ ] Failed repos skipped, remaining repos continue
+- [ ] End-of-run summary with success/fail counts
+- [ ] CROSS-REPO.md generated for multi-repo setups (2+ repos)
+- [ ] User knows next steps
+</success_criteria>

package/commands/dgs/new-milestone.md

@@ -0,0 +1,44 @@
+---
+name: dgs:new-milestone
+description: Start a new milestone cycle — update PROJECT.md and route to requirements
+argument-hint: "[milestone name, e.g., 'v1.1 Notifications']"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Task
+  - AskUserQuestion
+---
+<objective>
+Start a new milestone: questioning → research (optional) → requirements → roadmap.
+
+Brownfield equivalent of new-project. Project exists, PROJECT.md has history. Gathers "what's next", updates PROJECT.md, then runs requirements → roadmap cycle.
+
+**Creates/Updates:**
+- `.planning/PROJECT.md` — updated with new milestone goals
+- `.planning/research/` — domain research (optional, NEW features only)
+- `.planning/REQUIREMENTS.md` — scoped requirements for this milestone
+- `.planning/ROADMAP.md` — phase structure (continues numbering)
+- `.planning/STATE.md` — reset for new milestone
+
+**After:** `/dgs:plan-phase [N]` to start execution.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/new-milestone.md
+@~/.claude/deliver-great-systems/references/questioning.md
+@~/.claude/deliver-great-systems/references/ui-brand.md
+@~/.claude/deliver-great-systems/templates/project.md
+@~/.claude/deliver-great-systems/templates/requirements.md
+</execution_context>
+
+<context>
+Milestone name: $ARGUMENTS (optional - will prompt if not provided)
+
+Project and milestone context files are resolved inside the workflow (`init new-milestone`) and delegated via `<files_to_read>` blocks where subagents are used.
+</context>
+
+<process>
+Execute the new-milestone workflow from @~/.claude/deliver-great-systems/workflows/new-milestone.md end-to-end.
+Preserve all workflow gates (validation, questioning, research, requirements, roadmap approval, commits).
+</process>