@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/workflows/insert-phase.md

@@ -0,0 +1,138 @@
+<purpose>
+Insert a decimal phase for urgent work discovered mid-milestone between existing integer phases. Uses decimal numbering (72.1, 72.2, etc.) to preserve the logical sequence of planned phases while accommodating urgent insertions without renumbering the entire roadmap.
+</purpose>
+
+<context_tier>planning</context_tier>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="parse_arguments">
+Parse the command arguments:
+- First argument: integer phase number to insert after
+- Remaining arguments: phase description
+
+Example: `/dgs:insert-phase 72 Fix critical auth bug`
+-> after = 72
+-> description = "Fix critical auth bug"
+
+If arguments missing:
+
+```
+ERROR: Both phase number and description required
+Usage: /dgs:insert-phase <after> <description>
+Example: /dgs:insert-phase 72 Fix critical auth bug
+```
+
+Exit.
+
+Validate first argument is an integer.
+</step>
+
+<step name="init_context">
+Load phase operation context:
+
+```bash
+INIT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" init phase-op "${after_phase}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Load planning-tier context files:
+
+```bash
+TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" context load-tier planning --raw 2>/dev/null)
+```
+
+Check `roadmap_exists` from init JSON. If false:
+```
+ERROR: No roadmap found (${roadmap_path})
+```
+Exit.
+</step>
+
+<step name="insert_phase">
+**Delegate the phase insertion to dgs-tools:**
+
+```bash
+RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" phase insert "${after_phase}" "${description}")
+```
+
+The CLI handles:
+- Verifying target phase exists in ROADMAP.md
+- Calculating next decimal phase number (checking existing decimals on disk)
+- Generating slug from description
+- Creating the phase directory (`${phases_dir}/{N.M}-{slug}/`)
+- Inserting the phase entry into ROADMAP.md after the target phase with (INSERTED) marker
+
+Extract from result: `phase_number`, `after_phase`, `name`, `slug`, `directory`.
+</step>
+
+<step name="update_project_state">
+Update STATE.md to reflect the inserted phase:
+
+1. Read STATE.md (via `${state_path}` from init)
+2. Under "## Accumulated Context" → "### Roadmap Evolution" add entry:
+   ```
+   - Phase {decimal_phase} inserted after Phase {after_phase}: {description} (URGENT)
+   ```
+
+If "Roadmap Evolution" section doesn't exist, create it.
+</step>
+
+<step name="completion">
+Present completion summary:
+
+```
+Phase {decimal_phase} inserted after Phase {after_phase}:
+- Description: {description}
+- Directory: ${phases_dir}/{decimal-phase}-{slug}/
+- Status: Not planned yet
+- Marker: (INSERTED) - indicates urgent work
+
+Roadmap updated: ${roadmap_path}
+Project state updated: ${state_path}
+
+---
+
+## Next Up
+
+**Phase {decimal_phase}: {description}** -- urgent insertion
+
+`/dgs:plan-phase {decimal_phase}`
+
+<sub>`/clear` first -> fresh context window</sub>
+
+---
+
+**Also available:**
+- Review insertion impact: Check if Phase {next_integer} dependencies still make sense
+- Review roadmap
+
+---
+```
+</step>
+
+</process>
+
+<anti_patterns>
+
+- Don't use this for planned work at end of milestone (use /dgs:add-phase)
+- Don't insert before Phase 1 (decimal 0.1 makes no sense)
+- Don't renumber existing phases
+- Don't modify the target phase content
+- Don't create plans yet (that's /dgs:plan-phase)
+- Don't commit changes (user decides when to commit)
+</anti_patterns>
+
+<success_criteria>
+Phase insertion is complete when:
+
+- [ ] `dgs-tools phase insert` executed successfully
+- [ ] Phase directory created
+- [ ] Roadmap updated with new phase entry (includes "(INSERTED)" marker)
+- [ ] STATE.md updated with roadmap evolution note
+- [ ] User informed of next steps and dependency implications
+</success_criteria>

package/deliver-great-systems/workflows/list-docs.md

@@ -0,0 +1,119 @@
+<purpose>
+List all supporting documents grouped by scope (product first, then ideas, then specs) with metadata tables. Supports --scope filtering to show documents for a specific scope only. This is the primary dashboard for browsing the document inventory.
+</purpose>
+
+<context_tier>lite</context_tier>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="load_context" priority="first">
+Load project context via tier system:
+
+```bash
+TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" context load-tier lite --raw 2>/dev/null)
+```
+
+Use `TIER_FILES` JSON `files` array for project context (PROJECT.md, STATE.md, config.json).
+</step>
+
+<step name="parse_arguments">
+Parse filter flags from `$ARGUMENTS`.
+
+- Check for `--scope <filter>` flag
+- Filter values: `product`, `idea:<slug>`, `spec:<slug>`, or empty (show all)
+
+Examples:
+- `/dgs:list-docs` -> no filter (show all scopes)
+- `/dgs:list-docs --scope product` -> show only product-level documents
+- `/dgs:list-docs --scope idea:auto-review-prs` -> show only documents for that idea
+- `/dgs:list-docs --scope spec:auth-system` -> show only documents for that spec
+</step>
+
+<step name="fetch_docs">
+Fetch document inventory with scope grouping:
+
+```bash
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs docs list --scope "$scopeFilter"
+```
+
+If no filter, omit the `--scope` flag to get all documents:
+
+```bash
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs docs list
+```
+
+Parse the JSON result:
+- `scopes`: array of scope objects, each with `scope`, `scope_id`, and `docs` array
+- Each doc has: `name` (original), `slug`, `type` (file extension), `size` (formatted), `added` (date), `extraction` (success/failed/skipped)
+- `total_count`: total number of documents across all scopes
+- `scope_count`: number of scopes with documents
+</step>
+
+<step name="display">
+**If no documents exist (total_count === 0 and no filter applied):**
+
+Display:
+```
+No documents found. Run /dgs:add-doc to add one.
+```
+Exit.
+
+**If scope filter returns empty:**
+
+Display:
+```
+No documents found in {scope}.
+```
+Exit.
+
+**Otherwise, display grouped sections:**
+
+Group documents by scope. Order: **Product Documents** first, then **Idea: {name}** for each idea, then **Spec: {name}** for each spec.
+
+For each scope that has documents, display a section:
+
+```
+## Product Documents
+
+| Name | Type | Size | Added | Extraction |
+|------|------|------|-------|------------|
+| q4-budget.pdf | PDF | 2.4 MB | 2026-02-25 | success |
+| architecture-diagram.png | PNG | 540 KB | 2026-02-25 | skipped |
+```
+
+For idea/spec scopes:
+
+```
+## Idea: Auto Review PRs
+
+| Name | Type | Size | Added | Extraction |
+|------|------|------|-------|------------|
+| review-process.docx | DOCX | 89 KB | 2026-02-25 | success |
+```
+
+**Summary line at bottom:**
+
+```
+{N} document(s) across {M} scope(s)
+```
+
+If filtering by scope, note the filter:
+
+```
+Showing: {scope} | {N} document(s)
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Documents displayed grouped by scope with headers
+- [ ] Each document shows name, type, size, added date, and extraction status
+- [ ] --scope filter works for product, idea, and spec scopes
+- [ ] Empty state shows helpful hint
+- [ ] Summary count displayed at bottom
+</success_criteria>

