@ktpartners/dgs-platform 2.6.2

package/commands/dgs/research-idea.md

@@ -0,0 +1,43 @@
+---
+name: dgs:research-idea
+description: Research an idea's feasibility and technical landscape via subagent
+argument-hint: "[idea-id]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - WebSearch
+  - WebFetch
+---
+
+<objective>
+Research an idea's technical landscape and feasibility through a subagent workflow. Investigates five adaptive dimensions -- web search, codebase analysis, landscape survey, approach identification, and feasibility assessment -- to produce a structured research document and a Research Log entry in the idea file.
+
+**Two modes:**
+- **With an idea ID** (`/dgs:research-idea 5`): Researches that specific idea directly
+- **Without an idea ID** (`/dgs:research-idea`): Lists pending ideas for selection
+
+The output is a research document at `.planning/docs/ideas/pending/{slug}-research.md` and a Research Log entry appended to the idea file, both committed together. When prior research exists, the document is overwritten with a "Changes from Prior Research" section highlighting what shifted.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/research-idea.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional idea ID)
+</context>
+
+<process>
+**Follow the research-idea workflow** from `@~/.claude/deliver-great-systems/workflows/research-idea.md`.
+
+The workflow handles all logic including:
+1. Argument parsing and idea selection (with or without ID)
+2. Loading idea context and prior research/discussion history
+3. Five adaptive research dimensions (web search, codebase analysis, landscape survey, approach identification, feasibility assessment)
+4. Research document creation at `.planning/docs/ideas/pending/{slug}-research.md`
+5. Research log entry save via `dgs-tools.cjs ideas research-save`
+6. Git commit of both files and next-step suggestion
+</process>

package/commands/dgs/research-phase.md

