@ktpartners/dgs-platform 2.6.2

package/commands/dgs/complete-milestone.md

@@ -0,0 +1,136 @@
+---
+type: prompt
+name: dgs:complete-milestone
+description: Archive completed milestone and prepare for next version
+argument-hint: <version>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Mark milestone {{version}} complete, archive to milestones/, and update ROADMAP.md and REQUIREMENTS.md.
+
+Purpose: Create historical record of shipped version, archive milestone artifacts (roadmap + requirements), and prepare for next milestone.
+Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tagged.
+</objective>
+
+<execution_context>
+**Load these files NOW (before proceeding):**
+
+- @~/.claude/deliver-great-systems/workflows/complete-milestone.md (main workflow)
+- @~/.claude/deliver-great-systems/templates/milestone-archive.md (archive template)
+  </execution_context>
+
+<context>
+**Project files:**
+- `.planning/ROADMAP.md`
+- `.planning/REQUIREMENTS.md`
+- `.planning/STATE.md`
+- `.planning/PROJECT.md`
+
+**User input:**
+
+- Version: {{version}} (e.g., "1.0", "1.1", "2.0")
+  </context>
+
+<process>
+
+**Follow complete-milestone.md workflow:**
+
+0. **Check for audit:**
+
+   - Look for `.planning/v{{version}}-MILESTONE-AUDIT.md`
+   - If missing or stale: recommend `/dgs:audit-milestone` first
+   - If audit status is `gaps_found`: recommend `/dgs:plan-milestone-gaps` first
+   - If audit status is `passed`: proceed to step 1
+
+   ```markdown
+   ## Pre-flight Check
+
+   {If no v{{version}}-MILESTONE-AUDIT.md:}
+   ⚠ No milestone audit found. Run `/dgs:audit-milestone` first to verify
+   requirements coverage, cross-phase integration, and E2E flows.
+
+   {If audit has gaps:}
+   ⚠ Milestone audit found gaps. Run `/dgs:plan-milestone-gaps` to create
+   phases that close the gaps, or proceed anyway to accept as tech debt.
+
+   {If audit passed:}
+   ✓ Milestone audit passed. Proceeding with completion.
+   ```
+
+1. **Verify readiness:**
+
+   - Check all phases in milestone have completed plans (SUMMARY.md exists)
+   - Present milestone scope and stats
+   - Wait for confirmation
+
+2. **Gather stats:**
+
+   - Count phases, plans, tasks
+   - Calculate git range, file changes, LOC
+   - Extract timeline from git log
+   - Present summary, confirm
+
+3. **Extract accomplishments:**
+
+   - Read all phase SUMMARY.md files in milestone range
+   - Extract 4-6 key accomplishments
+   - Present for approval
+
+4. **Archive milestone:**
+
+   - Create `.planning/milestones/v{{version}}-ROADMAP.md`
+   - Extract full phase details from ROADMAP.md
+   - Fill milestone-archive.md template
+   - Update ROADMAP.md to one-line summary with link
+
+5. **Archive requirements:**
+
+   - Create `.planning/milestones/v{{version}}-REQUIREMENTS.md`
+   - Mark all v1 requirements as complete (checkboxes checked)
+   - Note requirement outcomes (validated, adjusted, dropped)
+   - Delete `.planning/REQUIREMENTS.md` (fresh one created for next milestone)
+
+6. **Update PROJECT.md:**
+
+   - Add "Current State" section with shipped version
+   - Add "Next Milestone Goals" section
+   - Archive previous content in `<details>` (if v1.1+)
+
+7. **Commit and tag:**
+
+   - Stage: MILESTONES.md, PROJECT.md, ROADMAP.md, STATE.md, archive files
+   - Commit: `chore: archive v{{version}} milestone`
+   - Tag: `git tag -a v{{version}} -m "[milestone summary]"`
+   - Ask about pushing tag
+
+8. **Offer next steps:**
+   - `/dgs:new-milestone` — start next milestone (questioning → research → requirements → roadmap)
+
+</process>
+
+<success_criteria>
+
+- Milestone archived to `.planning/milestones/v{{version}}-ROADMAP.md`
+- Requirements archived to `.planning/milestones/v{{version}}-REQUIREMENTS.md`
+- `.planning/REQUIREMENTS.md` deleted (fresh for next milestone)
+- ROADMAP.md collapsed to one-line entry
+- PROJECT.md updated with current state
+- Git tag v{{version}} created
+- Commit successful
+- User knows next steps (including need for fresh requirements)
+  </success_criteria>
+
+<critical_rules>
+
+- **Load workflow first:** Read complete-milestone.md before executing
+- **Verify completion:** All phases must have SUMMARY.md files
+- **User confirmation:** Wait for approval at verification gates
+- **Archive before deleting:** Always create archive files before updating/deleting originals
+- **One-line summary:** Collapsed milestone in ROADMAP.md should be single line with link
+- **Context efficiency:** Archive keeps ROADMAP.md and REQUIREMENTS.md constant size per milestone
+- **Fresh requirements:** Next milestone starts with `/dgs:new-milestone` which includes requirements definition
+  </critical_rules>

