@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/workflows/node-repair.md

@@ -0,0 +1,94 @@
+<purpose>
+Autonomous repair operator for failed task verification. Invoked by execute-plan when a task fails its done-criteria. Proposes and attempts structured fixes before escalating to the user.
+</purpose>
+
+<context_tier>none</context_tier>
+
+<inputs>
+- FAILED_TASK: Task number, name, and done-criteria from the plan
+- ERROR: What verification produced — actual result vs expected
+- PLAN_CONTEXT: Adjacent tasks and phase goal (for constraint awareness)
+- REPAIR_BUDGET: Max repair attempts remaining (default: 2)
+</inputs>
+
+<repair_directive>
+Analyze the failure and choose exactly one repair strategy:
+
+**RETRY** — The approach was right but execution failed. Try again with a concrete adjustment.
+- Use when: command error, missing dependency, wrong path, env issue, transient failure
+- Output: `RETRY: [specific adjustment to make before retrying]`
+
+**DECOMPOSE** — The task is too coarse. Break it into smaller verifiable sub-steps.
+- Use when: done-criteria covers multiple concerns, implementation gaps are structural
+- Output: `DECOMPOSE: [sub-task 1] | [sub-task 2] | ...` (max 3 sub-tasks)
+- Sub-tasks must each have a single verifiable outcome
+
+**PRUNE** — The task is infeasible given current constraints. Skip with justification.
+- Use when: prerequisite missing and not fixable here, out of scope, contradicts an earlier decision
+- Output: `PRUNE: [one-sentence justification]`
+
+**ESCALATE** — Repair budget exhausted, or this is an architectural decision (Rule 4).
+- Use when: RETRY failed more than once with different approaches, or fix requires structural change
+- Output: `ESCALATE: [what was tried] | [what decision is needed]`
+</repair_directive>
+
+<process>
+
+<step name="diagnose">
+Read the error and done-criteria carefully. Ask:
+1. Is this a transient/environmental issue? → RETRY
+2. Is the task verifiably too broad? → DECOMPOSE
+3. Is a prerequisite genuinely missing and unfixable in scope? → PRUNE
+4. Has RETRY already been attempted with this task? Check REPAIR_BUDGET. If 0 → ESCALATE
+</step>
+
+<step name="execute_retry">
+If RETRY:
+1. Apply the specific adjustment stated in the directive
+2. Re-run the task implementation
+3. Re-run verification
+4. If passes → continue normally, log `[Node Repair - RETRY] Task [X]: [adjustment made]`
+5. If fails again → decrement REPAIR_BUDGET, re-invoke node-repair with updated context
+</step>
+
+<step name="execute_decompose">
+If DECOMPOSE:
+1. Replace the failed task inline with the sub-tasks (do not modify PLAN.md on disk)
+2. Execute sub-tasks sequentially, each with its own verification
+3. If all sub-tasks pass → treat original task as succeeded, log `[Node Repair - DECOMPOSE] Task [X] → [N] sub-tasks`
+4. If a sub-task fails → re-invoke node-repair for that sub-task (REPAIR_BUDGET applies per sub-task)
+</step>
+
+<step name="execute_prune">
+If PRUNE:
+1. Mark task as skipped with justification
+2. Log to SUMMARY "Issues Encountered": `[Node Repair - PRUNE] Task [X]: [justification]`
+3. Continue to next task
+</step>
+
+<step name="execute_escalate">
+If ESCALATE:
+1. Surface to user via verification_failure_gate with full repair history
+2. Present: what was tried (each RETRY/DECOMPOSE attempt), what the blocker is, options available
+3. Wait for user direction before continuing
+</step>
+
+</process>
+
+<logging>
+All repair actions must appear in SUMMARY.md under "## Deviations from Plan":
+
+| Type | Format |
+|------|--------|
+| RETRY success | `[Node Repair - RETRY] Task X: [adjustment] — resolved` |
+| RETRY fail → ESCALATE | `[Node Repair - RETRY] Task X: [N] attempts exhausted — escalated to user` |
+| DECOMPOSE | `[Node Repair - DECOMPOSE] Task X split into [N] sub-tasks — all passed` |
+| PRUNE | `[Node Repair - PRUNE] Task X skipped: [justification]` |
+</logging>
+
+<constraints>
+- REPAIR_BUDGET defaults to 2 per task. Configurable via dgs.config.json `workflow.node_repair_budget`.
+- Never modify PLAN.md on disk — decomposed sub-tasks are in-memory only.
+- DECOMPOSE sub-tasks must be more specific than the original, not synonymous rewrites.
+- If dgs.config.json `workflow.node_repair` is `false`, skip directly to verification_failure_gate (user retains original behavior).
+</constraints>