@@ -0,0 +1,189 @@
+---
+name: dgs:research-phase
+description: Research how to implement a phase (standalone - usually use /dgs:plan-phase instead)
+argument-hint: "[phase]"
+allowed-tools:
+  - Read
+  - Bash
+  - Task
+---
+
+<objective>
+Research how to implement a phase. Spawns dgs-phase-researcher agent with phase context.
+
+**Note:** This is a standalone research command. For most workflows, use `/dgs:plan-phase` which integrates research automatically.
+
+**Use this command when:**
+- You want to research without planning yet
+- You want to re-research after planning is complete
+- You need to investigate before deciding if a phase is feasible
+
+**Orchestrator role:** Parse phase, validate against roadmap, check existing research, gather context, spawn researcher agent, present results.
+
+**Why subagent:** Research burns context fast (WebSearch, Context7 queries, source verification). Fresh 200k context for investigation. Main context stays lean for user interaction.
+</objective>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+Normalize phase input in step 1 before any directory lookups.
+</context>
+
+<process>
+
+## 0. Initialize Context
+
+```bash
+INIT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs init phase-op "$ARGUMENTS")
+```
+
+Extract from init JSON: `phase_dir`, `phase_number`, `phase_name`, `phase_found`, `commit_docs`, `has_research`, `state_path`, `requirements_path`, `context_path`, `research_path`.
+
+Resolve researcher model:
+```bash
+RESEARCHER_MODEL=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs resolve-model dgs-phase-researcher --raw)
+```
+
+## 1. Validate Phase
+
+```bash
+PHASE_INFO=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs roadmap get-phase "${phase_number}")
+```
+
+**If `found` is false:** Error and exit. **If `found` is true:** Extract `phase_number`, `phase_name`, `goal` from JSON.
+
+## 2. Check Existing Research
+
+```bash
+ls .planning/phases/${PHASE}-*/RESEARCH.md 2>/dev/null
+```
+
+**If exists:** Offer: 1) Update research, 2) View existing, 3) Skip. Wait for response.
+
+**If doesn't exist:** Continue.
+
+## 3. Gather Phase Context
+
+Use paths from INIT (do not inline file contents in orchestrator context):
+- `requirements_path`
+- `context_path`
+- `state_path`
+
+Present summary with phase description and what files the researcher will load.
+
+## 4. Spawn dgs-phase-researcher Agent
+
+Research modes: ecosystem (default), feasibility, implementation, comparison.
+
+```markdown
+<research_type>
+Phase Research — investigating HOW to implement a specific phase well.
+</research_type>
+
+<key_insight>
+The question is NOT "which library should I use?"
+
+The question is: "What do I not know that I don't know?"
+
+For this phase, discover:
+- What's the established architecture pattern?
+- What libraries form the standard stack?
+- What problems do people commonly hit?
+- What's SOTA vs what Claude's training thinks is SOTA?
+- What should NOT be hand-rolled?
+</key_insight>
+
+<objective>
+Research implementation approach for Phase {phase_number}: {phase_name}
+Mode: ecosystem
+</objective>
+
+<files_to_read>
+- {requirements_path} (Requirements)
+- {context_path} (Phase context from discuss-phase, if exists)
+- {state_path} (Prior project decisions and blockers)
+</files_to_read>
+
+<additional_context>
+**Phase description:** {phase_description}
+</additional_context>
+
+<downstream_consumer>
+Your RESEARCH.md will be loaded by `/dgs:plan-phase` which uses specific sections:
+- `## Standard Stack` → Plans use these libraries
+- `## Architecture Patterns` → Task structure follows these
+- `## Don't Hand-Roll` → Tasks NEVER build custom solutions for listed problems
+- `## Common Pitfalls` → Verification steps check for these
+- `## Code Examples` → Task actions reference these patterns
+
+Be prescriptive, not exploratory. "Use X" not "Consider X or Y."
+</downstream_consumer>
+
+<quality_gate>
+Before declaring complete, verify:
+- [ ] All domains investigated (not just some)
+- [ ] Negative claims verified with official docs
+- [ ] Multiple sources for critical claims
+- [ ] Confidence levels assigned honestly
+- [ ] Section names match what plan-phase expects
+</quality_gate>
+
+<output>
+Write to: .planning/phases/${PHASE}-{slug}/${PHASE}-RESEARCH.md
+</output>
+```
+
+```
+Task(
+  prompt="First, read ~/.claude/agents/dgs-phase-researcher.md for your role and instructions.\n\n" + filled_prompt,
+  subagent_type="general-purpose",
+  model="{researcher_model}",
+  description="Research Phase {phase}"
+)
+```
+
+## 5. Handle Agent Return
+
+**`## RESEARCH COMPLETE`:** Display summary, offer: Plan phase, Dig deeper, Review full, Done.
+
+**`## CHECKPOINT REACHED`:** Present to user, get response, spawn continuation.
+
+**`## RESEARCH INCONCLUSIVE`:** Show what was attempted, offer: Add context, Try different mode, Manual.
+
+## 6. Spawn Continuation Agent
+
+```markdown
+<objective>
+Continue research for Phase {phase_number}: {phase_name}
+</objective>
+
+<prior_state>
+<files_to_read>
+- .planning/phases/${PHASE}-{slug}/${PHASE}-RESEARCH.md (Existing research)
+</files_to_read>
+</prior_state>
+
+<checkpoint_response>
+**Type:** {checkpoint_type}
+**Response:** {user_response}
+</checkpoint_response>
+```
+
+```
+Task(
+  prompt="First, read ~/.claude/agents/dgs-phase-researcher.md for your role and instructions.\n\n" + continuation_prompt,
+  subagent_type="general-purpose",
+  model="{researcher_model}",
+  description="Continue research Phase {phase}"
+)
+```
+
+</process>
+
+<success_criteria>
+- [ ] Phase validated against roadmap
+- [ ] Existing research checked
+- [ ] dgs-phase-researcher spawned with context
+- [ ] Checkpoints handled correctly
+- [ ] User knows next steps
+</success_criteria>

package/commands/dgs/restore-idea.md