package/commands/dgs/complete-project.md

@@ -0,0 +1,70 @@
+---
+name: dgs:complete-project
+description: Mark the current project as completed
+argument-hint: "[--slug name]"
+allowed-tools:
+  - Read
+  - Bash
+  - AskUserQuestion
+---
+<objective>
+Mark a project as completed. Moves it to the Completed section in PROJECTS.md and clears current_project if it was active.
+
+Requires confirmation before acting. Shows project status first so the user can verify before completing.
+</objective>
+
+<process>
+
+## 1. Show Current Status
+
+```bash
+LIST=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs projects list --raw)
+```
+
+Parse JSON. Identify the target project:
+- If `$ARGUMENTS` contains `--slug <name>`, use that slug.
+- Otherwise, use the current active project from the list.
+
+If no target project can be identified, display "No active project found. Use `--slug <name>` to specify one, or run `/dgs:switch-project` first." and exit.
+
+Display the target project's current status (name, phase, progress, repos touched).
+
+## 2. Confirm Completion
+
+Use AskUserQuestion:
+```
+Mark project "{name}" as completed? This will:
+- Move it to Completed in PROJECTS.md
+- Clear it as the active project (if current)
+- This cannot be undone
+
+Type "yes" to confirm or "no" to cancel.
+```
+
+If user does not confirm, display "Cancelled." and exit.
+
+## 3. Complete Project
+
+```bash
+RESULT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs projects complete $SLUG_FLAG --raw)
+```
+
+Where `$SLUG_FLAG` is `--slug <name>` if specified, or omitted to use current project.
+
+Parse JSON response.
+
+**If `completed: true`:**
+```
+DGS > PROJECT COMPLETED
+
+Project "{slug}" marked as completed on {date}.
+
+Remaining active projects: {remaining_active count}
+```
+
+If remaining active projects exist, list them. If none remain, suggest `/dgs:new-project` or `/dgs:init-product`.
+
+**If error:**
+Display the error message from the response.
+
+</process>

package/commands/dgs/consolidate-ideas.md

@@ -0,0 +1,50 @@
+---
+name: dgs:consolidate-ideas
+description: Merge related pending ideas into a single AI-synthesised idea
+argument-hint: "<id1> <id2> [id3...] [--title \"...\"]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+---
+
+<objective>
+Merge two or more related pending ideas into a single AI-synthesised idea with full lineage tracking and history preservation.
+
+**Two modes:**
+- **With idea IDs** (`/dgs:consolidate-ideas 1 3 17`): Consolidates those specific ideas
+- **Without idea IDs** (`/dgs:consolidate-ideas`): Lists pending ideas for selection
+
+The workflow reads all source ideas in full (body, notes, discussion logs, research logs), synthesises a coherent new idea body, merges logs with source attribution, and presents the result for user review before committing. The user can approve, request changes, or cancel.
+
+After approval, the underlying CLI creates the new idea in `pending/`, moves sources to `consolidated/`, and commits atomically.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/consolidate-ideas.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (idea IDs and optional --title flag)
+</context>
+
+<process>
+**Follow the consolidate-ideas workflow** from `@~/.claude/deliver-great-systems/workflows/consolidate-ideas.md`.
+
+The workflow handles all logic including:
+1. Argument parsing (idea IDs, --title flag)
+2. Validation that all IDs exist and are in pending state
+3. Loading full content of each source idea (body, notes, discussion log, research log)
+4. AI synthesis of a coherent merged body
+5. Merging discussion logs with `[from #ID]` attribution, chronologically ordered
+6. Merging research logs with `[from #ID]` attribution, chronologically ordered
+7. Merging notes with source attribution
+8. Tag union with deduplication
+9. Title generation (from --title flag or AI-generated)
+10. Presenting synthesised idea for user review and approval
+11. Calling dgs-tools.cjs ideas consolidate for atomic commit
+12. Confirmation output
+</process>