package/deliver-great-systems/workflows/overlap-check.md

@@ -0,0 +1,86 @@
+<purpose>
+Show which repos and files are touched by multiple active projects.
+Non-blocking informational output — never prevents work.
+</purpose>
+
+<context_tier>lite</context_tier>
+
+<process>
+
+## 1. Initialize
+
+Check v2 install:
+```bash
+INIT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs init phase-op "1" 2>/dev/null)
+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).
+
+Parse JSON. If not v2 (no PROJECTS.md/REPOS.md — `dgs_mode` is not `v2`):
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► OVERLAP CHECK
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Overlap check requires v2 multi-project setup.
+Run /dgs:init-product first.
+```
+
+Exit.
+
+## 2. Run Overlap Check
+
+```bash
+OVERLAP=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs overlap check --raw)
+```
+
+Parse JSON result. Extract `overlapping_repos` array and `warnings` array.
+
+## 3. Present Results
+
+**If no overlaps** (`overlapping_repos` is empty):
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► OVERLAP CHECK ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+No cross-project overlaps detected.
+
+Each active project touches unique repos.
+```
+
+**If overlaps found:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► OVERLAP CHECK
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⚠ {N} repo(s) touched by multiple active projects
+
+| Repo | Projects |
+|------|----------|
+| {repo} | {project1}, {project2} |
+
+### File-Level Conflicts
+
+**{repo}:**
+- {file1} — {project1}, {project2}
+- {file2} — {project1}
+
+This is informational — overlapping repos don't block work.
+Coordinate merges manually if projects touch the same files.
+```
+
+**If warnings exist** (ghost projects, etc.), append:
+
+```
+### Warnings
+- {warning1}
+- {warning2}
+```
+
+</process>

package/deliver-great-systems/workflows/pause-work.md

