@ktpartners/dgs-platform 2.6.2

package/commands/dgs/add-doc.md

@@ -0,0 +1,45 @@
+---
+name: dgs:add-doc
+description: Add a supporting document (PDF, image, spreadsheet) to an idea, spec, or product
+argument-hint: [<file-path> --scope <product|idea|spec> --scope-id <id>]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Add a document from a local file or conversation attachment to a scoped docs/ directory. Supports PDFs, images, spreadsheets, and other files up to 10MB.
+
+Routes to the add-doc workflow which handles:
+- Source detection (local file path or conversation attachment; URLs not supported)
+- Scope inference from conversation context or interactive prompt
+- File size validation (10MB limit)
+- Duplicate check with user confirmation before overwriting
+- Document storage, text extraction, and INDEX.md update via dgs-tools CLI
+- Git commit and markdown link output
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/add-doc.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional file path and scope flags)
+
+Document management is handled in-workflow via `dgs-tools.cjs docs` subcommands.
+</context>
+
+<process>
+**Follow the add-doc workflow** from `@~/.claude/deliver-great-systems/workflows/add-doc.md`.
+
+The workflow handles all logic including:
+1. Source detection (local file path or conversation attachment; rejects URLs)
+2. Scope inference from conversation context or interactive prompt
+3. File size validation (10MB limit)
+4. Duplicate check and user confirmation if slug already exists
+5. Document storage via `dgs-tools.cjs docs add`
+6. Git commit of document, sidecars, and INDEX.md
+7. Markdown link output for easy pasting into ideas/specs
+</process>

package/commands/dgs/add-idea.md

@@ -0,0 +1,38 @@
+---
+name: dgs:add-idea
+description: Capture a new idea with title, problem/body, and optional tags
+argument-hint: [--auto "freeform text"]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Capture a new idea into the DGS ideas system. Supports two modes:
+
+- **Interactive mode** (default): Prompts for title, body, and tags sequentially
+- **Auto mode** (`--auto "text"`): Claude extracts title, body, and tags from freeform text — no interactive prompts
+
+Routes to the add-idea workflow which handles argument parsing, idea creation via dgs-tools CLI, git commit, and minimal confirmation output.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/add-idea.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional `--auto "freeform text"`)
+</context>
+
+<process>
+**Follow the add-idea workflow** from `@~/.claude/deliver-great-systems/workflows/add-idea.md`.
+
+The workflow handles all logic including:
+1. Argument parsing (detect `--auto` mode vs interactive)
+2. Interactive prompting (title, body, tags) or auto extraction from freeform text
+3. Idea creation via `dgs-tools.cjs ideas create`
+4. Git commit of new idea file and manifest
+5. Minimal confirmation output
+</process>

package/commands/dgs/add-phase.md

@@ -0,0 +1,43 @@
+---
+name: dgs:add-phase
+description: Add phase to end of current milestone in roadmap
+argument-hint: <description>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Add a new integer phase to the end of the current milestone in the roadmap.
+
+Routes to the add-phase workflow which handles:
+- Phase number calculation (next sequential integer)
+- Directory creation with slug generation
+- Roadmap structure updates
+- STATE.md roadmap evolution tracking
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/add-phase.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (phase description)
+
+Roadmap and state are resolved in-workflow via `init phase-op` and targeted tool calls.
+</context>
+
+<process>
+**Follow the add-phase workflow** from `@~/.claude/deliver-great-systems/workflows/add-phase.md`.
+
+The workflow handles all logic including:
+1. Argument parsing and validation
+2. Roadmap existence checking
+3. Current milestone identification
+4. Next phase number calculation (ignoring decimals)
+5. Slug generation from description
+6. Phase directory creation
+7. Roadmap entry insertion
+8. STATE.md updates
+</process>

package/commands/dgs/add-repo.md

@@ -0,0 +1,54 @@
+---
+name: dgs:add-repo
+description: Register a new repository in REPOS.md
+argument-hint: "<path> [--name N] [--desc D]"
+allowed-tools:
+  - Read
+  - Bash
+  - AskUserQuestion
+---
+<objective>
+Register a new repository in REPOS.md. Takes a sibling repo path in ../name format and optionally a name and description. The repo becomes available for project assignment.
+</objective>
+
+<process>
+
+## 1. Parse Arguments
+
+Extract from `$ARGUMENTS`:
+- `path` — required, the sibling repo path in ../name format
+- `--name <N>` — optional, display name for the repo
+- `--desc <D>` — optional, description of the repo
+
+If path is not provided, use AskUserQuestion:
+```
+What is the repo path? (e.g., "../my-api" or "../web-app")
+```
+
+## 2. Add Repo
+
+Build the command with available arguments:
+```bash
+RESULT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs repos add "$PATH" $NAME_FLAG $DESC_FLAG --raw)
+```
+
+Where `$NAME_FLAG` is `--name <N>` if provided, and `$DESC_FLAG` is `--desc <D>` if provided.
+
+Parse JSON response.
+
+**If `added: true`:**
+```
+DGS > REPO ADDED
+
+Name: {repo.name}
+Path: {repo.path}
+URL: {repo.url}
+Description: {repo.description}
+
+The repo is now available for project assignment via `/dgs:new-project`.
+```
+
+**If error:**
+Display the error message from the response.
+
+</process>