package/commands/dgs/create-milestone-job.md

@@ -0,0 +1,37 @@
+---
+name: dgs:create-milestone-job
+description: Generate a milestone build job from the current roadmap
+argument-hint: "[version] [--no-check]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Write
+---
+<objective>
+Generate a milestone build job that plans and executes all remaining phases, with optional audit/close cycle.
+
+Purpose: Reads the roadmap, determines which phases still need work, generates the step sequence, shows it for approval, and writes the job file on confirmation.
+
+Output: Job file at `.planning/jobs/pending/milestone-{version}.md` ready for `/dgs:run-job`.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/create-milestone-job.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+Flags:
+- `version` (optional): Milestone version (e.g., `v6`). Auto-detects from ROADMAP.md if omitted.
+- `--no-check`: Skip audit-milestone and complete-milestone steps in the generated job.
+
+State is resolved in-workflow via `dgs-tools.cjs jobs milestone-preview` and `jobs create-milestone`.
+</context>
+
+<process>
+Execute the create-milestone-job workflow from @~/.claude/deliver-great-systems/workflows/create-milestone-job.md end-to-end.
+Preserve all workflow gates (argument parsing, preview generation, step display, approval handling).
+</process>

package/commands/dgs/debug.md

@@ -0,0 +1,164 @@
+---
+name: dgs:debug
+description: Systematic debugging with persistent state across context resets
+argument-hint: [issue description]
+allowed-tools:
+  - Read
+  - Bash
+  - Task
+  - AskUserQuestion
+---
+
+<objective>
+Debug issues using scientific method with subagent isolation.
+
+**Orchestrator role:** Gather symptoms, spawn dgs-debugger agent, handle checkpoints, spawn continuations.
+
+**Why subagent:** Investigation burns context fast (reading files, forming hypotheses, testing). Fresh 200k context per investigation. Main context stays lean for user interaction.
+</objective>
+
+<context>
+User's issue: $ARGUMENTS
+
+Check for active sessions:
+```bash
+ls .planning/debug/*.md 2>/dev/null | grep -v resolved | head -5
+```
+</context>
+
+<process>
+
+## 0. Initialize Context
+
+```bash
+INIT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs state load)
+```
+
+Extract `commit_docs` from init JSON. Resolve debugger model:
+```bash
+DEBUGGER_MODEL=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs resolve-model dgs-debugger --raw)
+```
+
+## 1. Check Active Sessions
+
+If active sessions exist AND no $ARGUMENTS:
+- List sessions with status, hypothesis, next action
+- User picks number to resume OR describes new issue
+
+If $ARGUMENTS provided OR user describes new issue:
+- Continue to symptom gathering
+
+## 2. Gather Symptoms (if new issue)
+
+Use AskUserQuestion for each:
+
+1. **Expected behavior** - What should happen?
+2. **Actual behavior** - What happens instead?
+3. **Error messages** - Any errors? (paste or describe)
+4. **Timeline** - When did this start? Ever worked?
+5. **Reproduction** - How do you trigger it?
+
+After all gathered, confirm ready to investigate.
+
+## 3. Spawn dgs-debugger Agent
+
+Fill prompt and spawn:
+
+```markdown
+<objective>
+Investigate issue: {slug}
+
+**Summary:** {trigger}
+</objective>
+
+<symptoms>
+expected: {expected}
+actual: {actual}
+errors: {errors}
+reproduction: {reproduction}
+timeline: {timeline}
+</symptoms>
+
+<mode>
+symptoms_prefilled: true
+goal: find_and_fix
+</mode>
+
+<debug_file>
+Create: .planning/debug/{slug}.md
+</debug_file>
+```
+
+```
+Task(
+  prompt=filled_prompt,
+  subagent_type="dgs-debugger",
+  model="{debugger_model}",
+  description="Debug {slug}"
+)
+```
+
+## 4. Handle Agent Return
+
+**If `## ROOT CAUSE FOUND`:**
+- Display root cause and evidence summary
+- Offer options:
+  - "Fix now" - spawn fix subagent
+  - "Plan fix" - suggest /dgs:plan-phase --gaps
+  - "Manual fix" - done
+
+**If `## CHECKPOINT REACHED`:**
+- Present checkpoint details to user
+- Get user response
+- Spawn continuation agent (see step 5)
+
+**If `## INVESTIGATION INCONCLUSIVE`:**
+- Show what was checked and eliminated
+- Offer options:
+  - "Continue investigating" - spawn new agent with additional context
+  - "Manual investigation" - done
+  - "Add more context" - gather more symptoms, spawn again
+
+## 5. Spawn Continuation Agent (After Checkpoint)
+
+When user responds to checkpoint, spawn fresh agent:
+
+```markdown
+<objective>
+Continue debugging {slug}. Evidence is in the debug file.
+</objective>
+
+<prior_state>
+<files_to_read>
+- .planning/debug/{slug}.md (Debug session state)
+</files_to_read>
+</prior_state>
+
+<checkpoint_response>
+**Type:** {checkpoint_type}
+**Response:** {user_response}
+</checkpoint_response>
+
+<mode>
+goal: find_and_fix
+</mode>
+```
+
+```
+Task(
+  prompt=continuation_prompt,
+  subagent_type="dgs-debugger",
+  model="{debugger_model}",
+  description="Continue debug {slug}"
+)
+```
+
+</process>
+
+<success_criteria>
+- [ ] Active sessions checked
+- [ ] Symptoms gathered (if new)
+- [ ] dgs-debugger spawned with context
+- [ ] Checkpoints handled correctly
+- [ ] Root cause confirmed before fixing
+</success_criteria>