@@ -0,0 +1,45 @@
+---
+name: dgs:restore-idea
+description: Restore a rejected, done, or consolidated idea back to pending
+argument-hint: <idea-id>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Restore a rejected, done, or consolidated idea back to pending state for reconsideration.
+
+Routes to the restore-idea workflow which handles:
+- Finding and displaying the idea from rejected, done, or consolidated state
+- For consolidated ideas, removing the consolidated_into field from frontmatter
+- Confirmation before restore (always required)
+- State transition via git mv
+- Preservation of rejection reason as history
+- Auto-commit to git
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/restore-idea.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (idea ID)
+
+State is resolved in-workflow via dgs-tools.cjs ideas list.
+</context>
+
+<process>
+**Follow the restore-idea workflow** from `@~/.claude/deliver-great-systems/workflows/restore-idea.md`.
+
+The workflow handles all logic including:
+1. Argument parsing (idea ID extraction)
+2. Finding and displaying the idea with its current state and any rejection reason
+3. Confirmation prompt (always required; for consolidated ideas, notes consolidated_into removal)
+4. State transition from rejected/, done/, or consolidated/ back to pending/ via git mv
+5. For consolidated ideas, removal of the consolidated_into field from frontmatter
+6. Preservation of rejection reason in file as history (not removed)
+7. Auto-commit to git
+</process>

package/commands/dgs/resume-work.md

@@ -0,0 +1,40 @@
+---
+name: dgs:resume-work
+description: Resume work from previous session with full context restoration
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - AskUserQuestion
+  - SlashCommand
+---
+
+<objective>
+Restore complete project context and resume work seamlessly from previous session.
+
+Routes to the resume-project workflow which handles:
+
+- STATE.md loading (or reconstruction if missing)
+- Checkpoint detection (.continue-here files)
+- Incomplete work detection (PLAN without SUMMARY)
+- Status presentation
+- Context-aware next action routing
+  </objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/resume-project.md
+</execution_context>
+
+<process>
+**Follow the resume-project workflow** from `@~/.claude/deliver-great-systems/workflows/resume-project.md`.
+
+The workflow handles all resumption logic including:
+
+1. Project existence verification
+2. STATE.md loading or reconstruction
+3. Checkpoint and incomplete work detection
+4. Visual status presentation
+5. Context-aware option offering (checks CONTEXT.md before suggesting plan vs discuss)
+6. Routing to appropriate next command
+7. Session continuity updates
+   </process>

package/commands/dgs/rollback-job.md

@@ -0,0 +1,24 @@
+---
+name: dgs:rollback-job
+description: Roll back all code changes made by a milestone job
+argument-hint: "<version>"
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+---
+<objective>
+Roll back all code repo changes made by a milestone job to their pre-job commit SHAs. Planning artifacts are preserved; only code repos are reset.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/rollback-job.md
+</execution_context>
+
+<context>
+Version: $ARGUMENTS
+</context>
+
+<process>
+Execute the rollback-job workflow from @~/.claude/deliver-great-systems/workflows/rollback-job.md end-to-end.
+</process>

package/commands/dgs/run-job.md

@@ -0,0 +1,35 @@
+---
+name: dgs:run-job
+description: Execute a milestone build job
+argument-hint: "<version> [--dry-run]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Write
+  - Task
+---
+<objective>
+Execute a pending or partially-completed milestone job, spawning an isolated subagent per step. Supports --dry-run mode to preview steps without executing them.
+
+Reads the job file, loops through pending steps, spawns a fresh subagent for each DGS command, updates the job file with status and timestamps in real-time, handles failures with immediate halt, manages the dynamic audit-gap-fix cycle, and moves completed jobs to the completed/ directory.
+
+Context budget: ~10-15% orchestrator, 100% fresh per subagent.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/run-job.md
+</execution_context>
+
+<context>
+Version: $ARGUMENTS
+
+The version argument identifies which milestone job to execute (e.g., `v6`, `v6.0`).
+State is resolved in-workflow via `dgs-tools.cjs jobs find-job`, `parse`, `update-step`, `update-header`, `move`, and `insert-steps` CLI calls.
+</context>
+
+<process>
+Execute the run-job workflow from @~/.claude/deliver-great-systems/workflows/run-job.md end-to-end.
+Preserve all workflow gates (job location, step execution, failure handling, gap-fix cycle, completion).
+</process>

package/commands/dgs/search.md