package/commands/dgs/add-tests.md

@@ -0,0 +1,41 @@
+---
+name: dgs:add-tests
+description: Generate tests for a completed phase based on UAT criteria and implementation
+argument-hint: "<phase> [additional instructions]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - AskUserQuestion
+argument-instructions: |
+  Parse the argument as a phase number (integer, decimal, or letter-suffix), plus optional free-text instructions.
+  Example: /dgs:add-tests 12
+  Example: /dgs:add-tests 12 focus on edge cases in the pricing module
+---
+<objective>
+Generate unit and E2E tests for a completed phase, using its SUMMARY.md, CONTEXT.md, and VERIFICATION.md as specifications.
+
+Analyzes implementation files, classifies them into TDD (unit), E2E (browser), or Skip categories, presents a test plan for user approval, then generates tests following RED-GREEN conventions.
+
+Output: Test files committed with message `test(phase-{N}): add unit and E2E tests from add-tests command`
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/add-tests.md
+</execution_context>
+
+<context>
+Phase: $ARGUMENTS
+
+@.planning/STATE.md
+@.planning/ROADMAP.md
+</context>
+
+<process>
+Execute the add-tests workflow from @~/.claude/deliver-great-systems/workflows/add-tests.md end-to-end.
+Preserve all workflow gates (classification approval, test plan approval, RED-GREEN verification, gap reporting).
+</process>

package/commands/dgs/add-todo.md

@@ -0,0 +1,47 @@
+---
+name: dgs:add-todo
+description: Capture idea or task as todo from current conversation context
+argument-hint: [optional description]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Capture an idea, task, or issue that surfaces during a DGS session as a structured todo for later work.
+
+Routes to the add-todo workflow which handles:
+- Directory structure creation
+- Content extraction from arguments or conversation
+- Area inference from file paths
+- Duplicate detection and resolution
+- Todo file creation with frontmatter
+- STATE.md updates
+- Git commits
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/add-todo.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional todo description)
+
+State is resolved in-workflow via `init todos` and targeted reads.
+</context>
+
+<process>
+**Follow the add-todo workflow** from `@~/.claude/deliver-great-systems/workflows/add-todo.md`.
+
+The workflow handles all logic including:
+1. Directory ensuring
+2. Existing area checking
+3. Content extraction (arguments or conversation)
+4. Area inference
+5. Duplicate checking
+6. File creation with slug generation
+7. STATE.md updates
+8. Git commits
+</process>

package/commands/dgs/approve-spec.md

@@ -0,0 +1,38 @@
+---
+name: dgs:approve-spec
+description: Approve a draft spec after completeness validation
+argument-hint: <spec-slug>
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+---
+
+<objective>
+Approve a draft spec by running completeness validation (required sections, P0 requirements, blocking open questions), presenting warnings for optional sections, and transitioning to final status with an approved_date and Refinement Log entry. If the spec is already final, show an informational message and make no changes.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/approve-spec.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (spec slug - required)
+</context>
+
+<process>
+**Follow the approve-spec workflow** from `@~/.claude/deliver-great-systems/workflows/approve-spec.md`.
+
+The workflow handles:
+1. Argument parsing (extract spec-slug)
+2. Spec lookup and status check (already-final short-circuit)
+3. Completeness validation (P0 errors, P1 warnings)
+4. Blocking open questions semantic check
+5. Error gate (blocks with clear messages)
+6. Warning gate (asks for user confirmation)
+7. State transition (set-status final, add approval log entry)
+8. Git commit
+</process>

package/commands/dgs/audit-milestone.md