package/commands/dgs/develop-idea.md

@@ -0,0 +1,53 @@
+---
+name: dgs:develop-idea
+description: Develop an idea through discussion then research in one continuous flow
+argument-hint: "[idea-id]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - WebSearch
+  - WebFetch
+  - AskUserQuestion
+---
+
+<objective>
+Develop an idea through structured discussion followed by research as a single continuous creative session. Discussion flows naturally into research -- the two phases feel like one conversation, not two separate tasks bolted together.
+
+**Two modes:**
+- **With an idea ID** (`/dgs:develop-idea 5`): Develops that specific idea directly
+- **Without an idea ID** (`/dgs:develop-idea`): Lists pending ideas for selection
+
+The discussion phase walks through Understanding, Exploration, and Refinement as a thinking partner. Once discussion concludes and is committed, the research phase investigates feasibility and technical landscape across five adaptive dimensions. Discussion commits before research begins so research reads the freshly-updated idea context.
+
+If discussion concludes that the idea is not viable, research is skipped entirely. If the user exits mid-discussion, partial progress is saved and research does not run.
+
+When re-running on an idea with prior history, the user is offered a choice: re-do both, just discuss, or just research.
+
+The output is a Discussion Log entry in the idea file, a research document at `.planning/docs/ideas/pending/{slug}-research.md`, and a Research Log entry in the idea file -- all committed at appropriate stages.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/develop-idea.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional idea ID)
+</context>
+
+<process>
+**Follow the develop-idea workflow** from `@~/.claude/deliver-great-systems/workflows/develop-idea.md`.
+
+The workflow handles all logic including:
+1. Argument parsing and idea selection (with or without ID)
+2. Loading idea context with prior history detection
+3. History assessment and re-run choice offering
+4. Discussion phase (Understanding, Exploration, Refinement) inline
+5. Discussion commit before research starts
+6. Decision-based routing (skip research on negative decisions)
+7. Research phase (five adaptive dimensions) inline
+8. Research commit with document and idea file
+9. Unified completion summary with context-aware next step
+</process>

package/commands/dgs/discuss-idea.md

@@ -0,0 +1,41 @@
+---
+name: dgs:discuss-idea
+description: Develop and refine an idea through structured discussion with Claude
+argument-hint: "[idea-id]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - AskUserQuestion
+---
+
+<objective>
+Develop and refine an idea through structured, inline conversation. Claude walks through three discussion phases -- Understanding, Exploration, and Refinement -- to help shape a raw idea into something actionable.
+
+**Two modes:**
+- **With an idea ID** (`/dgs:discuss-idea 5`): Starts discussion for that specific idea
+- **Without an idea ID** (`/dgs:discuss-idea`): Lists pending ideas for selection
+
+The output is a Discussion Log entry appended to the idea file and committed. When a prior discussion log exists, the conversation builds on it rather than starting fresh -- jumping straight to unresolved Open Questions from the last session.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/discuss-idea.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional idea ID)
+</context>
+
+<process>
+**Follow the discuss-idea workflow** from `@~/.claude/deliver-great-systems/workflows/discuss-idea.md`.
+
+The workflow handles all logic including:
+1. Argument parsing and idea selection (with or without ID)
+2. Loading idea context and prior discussion history
+3. Three-phase structured discussion (Understanding, Exploration, Refinement)
+4. Discussion summary generation and file save via `dgs-tools.cjs ideas discuss-save`
+5. Git commit and next-step suggestion based on Decision tag
+</process>