package/deliver-great-systems/workflows/list-ideas.md

@@ -0,0 +1,154 @@
+<purpose>
+List all ideas grouped by state (Pending, Done, Rejected, and optionally Consolidated) with optional tag and state filtering, orphan detection for done ideas, and a helpful empty-state message. This is the primary dashboard for viewing idea status.
+
+By default, consolidated ideas are hidden. Use `--consolidated` to show only consolidated ideas, or `--all` to include consolidated ideas alongside all other states.
+</purpose>
+
+<context_tier>lite</context_tier>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="load_context" priority="first">
+Load project context via tier system:
+
+```bash
+TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" context load-tier lite --raw 2>/dev/null)
+```
+
+Use `TIER_FILES` JSON `files` array for project context (PROJECT.md, STATE.md, config.json).
+</step>
+
+<step name="parse_arguments">
+Parse filter flags from arguments:
+
+- Check for `--tag TAG` filter (e.g., `--tag api`)
+- Check for state filter flags: `--pending`, `--done`, `--rejected`
+- Check for `--consolidated` flag (show only consolidated ideas)
+- Check for `--all` flag (include consolidated ideas alongside all other states)
+- Map state flags to the `--state` parameter value
+- `--consolidated` and `--all` are mutually exclusive with each other and with state filters (`--pending`/`--done`/`--rejected`)
+
+Examples:
+- `/dgs:list-ideas` -> no filters (show pending, done, rejected; consolidated hidden)
+- `/dgs:list-ideas --tag api` -> filter by tag "api" (consolidated still hidden)
+- `/dgs:list-ideas --pending` -> show only pending ideas
+- `/dgs:list-ideas --done --tag ux` -> show only done ideas with tag "ux"
+- `/dgs:list-ideas --consolidated` -> show only consolidated ideas
+- `/dgs:list-ideas --all` -> show all ideas including consolidated
+
+Only one state filter allowed at a time. If multiple provided, use the first one.
+</step>
+
+<step name="fetch_ideas">
+Fetch ideas data with orphan detection:
+
+```bash
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs ideas list [--state STATE] [--tag TAG] [--consolidated] [--all] --orphan-check --raw
+```
+
+Build the command with applicable flags from step 1. Pass `--consolidated` or `--all` when those flags are present.
+
+Parse the JSON result with fields:
+- `ideas`: array of idea objects (id, title, tags, created, state, orphaned, discussed, researched, consolidated_into)
+- `counts`: object with pending, done, rejected, consolidated, total counts
+- `orphaned_ids`: array of IDs for done ideas with no spec reference
+
+The `discussed` and `researched` fields are booleans indicating whether the idea has a Discussion Log or Research Log section with content.
+</step>
+
+<step name="format_output">
+**If no ideas exist (counts.total === 0):**
+
+Display:
+```
+No ideas yet. Run /dgs:add-idea to capture one.
+```
+Exit.
+
+**Otherwise, display grouped sections:**
+
+Group ideas by state. For each state that has ideas, display a section with header and table.
+
+Order: Pending first, then Done, then Rejected, then Consolidated (if included).
+
+For each state group (Pending, Done, Rejected):
+
+```
+## Pending (N)
+
+| ID | Title | Dev | Tags | Created |
+|----|-------|-----|------|---------|
+| 042 | Auto review reminders | D+R | api, automation | 2026-02-25 |
+| 043 | Better error messages | - | ux | 2026-02-25 |
+```
+
+For the Consolidated state group (shown with `--consolidated` or `--all`):
+
+```
+## Consolidated (N)
+
+| ID | Title | Consolidated Into | Tags | Created |
+|----|-------|-------------------|------|---------|
+| 001 | Add retry logic | -> #005 | api | 2026-02-25 |
+```
+
+The "Consolidated Into" column replaces "Dev" for consolidated ideas, showing `-> #ID` where the ID comes from the `consolidated_into` field.
+
+Formatting rules:
+- **ID:** Zero-padded 3-digit (e.g., 042)
+- **Title:** As stored. For done ideas whose ID appears in `orphaned_ids`, append ` [orphaned]` to the title (inline marker per CONTEXT.md)
+- **Dev:** Development status indicator based on `discussed` and `researched` fields:
+  - `D+R` — both discussed AND researched
+  - `D` — discussed only
+  - `R` — researched only
+  - `-` — neither discussed nor researched
+- **Consolidated Into:** For consolidated ideas only, display `-> #ID` from the `consolidated_into` field
+- **Tags:** Comma-separated, or empty cell if none
+- **Created:** Date portion only (YYYY-MM-DD), extracted from ISO timestamp
+
+If filtering by state (--pending/--done/--rejected), only show that one section.
+If using `--consolidated`, only show the Consolidated section.
+If using `--all`, show all sections including Consolidated.
+If filtering by tag, only show ideas matching the tag (across all displayed states).
+
+**Summary line at bottom:**
+
+When consolidated ideas are visible (via `--consolidated` or `--all`), include the consolidated count:
+
+```
+Total: N ideas (P pending, D done, R rejected, C consolidated)
+```
+
+Only show the consolidated count when it is non-zero and the view includes consolidated.
+
+Use the counts from the JSON result. If filtering by state, still show the full count line but note the filter:
+
+```
+Showing: pending only | Total: N ideas (P pending, D done, R rejected)
+```
+
+For `--consolidated`:
+
+```
+Showing: consolidated only | Total: N ideas (P pending, D done, R rejected, C consolidated)
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Ideas displayed grouped by state with headers
+- [ ] Each idea shows ID, title, Dev status, tags, and created date
+- [ ] Dev column shows D (discussed), R (researched), D+R (both), or - (neither)
+- [ ] Orphaned done ideas marked with inline [orphaned] marker
+- [ ] Tag and state filters work
+- [ ] Empty state shows helpful hint
+- [ ] Consolidated ideas hidden by default
+- [ ] `--consolidated` flag shows only consolidated ideas with "Consolidated Into" column
+- [ ] `--all` flag shows all ideas including consolidated
+- [ ] Summary line includes consolidated count when consolidated ideas are visible
+</success_criteria>

package/deliver-great-systems/workflows/list-jobs.md

@@ -0,0 +1,89 @@
+<purpose>
+Display all milestone jobs grouped by status with progress fractions. Provides a quick overview of all jobs in the system.
+</purpose>
+
+<context_tier>lite</context_tier>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="load_context" priority="first">
+Load project context via tier system:
+
+```bash
+TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" context load-tier lite --raw 2>/dev/null)
+```
+
+Use `TIER_FILES` JSON `files` array for project context (PROJECT.md, STATE.md, config.json).
+</step>
+
+<step name="fetch_jobs">
+Run the list-jobs CLI command to get all jobs:
+
+```bash
+RESULT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs jobs list-jobs)
+```
+
+Parse the JSON result. The response contains three arrays at the top level:
+```json
+{
+  "in_progress": [...],
+  "pending": [...],
+  "completed": [...]
+}
+```
+
+Each job object contains:
+- `version`: The milestone version (e.g., "v6.0")
+- `progress`: Progress fraction string (e.g., "4/12")
+- `check`: Whether audit/complete steps are included
+- `status`: Current status
+</step>
+
+<step name="display_results">
+Format and display the results grouped by status.
+
+**Display order:** In Progress first, then Pending, then Completed. Within each group, most recent first.
+
+**If no jobs at all (total is 0):**
+```
+No jobs found. Create one with /dgs:create-milestone-job
+```
+
+**Otherwise, display each group:**
+
+```
+### In Progress
+
+- **v6.0** -- 4/12 steps completed
+- **v5.1** -- 2/8 steps completed (no-check)
+
+### Pending
+
+- **v7.0** -- 0/15 steps completed
+
+### Completed
+
+- **v5.0** -- 10/10 steps completed
+```
+
+**Format rules:**
+- Section headers: `### In Progress`, `### Pending`, `### Completed`
+- Each job line: `- **{version}** -- {progress} steps completed`
+- If `check` is false, append ` (no-check)` annotation
+- If no jobs in a group, show: `(none)`
+- No timing info in list view
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Jobs fetched via `dgs-tools.cjs jobs list-jobs` CLI call
+- [ ] Results grouped by status: In Progress, Pending, Completed
+- [ ] Each job shows version and progress fraction
+- [ ] No-check jobs annotated
+- [ ] Empty state shows helpful message with create command
+</success_criteria>