@@ -0,0 +1,36 @@
+---
+name: dgs:audit-milestone
+description: Audit milestone completion against original intent before archiving
+argument-hint: "[version]"
+allowed-tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - Write
+---
+<objective>
+Verify milestone achieved its definition of done. Check requirements coverage, cross-phase integration, and end-to-end flows.
+
+**This command IS the orchestrator.** Reads existing VERIFICATION.md files (phases already verified during execute-phase), aggregates tech debt and deferred gaps, then spawns integration checker for cross-phase wiring.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/audit-milestone.md
+</execution_context>
+
+<context>
+Version: $ARGUMENTS (optional — defaults to current milestone)
+
+Core planning files are resolved in-workflow (`init milestone-op`) and loaded only as needed.
+
+**Completed Work:**
+Glob: .planning/phases/*/*-SUMMARY.md
+Glob: .planning/phases/*/*-VERIFICATION.md
+</context>
+
+<process>
+Execute the audit-milestone workflow from @~/.claude/deliver-great-systems/workflows/audit-milestone.md end-to-end.
+Preserve all workflow gates (scope determination, verification reading, integration check, requirements coverage, routing).
+</process>

package/commands/dgs/audit-phase.md

@@ -0,0 +1,37 @@
+---
+name: dgs:audit-phase
+description: Automated phase verification (tests + structural inspection)
+argument-hint: "<phase> [--rerun-failed]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Edit
+  - Write
+  - Task
+---
+<objective>
+Automated phase-level verification combining test execution with structural inspection. Produces a UAT file with combined findings.
+
+Purpose: Verify a completed phase by running its test suite and cross-referencing PLAN.md deliverables with what exists on disk. Two independent verification layers (test execution + structural inspection) must both pass for a phase to be considered clean.
+
+Output: Phase audit report confirming deliverables exist, are wired correctly, and pass their test suite.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/audit-phase.md
+</execution_context>
+
+<context>
+Phase: $ARGUMENTS
+- Required: phase number (e.g., "86")
+- Optional: `--rerun-failed` flag to re-execute only previously-failed tests
+
+Context files are resolved inside the workflow (`init audit-phase`) and loaded only as needed.
+</context>
+
+<process>
+Execute the audit-phase workflow from @~/.claude/deliver-great-systems/workflows/audit-phase.md end-to-end.
+Preserve all workflow gates (initialization, test execution, structural inspection, report generation).
+</process>

package/commands/dgs/cancel-job.md

@@ -0,0 +1,23 @@
+---
+name: dgs:cancel-job
+description: Cancel an in-progress job
+argument-hint: "<version>"
+allowed-tools:
+  - Read
+  - Bash
+---
+<objective>
+Cancel an in-progress job, resetting it to pending for re-execution.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/cancel-job.md
+</execution_context>
+
+<context>
+Version: $ARGUMENTS
+</context>
+
+<process>
+Execute the cancel-job workflow from @~/.claude/deliver-great-systems/workflows/cancel-job.md end-to-end.
+</process>

package/commands/dgs/capture-principle.md