package/commands/dgs/discuss-phase.md

@@ -0,0 +1,83 @@
+---
+name: dgs:discuss-phase
+description: Gather phase context through adaptive questioning before planning
+argument-hint: "<phase> [--auto]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - AskUserQuestion
+  - Task
+---
+
+<objective>
+Extract implementation decisions that downstream agents need — researcher and planner will use CONTEXT.md to know what to investigate and what choices are locked.
+
+**How it works:**
+1. Analyze the phase to identify gray areas (UI, UX, behavior, etc.)
+2. Present gray areas — user selects which to discuss
+3. Deep-dive each selected area until satisfied
+4. Create CONTEXT.md with decisions that guide research and planning
+
+**Output:** `{phase_num}-CONTEXT.md` — decisions clear enough that downstream agents can act without asking the user again
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/discuss-phase.md
+@~/.claude/deliver-great-systems/templates/context.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+Context files are resolved in-workflow using `init phase-op` and roadmap/state tool calls.
+</context>
+
+<process>
+1. Validate phase number (error if missing or not in roadmap)
+2. Check if CONTEXT.md exists (offer update/view/skip if yes)
+3. **Analyze phase** — Identify domain and generate phase-specific gray areas
+4. **Present gray areas** — Multi-select: which to discuss? (NO skip option)
+5. **Deep-dive each area** — 4 questions per area, then offer more/next
+6. **Write CONTEXT.md** — Sections match areas discussed
+7. Offer next steps (research or plan)
+
+**CRITICAL: Scope guardrail**
+- Phase boundary from ROADMAP.md is FIXED
+- Discussion clarifies HOW to implement, not WHETHER to add more
+- If user suggests new capabilities: "That's its own phase. I'll note it for later."
+- Capture deferred ideas — don't lose them, don't act on them
+
+**Domain-aware gray areas:**
+Gray areas depend on what's being built. Analyze the phase goal:
+- Something users SEE → layout, density, interactions, states
+- Something users CALL → responses, errors, auth, versioning
+- Something users RUN → output format, flags, modes, error handling
+- Something users READ → structure, tone, depth, flow
+- Something being ORGANIZED → criteria, grouping, naming, exceptions
+
+Generate 3-4 **phase-specific** gray areas, not generic categories.
+
+**Probing depth:**
+- Ask 4 questions per area before checking
+- "More questions about [area], or move to next?"
+- If more → ask 4 more, check again
+- After all areas → "Ready to create context?"
+
+**Do NOT ask about (Claude handles these):**
+- Technical implementation
+- Architecture choices
+- Performance concerns
+- Scope expansion
+</process>
+
+<success_criteria>
+- Gray areas identified through intelligent analysis
+- User chose which areas to discuss
+- Each selected area explored until satisfied
+- Scope creep redirected to deferred ideas
+- CONTEXT.md captures decisions, not vague vision
+- User knows next steps
+</success_criteria>

package/commands/dgs/execute-phase.md

@@ -0,0 +1,41 @@
+---
+name: dgs:execute-phase
+description: Execute all plans in a phase with wave-based parallelization
+argument-hint: "<phase-number> [--gaps-only]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - TodoWrite
+  - AskUserQuestion
+---
+<objective>
+Execute all plans in a phase using wave-based parallel execution.
+
+Orchestrator stays lean: discover plans, analyze dependencies, group into waves, spawn subagents, collect results. Each subagent loads the full execute-plan context and handles its own plan.
+
+Context budget: ~15% orchestrator, 100% fresh per subagent.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/execute-phase.md
+@~/.claude/deliver-great-systems/references/ui-brand.md
+</execution_context>
+
+<context>
+Phase: $ARGUMENTS
+
+**Flags:**
+- `--gaps-only` — Execute only gap closure plans (plans with `gap_closure: true` in frontmatter). Use after verify-work creates fix plans.
+
+Context files are resolved inside the workflow via `dgs-tools init execute-phase` and per-subagent `<files_to_read>` blocks.
+</context>
+
+<process>
+Execute the execute-phase workflow from @~/.claude/deliver-great-systems/workflows/execute-phase.md end-to-end.
+Preserve all workflow gates (wave execution, checkpoint handling, verification, state updates, routing).
+</process>