@@ -0,0 +1,40 @@
+---
+name: dgs:search
+description: Search across ideas, specs, docs, and projects
+argument-hint: "query" [--ideas-only] [--specs-only] [--docs-only] [--include-rejected] [--tags TAG1,TAG2]
+allowed-tools:
+  - Read
+  - Bash
+---
+
+<objective>
+Search all DGS content (ideas, specs, docs, projects) for keyword matches with scope and tag filters. Display results grouped by type with context snippets.
+
+Routes to the search workflow which handles:
+- Argument parsing (query string, scope flags, tag filter)
+- Executing search via dgs-tools.cjs
+- Formatting grouped results with titles, paths, and snippets
+- Overflow indicators for large result sets
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/search.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (query string and optional filter flags)
+
+Search data is fetched in-workflow via `dgs-tools.cjs search`.
+</context>
+
+<process>
+**Follow the search workflow** from `@~/.claude/deliver-great-systems/workflows/search.md`.
+
+The workflow handles all logic including:
+1. Parsing the query and filter flags from arguments
+2. Prompting for a query if none provided
+3. Running search via dgs-tools.cjs with applicable flags
+4. Formatting grouped output by type (Ideas, Specs, Documents, Projects)
+5. Displaying titles, paths, context snippets, and overflow counts
+6. Showing total match count or empty-state message
+</process>

package/commands/dgs/set-profile.md

@@ -0,0 +1,34 @@
+---
+name: dgs:set-profile
+description: Switch model profile for DGS agents (quality/balanced/budget)
+argument-hint: <profile>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Switch the model profile used by DGS agents. Controls which Claude model each agent uses, balancing quality vs token spend.
+
+Routes to the set-profile workflow which handles:
+- Argument validation (quality/balanced/budget)
+- Config file creation if missing
+- Profile update in config.json
+- Confirmation with model table display
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/set-profile.md
+</execution_context>
+
+<process>
+**Follow the set-profile workflow** from `@~/.claude/deliver-great-systems/workflows/set-profile.md`.
+
+The workflow handles all logic including:
+1. Profile argument validation
+2. Config file ensuring
+3. Config reading and updating
+4. Model table generation from MODEL_PROFILES
+5. Confirmation display
+</process>

package/commands/dgs/settings.md

@@ -0,0 +1,38 @@
+---
+name: dgs:settings
+description: Configure DGS workflow toggles, model profile, and cross-LLM review settings
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Interactive configuration of DGS workflow agents, model profile, and cross-LLM review settings via multi-question prompt.
+
+Routes to the settings workflow which handles:
+- Config existence ensuring
+- Current settings reading and parsing
+- Interactive workflow settings prompt (model, research, plan_check, verifier, branching)
+- Interactive review settings prompt (OpenAI key/model, Gemini key/model, max rounds)
+- Config merging and writing (including review section)
+- Gitignore safety check when API keys are configured
+- Confirmation display with quick command references
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/settings.md
+</execution_context>
+
+<process>
+**Follow the settings workflow** from `@~/.claude/deliver-great-systems/workflows/settings.md`.
+
+The workflow handles all logic including:
+1. Config file creation with defaults if missing
+2. Current config reading
+3. Interactive settings presentation with pre-selection
+4. Answer parsing and config merging
+5. File writing
+6. Confirmation display
+</process>

package/commands/dgs/switch-project.md