@@ -0,0 +1,143 @@
+---
+name: dgs:capture-principle
+description: Extract a design principle from conversation context and save to product docs
+argument-hint: [optional principle description]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - AskUserQuestion
+---
+
+<objective>
+Extract a design principle from the current conversation context (e.g., a debugging session, root cause analysis, or architectural discussion) and save it to `.planning/docs/product/DESIGN-PRINCIPLES.md`.
+
+Principles are product-level artifacts — actionable rules distilled from hard-won lessons. They are loaded automatically by any workflow that reads product docs (Planning, Execution, and Verification tiers), preventing the same mistakes from recurring.
+</objective>
+
+<context>
+Arguments: $ARGUMENTS (optional seed text for the principle)
+
+State is resolved in-process via `state load` and git repo root detection.
+</context>
+
+<process>
+
+## 1. Resolve Target Path
+
+Determine where `DESIGN-PRINCIPLES.md` lives:
+
+```bash
+REPO_ROOT=$(git rev-parse --show-toplevel)
+```
+
+The target is always at `${REPO_ROOT}/.planning/docs/product/DESIGN-PRINCIPLES.md`.
+
+Load state for commit_docs setting:
+```bash
+INIT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs state load)
+```
+
+Extract `commit_docs` from the init JSON.
+
+## 2. Extract Principle from Context
+
+If `$ARGUMENTS` is provided, use it as a seed to guide principle extraction.
+
+Otherwise, analyze the current conversation to identify the key lesson, insight, or pattern worth preserving.
+
+Auto-propose a concise, actionable design principle with three parts:
+
+- **Title**: Short imperative name (e.g., "Validate State Transitions at Boundaries")
+- **Rule**: One-sentence actionable directive (e.g., "Always validate status transitions in the workflow layer, not the data layer, to prevent invalid state propagation")
+- **Context**: Brief note on origin (e.g., "Discovered during phase-88 debugging: status lifecycle bug caused by scattered transition logic")
+
+## 3. Present for Confirmation
+
+Use AskUserQuestion to show the proposed principle and let the user confirm, edit, or reject:
+
+```
+Proposed principle:
+
+**Title:** {title}
+**Rule:** {rule}
+**Context:** {context}
+
+Accept, edit, or reject? (type "ok" to accept, provide edits, or "reject" to cancel)
+```
+
+If the user provides edits, incorporate them and re-present. If the user rejects, stop with a brief acknowledgment.
+
+## 4. Read Existing DESIGN-PRINCIPLES.md
+
+Read `.planning/docs/product/DESIGN-PRINCIPLES.md` at the resolved path.
+
+If the file does **not** exist, create it with this template:
+
+```markdown
+# Design Principles
+
+Actionable design rules distilled from project experience. Loaded automatically by all planning and execution workflows as part of product docs.
+
+## How to use
+- Principles flow into `/dgs:plan-phase`, `/dgs:execute-phase`, and all workflows that load product docs
+- Each principle has a rule (what to do) and context (why it matters)
+- Add new principles with `/dgs:capture-principle`
+
+## Principles
+```
+
+Also ensure the directory exists:
+```bash
+mkdir -p "${REPO_ROOT}/.planning/docs/product"
+```
+
+If the file exists, read and parse existing principles (look for `### ` headings under `## Principles`).
+
+## 5. Check for Duplicates
+
+Compare the proposed principle's title and rule against existing entries.
+
+If a similar principle exists (same title or substantially overlapping rule):
+- Inform the user which existing principle overlaps
+- Use AskUserQuestion to ask whether to **merge** (combine both into one), **replace** (overwrite existing), or **add anyway** (keep both)
+- If merge: combine the rules and contexts, update in place
+- If replace: remove old entry, append new one
+- If add anyway: proceed to append
+
+## 6. Append Principle
+
+Add the new principle to the end of the `## Principles` section in SKILL.md:
+
+```markdown
+
+### {title}
+**Added:** {YYYY-MM-DD}
+**Rule:** {rule}
+**Context:** {context}
+```
+
+Use today's date for the `Added` field.
+
+## 7. Commit
+
+If `commit_docs` is true:
+```bash
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "docs: capture design principle - {title}" --files .planning/docs/product/DESIGN-PRINCIPLES.md
+```
+
+If `commit_docs` is false, just save the file without committing.
+
+Confirm to the user that the principle has been saved.
+
+</process>
+
+<success_criteria>
+- [ ] Target DESIGN-PRINCIPLES.md path resolved correctly
+- [ ] Principle extracted from context (or arguments)
+- [ ] User confirmed or edited the principle via AskUserQuestion
+- [ ] Existing principles checked for duplicates
+- [ ] Principle appended to DESIGN-PRINCIPLES.md with correct format
+- [ ] File committed (if commit_docs is true)
+</success_criteria>

package/commands/dgs/check-todos.md

@@ -0,0 +1,45 @@
+---
+name: dgs:check-todos
+description: List pending todos and select one to work on
+argument-hint: [area filter]
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+List all pending todos, allow selection, load full context for the selected todo, and route to appropriate action.
+
+Routes to the check-todos workflow which handles:
+- Todo counting and listing with area filtering
+- Interactive selection with full context loading
+- Roadmap correlation checking
+- Action routing (work now, add to phase, brainstorm, create phase)
+- STATE.md updates and git commits
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/check-todos.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (optional area filter)
+
+Todo state and roadmap correlation are loaded in-workflow using `init todos` and targeted reads.
+</context>
+
+<process>
+**Follow the check-todos workflow** from `@~/.claude/deliver-great-systems/workflows/check-todos.md`.
+
+The workflow handles all logic including:
+1. Todo existence checking
+2. Area filtering
+3. Interactive listing and selection
+4. Full context loading with file summaries
+5. Roadmap correlation checking
+6. Action offering and execution
+7. STATE.md updates
+8. Git commits
+</process>

package/commands/dgs/cleanup.md

@@ -0,0 +1,18 @@
+---
+name: dgs:cleanup
+description: Archive milestone phase directories and clean up completed quick task directories
+---
+<objective>
+Archive phase directories from completed milestones into `.planning/milestones/v{X.Y}-phases/`, and remove planning directories for completed quick/fast tasks from `.planning/quick/`.
+
+Use when `.planning/phases/` has accumulated directories from past milestones, or `.planning/quick/` has many completed task directories.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/cleanup.md
+</execution_context>
+
+<process>
+Follow the cleanup workflow at @~/.claude/deliver-great-systems/workflows/cleanup.md.
+Identify completed milestones and completed quick task directories, show a combined dry-run summary, and execute cleanup on confirmation.
+</process>