package/deliver-great-systems/workflows/list-phase-assumptions.md

@@ -0,0 +1,192 @@
+<purpose>
+Surface Claude's assumptions about a phase before planning, enabling users to correct misconceptions early.
+
+Key difference from discuss-phase: This is ANALYSIS of what Claude thinks, not INTAKE of what user knows. No file output - purely conversational to prompt discussion.
+</purpose>
+
+<context_tier>planning</context_tier>
+
+<process>
+
+<step name="validate_phase" priority="first">
+Phase number: $ARGUMENTS (required)
+
+```bash
+INIT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs init phase-op "${PHASE}")
+```
+
+Parse JSON for: `roadmap_path`, `phase_dir`, `phase_number`, `phase_name`.
+
+Load planning-tier context files:
+
+```bash
+TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" context load-tier planning --raw 2>/dev/null)
+```
+
+**If argument missing:**
+
+```
+Error: Phase number required.
+
+Usage: /dgs:list-phase-assumptions [phase-number]
+Example: /dgs:list-phase-assumptions 3
+```
+
+Exit workflow.
+
+**If argument provided:**
+Validate phase exists in roadmap:
+
+```bash
+cat ${roadmap_path} | grep -i "Phase ${PHASE}"
+```
+
+**If phase not found:**
+
+```
+Error: Phase ${PHASE} not found in roadmap.
+
+Available phases:
+[list phases from roadmap]
+```
+
+Exit workflow.
+
+**If phase found:**
+Parse phase details from roadmap:
+
+- Phase number
+- Phase name
+- Phase description/goal
+- Any scope details mentioned
+
+Continue to analyze_phase.
+</step>
+
+<step name="analyze_phase">
+Based on roadmap description and project context, identify assumptions across five areas:
+
+**1. Technical Approach:**
+What libraries, frameworks, patterns, or tools would Claude use?
+- "I'd use X library because..."
+- "I'd follow Y pattern because..."
+- "I'd structure this as Z because..."
+
+**2. Implementation Order:**
+What would Claude build first, second, third?
+- "I'd start with X because it's foundational"
+- "Then Y because it depends on X"
+- "Finally Z because..."
+
+**3. Scope Boundaries:**
+What's included vs excluded in Claude's interpretation?
+- "This phase includes: A, B, C"
+- "This phase does NOT include: D, E, F"
+- "Boundary ambiguities: G could go either way"
+
+**4. Risk Areas:**
+Where does Claude expect complexity or challenges?
+- "The tricky part is X because..."
+- "Potential issues: Y, Z"
+- "I'd watch out for..."
+
+**5. Dependencies:**
+What does Claude assume exists or needs to be in place?
+- "This assumes X from previous phases"
+- "External dependencies: Y, Z"
+- "This will be consumed by..."
+
+Be honest about uncertainty. Mark assumptions with confidence levels:
+- "Fairly confident: ..." (clear from roadmap)
+- "Assuming: ..." (reasonable inference)
+- "Unclear: ..." (could go multiple ways)
+</step>
+
+<step name="present_assumptions">
+Present assumptions in a clear, scannable format:
+
+```
+## My Assumptions for Phase ${PHASE}: ${PHASE_NAME}
+
+### Technical Approach
+[List assumptions about how to implement]
+
+### Implementation Order
+[List assumptions about sequencing]
+
+### Scope Boundaries
+**In scope:** [what's included]
+**Out of scope:** [what's excluded]
+**Ambiguous:** [what could go either way]
+
+### Risk Areas
+[List anticipated challenges]
+
+### Dependencies
+**From prior phases:** [what's needed]
+**External:** [third-party needs]
+**Feeds into:** [what future phases need from this]
+
+---
+
+**What do you think?**
+
+Are these assumptions accurate? Let me know:
+- What I got right
+- What I got wrong
+- What I'm missing
+```
+
+Wait for user response.
+</step>
+
+<step name="gather_feedback">
+**If user provides corrections:**
+
+Acknowledge the corrections:
+
+```
+Key corrections:
+- [correction 1]
+- [correction 2]
+
+This changes my understanding significantly. [Summarize new understanding]
+```
+
+**If user confirms assumptions:**
+
+```
+Assumptions validated.
+```
+
+Continue to offer_next.
+</step>
+
+<step name="offer_next">
+Present next steps:
+
+```
+What's next?
+1. Discuss context (/dgs:discuss-phase ${PHASE}) - Let me ask you questions to build comprehensive context
+2. Plan this phase (/dgs:plan-phase ${PHASE}) - Create detailed execution plans
+3. Re-examine assumptions - I'll analyze again with your corrections
+4. Done for now
+```
+
+Wait for user selection.
+
+If "Discuss context": Note that CONTEXT.md will incorporate any corrections discussed here
+If "Plan this phase": Proceed knowing assumptions are understood
+If "Re-examine": Return to analyze_phase with updated understanding
+</step>
+
+</process>
+
+<success_criteria>
+- Phase number validated against roadmap
+- Assumptions surfaced across five areas: technical approach, implementation order, scope, risks, dependencies
+- Confidence levels marked where appropriate
+- "What do you think?" prompt presented
+- User feedback acknowledged
+- Clear next steps offered
+</success_criteria>