@@ -0,0 +1,58 @@
+---
+name: dgs:switch-project
+description: Switch active project context
+argument-hint: "[project-name]"
+allowed-tools:
+  - Read
+  - Bash
+  - AskUserQuestion
+---
+<objective>
+Switch the active project context. If a project name is provided, switches immediately. If no name is given, shows a picker with all active projects.
+
+After switching, all DGS commands operate in the new project's context (its .planning/ directory, repos, and state).
+</objective>
+
+<process>
+
+## 1. Check Arguments
+
+If `$ARGUMENTS` contains a project name, go to step 3.
+
+If no arguments provided, go to step 2.
+
+## 2. Interactive Picker
+
+List available projects:
+```bash
+LIST=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs projects list --raw)
+```
+
+Parse JSON. Extract active project names from `active` array.
+
+If no active projects: display "No active projects found. Run `/dgs:new-project` to create one." and exit.
+
+Use AskUserQuestion to present the active project names and ask the user to pick one. Use the selected name as the target.
+
+## 3. Switch Project
+
+```bash
+RESULT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs projects switch "$PROJECT_NAME" --raw)
+```
+
+Parse JSON response.
+
+**If `switched: true`:**
+```
+DGS > PROJECT SWITCHED
+
+Active project: {slug}
+Phase: {status.phase}
+Status: {status.status}
+Progress: {status.progress}%
+```
+
+**If error:**
+Display the error message from the response. Suggest `/dgs:list-projects` to see available projects.
+
+</process>

package/commands/dgs/undo-consolidation.md

@@ -0,0 +1,42 @@
+---
+name: dgs:undo-consolidation
+description: Undo a consolidation — restore source ideas to pending and delete the consolidated idea
+argument-hint: "<consolidated-idea-id>"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+---
+
+<objective>
+Undo a previous idea consolidation. Restores all source ideas from consolidated/ back to pending/ and deletes the consolidated result idea.
+
+**Two modes:**
+- **With idea ID** (`/dgs:undo-consolidation 5`): Undoes that specific consolidated idea
+- **Without idea ID** (`/dgs:undo-consolidation`): Lists consolidated ideas with `consolidated_from` and prompts for selection
+
+The workflow validates the idea is a consolidated result, displays the affected ideas, confirms with the user, calls the CLI for the atomic undo operation, and shows the result.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/undo-consolidation.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (consolidated idea ID)
+</context>
+
+<process>
+**Follow the undo-consolidation workflow** from `@~/.claude/deliver-great-systems/workflows/undo-consolidation.md`.
+
+The workflow handles all logic including:
+1. Argument parsing (consolidated idea ID extraction)
+2. Validation that the idea exists and has `consolidated_from`
+3. Display of the consolidated idea and its source ideas
+4. User confirmation before proceeding
+5. Calling dgs-tools.cjs ideas undo-consolidation for atomic operation
+6. Confirmation output with undo instructions
+</process>

package/commands/dgs/update-idea.md

@@ -0,0 +1,44 @@
+---
+name: dgs:update-idea
+description: Update an existing idea's content or append a note
+argument-hint: <idea-id> [--note "text"]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Update an existing idea's fields (title, body, tags) interactively, or append a timestamped note via the --note flag.
+
+Routes to the update-idea workflow which handles:
+- Argument parsing (idea ID, --note flag)
+- Idea lookup across all states
+- Interactive field selection and prompting (without --note)
+- Timestamped note appending (with --note)
+- File update with timestamp refresh
+- Git commit for audit trail
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/update-idea.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (idea ID required, optional --note "text")
+
+Idea state is resolved in-workflow via `dgs-tools.cjs ideas list`.
+</context>
+
+<process>
+**Follow the update-idea workflow** from `@~/.claude/deliver-great-systems/workflows/update-idea.md`.
+
+The workflow handles all logic including:
+1. Parsing idea ID and --note flag from arguments
+2. Finding the idea file across all states
+3. Interactive field selection (title, body, tags) or note appending
+4. Calling dgs-tools.cjs ideas update/append-note
+5. Git commit for audit trail
+6. Minimal confirmation
+</process>

package/commands/dgs/update.md

@@ -0,0 +1,37 @@
+---
+name: dgs:update
+description: Update DGS to latest version with changelog display
+allowed-tools:
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Check for DGS 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>
+@~/.claude/deliver-great-systems/workflows/update.md
+</execution_context>
+
+<process>
+**Follow the update workflow** from `@~/.claude/deliver-great-systems/workflows/update.md`.
+
+The workflow handles all logic including:
+1. Installed version detection (local/global)
+2. Latest version checking via npm
+3. Version comparison
+4. Changelog fetching and extraction
+5. Clean install warning display
+6. User confirmation
+7. Update execution
+8. Cache clearing
+</process>