@@ -0,0 +1,134 @@
+<purpose>
+Create `.continue-here.md` handoff file to preserve complete work state across sessions. Enables seamless resumption with full context restoration.
+</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="detect">
+Find current phase directory from most recently modified files:
+
+```bash
+# Find most recent phase directory with work
+ls -lt ${project_root}/phases/*/PLAN.md 2>/dev/null | head -1 | grep -oP 'phases/\K[^/]+'
+```
+
+If no active phase detected, ask user which phase they're pausing work on.
+</step>
+
+<step name="gather">
+**Collect complete state for handoff:**
+
+1. **Current position**: Which phase, which plan, which task
+2. **Work completed**: What got done this session
+3. **Work remaining**: What's left in current plan/phase
+4. **Decisions made**: Key decisions and rationale
+5. **Blockers/issues**: Anything stuck
+6. **Mental context**: The approach, next steps, "vibe"
+7. **Files modified**: What's changed but not committed
+
+Ask user for clarifications if needed via conversational questions.
+</step>
+
+<step name="write">
+**Write handoff to `${phase_dir}/.continue-here.md`:**
+
+```markdown
+---
+phase: XX-name
+task: 3
+total_tasks: 7
+status: in_progress
+last_updated: [timestamp from current-timestamp]
+---
+
+<current_state>
+[Where exactly are we? Immediate context]
+</current_state>
+
+<completed_work>
+
+- Task 1: [name] - Done
+- Task 2: [name] - Done
+- Task 3: [name] - In progress, [what's done]
+</completed_work>
+
+<remaining_work>
+
+- Task 3: [what's left]
+- Task 4: Not started
+- Task 5: Not started
+</remaining_work>
+
+<decisions_made>
+
+- Decided to use [X] because [reason]
+- Chose [approach] over [alternative] because [reason]
+</decisions_made>
+
+<blockers>
+- [Blocker 1]: [status/workaround]
+</blockers>
+
+<context>
+[Mental state, what were you thinking, the plan]
+</context>
+
+<next_action>
+Start with: [specific first action when resuming]
+</next_action>
+```
+
+Be specific enough for a fresh Claude to understand immediately.
+
+Use `current-timestamp` for last_updated field. You can use init todos (which provides timestamps) or call directly:
+```bash
+timestamp=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" current-timestamp full --raw)
+```
+</step>
+
+<step name="commit">
+```bash
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "wip: [phase-name] paused at task [X]/[Y]" --files ${phase_dir}/.continue-here.md
+```
+</step>
+
+<step name="confirm">
+```
+✓ Handoff created: ${phase_dir}/.continue-here.md
+
+Current state:
+
+- Phase: [XX-name]
+- Task: [X] of [Y]
+- Status: [in_progress/blocked]
+- Committed as WIP
+
+To resume: /dgs:resume-work
+
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] .continue-here.md created in correct phase directory
+- [ ] All sections filled with specific content
+- [ ] Committed as WIP
+- [ ] User knows location and how to resume
+</success_criteria>

package/deliver-great-systems/workflows/plan-milestone-gaps.md

@@ -0,0 +1,306 @@
+<purpose>
+Create all phases necessary to close gaps identified by `/dgs:audit-milestone`. Reads MILESTONE-AUDIT.md, groups gaps into logical phases, creates phase entries in ROADMAP.md, and offers to plan each phase. One command creates all fix phases — no manual `/dgs:add-phase` per gap.
+</purpose>
+
+<context_tier>planning</context_tier>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+## 0. Load Context
+
+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)
+```
+
+## 1. Load Audit Results
+
+```bash
+# Find the most recent audit file
+ls -t ${project_root}/v*-MILESTONE-AUDIT.md 2>/dev/null | head -1
+```
+
+Parse YAML frontmatter to extract structured gaps:
+- `gaps.requirements` — unsatisfied requirements
+- `gaps.integration` — missing cross-phase connections
+- `gaps.flows` — broken E2E flows
+
+If no audit file exists or has no gaps, error:
+```
+No audit gaps found. Run `/dgs:audit-milestone` first.
+```
+
+## 1b. Parse Arguments
+
+Parse `$ARGUMENTS` for:
+- `--auto` flag --> store as `NON_INTERACTIVE` (true/false)
+- Remaining text --> version identifier
+
+```bash
+# Example: "v10.0 --auto" --> NON_INTERACTIVE=true, VERSION="v10.0"
+NON_INTERACTIVE=false
+if echo "$ARGUMENTS" | grep -q "\-\-auto"; then
+  NON_INTERACTIVE=true
+fi
+```
+
+## 2. Prioritize Gaps
+
+Group gaps by priority from REQUIREMENTS.md:
+
+| Priority | Action |
+|----------|--------|
+| `must` | Create phase, blocks milestone |
+| `should` | Create phase, recommended |
+| `nice` | Ask user: include or defer? |
+
+For integration/flow gaps, infer priority from affected requirements.
+
+## 3. Group Gaps into Phases
+
+Cluster related gaps into logical phases:
+
+**Grouping rules:**
+- Same affected phase → combine into one fix phase
+- Same subsystem (auth, API, UI) → combine
+- Dependency order (fix stubs before wiring)
+- Keep phases focused: 2-4 tasks each
+
+**Example grouping:**
+```
+Gap: DASH-01 unsatisfied (Dashboard doesn't fetch)
+Gap: Integration Phase 1→3 (Auth not passed to API calls)
+Gap: Flow "View dashboard" broken at data fetch
+
+→ Phase 6: "Wire Dashboard to API"
+  - Add fetch to Dashboard.tsx
+  - Include auth header in fetch
+  - Handle response, update state
+  - Render user data
+```
+
+## 4. Determine Phase Numbers
+
+Find highest existing phase:
+```bash
+# Get sorted phase list, extract last one
+PHASES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" phases list)
+HIGHEST=$(printf '%s\n' "$PHASES" | jq -r '.directories[-1]')
+```
+
+New phases continue from there:
+- If Phase 5 is highest, gaps become Phase 6, 7, 8...
+
+## 5. Present Gap Closure Plan
+
+```markdown
+## Gap Closure Plan
+
+**Milestone:** {version}
+**Gaps to close:** {N} requirements, {M} integration, {K} flows
+
+### Proposed Phases
+
+**Phase {N}: {Name}**
+Closes:
+- {REQ-ID}: {description}
+- Integration: {from} → {to}
+Tasks: {count}
+
+**Phase {N+1}: {Name}**
+Closes:
+- {REQ-ID}: {description}
+- Flow: {flow name}
+Tasks: {count}
+
+{If nice-to-have gaps exist:}
+
+### Deferred (nice-to-have)
+
+These gaps are optional. Include them?
+- {gap description}
+- {gap description}
+
+---
+
+Create these {X} phases? (yes / adjust / defer all optional)
+```
+
+**If `NON_INTERACTIVE` is true:**
+- Auto-include all must/should gaps
+- Auto-include nice-to-have gaps (job mode resolves ambiguity by including everything)
+- Display: `[AUTO-RESOLVE] Auto-approving {X} gap closure phases`
+- Skip to step 6 (do not wait for confirmation)
+
+**If `NON_INTERACTIVE` is false (default):**
+
+Wait for user confirmation.
+
+## 6. Update ROADMAP.md
+
+Add new phases to current milestone:
+
+```markdown
+### Phase {N}: {Name}
+**Goal:** {derived from gaps being closed}
+**Requirements:** {REQ-IDs being satisfied}
+**Gap Closure:** Closes gaps from audit
+
+### Phase {N+1}: {Name}
+...
+```
+
+## 7. Update REQUIREMENTS.md Traceability Table (REQUIRED)
+
+For each REQ-ID assigned to a gap closure phase:
+- Update the Phase column to reflect the new gap closure phase
+- Reset Status to `Pending`
+
+Reset checked-off requirements the audit found unsatisfied:
+- Change `[x]` → `[ ]` for any requirement marked unsatisfied in the audit
+- Update coverage count at top of REQUIREMENTS.md
+
+```bash
+# Verify traceability table reflects gap closure assignments
+grep -c "Pending" ${project_root}/REQUIREMENTS.md
+```
+
+## 8. Create Phase Directories
+
+```bash
+mkdir -p "${project_root}/phases/{NN}-{name}"
+```
+
+## 9. Commit Roadmap and Requirements Update
+
+```bash
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs(roadmap): add gap closure phases {N}-{M}" --files ${roadmap_path} ${project_root}/REQUIREMENTS.md
+```
+
+## 10. Offer Next Steps
+
+```markdown
+## ✓ Gap Closure Phases Created
+
+**Phases added:** {N} - {M}
+**Gaps addressed:** {count} requirements, {count} integration, {count} flows
+
+---
+
+## ▶ Next Up
+
+**Plan first gap closure phase**
+
+`/dgs:plan-phase {N}`
+
+<sub>`/clear` first → fresh context window</sub>
+
+---
+
+**Also available:**
+- `/dgs:execute-phase {N}` — if plans already exist
+- `cat ${roadmap_path}` — see updated roadmap
+
+---
+
+**After all gap phases complete:**
+
+`/dgs:audit-milestone` — re-audit to verify gaps closed
+`/dgs:complete-milestone {version}` — archive when audit passes
+```
+
+</process>
+
+<gap_to_phase_mapping>
+
+## How Gaps Become Tasks
+
+**Requirement gap → Tasks:**
+```yaml
+gap:
+  id: DASH-01
+  description: "User sees their data"
+  reason: "Dashboard exists but doesn't fetch from API"
+  missing:
+    - "useEffect with fetch to /api/user/data"
+    - "State for user data"
+    - "Render user data in JSX"
+
+becomes:
+
+phase: "Wire Dashboard Data"
+tasks:
+  - name: "Add data fetching"
+    files: [src/components/Dashboard.tsx]
+    action: "Add useEffect that fetches /api/user/data on mount"
+
+  - name: "Add state management"
+    files: [src/components/Dashboard.tsx]
+    action: "Add useState for userData, loading, error states"
+
+  - name: "Render user data"
+    files: [src/components/Dashboard.tsx]
+    action: "Replace placeholder with userData.map rendering"
+```
+
+**Integration gap → Tasks:**
+```yaml
+gap:
+  from_phase: 1
+  to_phase: 3
+  connection: "Auth token → API calls"
+  reason: "Dashboard API calls don't include auth header"
+  missing:
+    - "Auth header in fetch calls"
+    - "Token refresh on 401"
+
+becomes:
+
+phase: "Add Auth to Dashboard API Calls"
+tasks:
+  - name: "Add auth header to fetches"
+    files: [src/components/Dashboard.tsx, src/lib/api.ts]
+    action: "Include Authorization header with token in all API calls"
+
+  - name: "Handle 401 responses"
+    files: [src/lib/api.ts]
+    action: "Add interceptor to refresh token or redirect to login on 401"
+```
+
+**Flow gap → Tasks:**
+```yaml
+gap:
+  name: "User views dashboard after login"
+  broken_at: "Dashboard data load"
+  reason: "No fetch call"
+  missing:
+    - "Fetch user data on mount"
+    - "Display loading state"
+    - "Render user data"
+
+becomes:
+
+# Usually same phase as requirement/integration gap
+# Flow gaps often overlap with other gap types
+```
+
+</gap_to_phase_mapping>
+
+<success_criteria>
+- [ ] MILESTONE-AUDIT.md loaded and gaps parsed
+- [ ] Gaps prioritized (must/should/nice)
+- [ ] Gaps grouped into logical phases
+- [ ] User confirmed phase plan
+- [ ] ROADMAP.md updated with new phases
+- [ ] REQUIREMENTS.md traceability table updated with gap closure phase assignments
+- [ ] Unsatisfied requirement checkboxes reset (`[x]` → `[ ]`)
+- [ ] Coverage count updated in REQUIREMENTS.md
+- [ ] Phase directories created
+- [ ] Changes committed (includes REQUIREMENTS.md)
+- [ ] User knows to run `/dgs:plan-phase` next
+</success_criteria>