@ktpartners/dgs-platform 2.9.0 → 3.3.0

package/deliver-great-systems/workflows/progress-all.md

@@ -0,0 +1,133 @@
+<purpose>
+Render a product-level dashboard spanning all active projects. Read-only summary — no routing or next-action recommendations. To act on a specific project, switch to it first.
+</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="init_context">
+Load product dashboard context:
+
+```bash
+INIT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" init progress-all --raw)
+```
+
+Parse the JSON. Extract: `product`, `projects`, `warnings`, `planner_model`, `executor_model`, `sync_push`, `sync_pull`, `needs_pull`, `dgs_mode`, `author`, `planning_root`.
+
+If `projects` is empty AND `product.completed_count` is 0:
+Show: "No projects found. Run /dgs:new-project to start one." and exit.
+</step>
+
+<step name="render_product_header">
+Render:
+
+```
+# {product.product_name OR "Product Dashboard"}
+
+**Active projects:** {product.active_count}  |  **Completed:** {product.completed_count}
+**Mode:** {dgs_mode}  |  **Planning root:** {planning_root}
+```
+</step>
+
+<step name="render_active_projects">
+If `projects` is non-empty, render a table:
+
+```
+## Active Projects
+
+| Project | Progress | Current Phase | Milestone | Repos Touched |
+|---------|----------|---------------|-----------|---------------|
+| {name} | {progress}% | {current_phase} | {milestone_version} {milestone_name} | {repos_touched} |
+```
+
+Build a simple progress bar inline if desired (e.g., `[####------] 40%`).
+Skip fields that are null/empty with em-dash ("—").
+
+If `projects` is empty, show: "_No active projects._"
+</step>
+
+<step name="render_product_backlog">
+```
+## Product Backlog
+
+- **Todos:** {product.backlog.todos} pending
+- **Ideas:** {product.backlog.ideas} pending
+- **Specs:** {product.backlog.specs} open
+- **Active debug sessions:** {product.backlog.debug_active}
+```
+
+Omit any line with count = 0 to reduce noise, but always show the header.
+</step>
+
+<step name="render_recent_quick_tasks">
+If `product.quick_tasks_recent.length > 0`:
+
+```
+## Recent Quick Tasks (product-level)
+
+| # | Description | Date | Commit | Status |
+|---|-------------|------|--------|--------|
+| {id} | {description} | {date} | {commit} | {status} |
+```
+
+Show up to 5 most recent. If empty, show: "_No product-level quick tasks yet._"
+</step>
+
+<step name="render_recent_shipments">
+If `product.shipped_milestones_recent.length > 0`:
+
+```
+## Recent Shipments
+
+- **{version}** {name} — shipped {shipped_date}
+```
+
+Show up to 5. If empty, OMIT the entire section (don't show the header).
+</step>
+
+<step name="render_per_project_cards">
+For each project in `projects`:
+
+```
+---
+
+### {name}
+
+**Progress:** [{bar}] {progress}%
+**Status:** {status}
+**Current Phase:** {current_phase}
+**Milestone:** {milestone_version} {milestone_name}
+**Repos:** {repos_touched}
+```
+
+Skip the per-project card section entirely if `projects.length <= 3` (the table above is already enough). Otherwise render cards.
+</step>
+
+<step name="footer_note">
+Render:
+
+```
+---
+
+_Dashboard is read-only. To act on a project, run `/dgs:switch-project <name>` then `/dgs:progress`._
+
+_To see single-project detail now, run `/dgs:progress` (without --all)._
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Product header rendered with counts
+- [ ] Active projects table rendered (or empty-state message)
+- [ ] Backlog counts shown
+- [ ] Recent quick tasks rendered or explicit empty message
+- [ ] Recent shipments rendered (omitted if none)
+- [ ] No routing or next-action recommendations (dashboard is read-only)
+- [ ] Footer note explains how to drill down
+</success_criteria>

package/deliver-great-systems/workflows/quick-abandon.md

@@ -0,0 +1,89 @@
+<purpose>
+Abandon the active product-level quick task: remove worktree and branch without merging. All committed and uncommitted changes in the worktree are discarded.
+
+Requires explicit confirmation before proceeding. This is destructive and cannot be undone.
+</purpose>
+
+<context_tier>none</context_tier>
+
+<process>
+
+**Step 1: Validate active quick**
+
+Check for active product-level quick:
+```bash
+ACTIVE=$(node -e "
+  const q = require('$HOME/.claude/deliver-great-systems/bin/lib/quick.cjs');
+  const a = q.getActiveQuick(process.cwd());
+  process.stdout.write(JSON.stringify(a || { none: true }));
+")
+```
+
+Parse result. If `none` is true:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+No active product-level quick to abandon.
+
+If working in a milestone context, changes are part of the milestone.
+```
+End workflow.
+
+Extract `$SLUG` from result.
+
+**Step 2: Confirm abandonment**
+
+```
+AskUserQuestion(
+  header: "Abandon Quick",
+  question: "Abandon quick '${SLUG}'? All uncommitted and committed changes will be lost.",
+  options: [
+    { label: "Yes, abandon", description: "Remove worktree and branch — changes are lost" },
+    { label: "No, keep", description: "Cancel — quick remains active" }
+  ]
+)
+```
+
+If "No, keep": Display `Quick '${SLUG}' remains active.` End workflow.
+
+**Step 3: Execute abandonment**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► ABANDONING QUICK
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Removing worktree and branch...
+```
+
+```bash
+RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" quick-abandon --confirmed 2>&1)
+EXIT_CODE=$?
+```
+
+**Step 4: Display result**
+
+**If exit code is 0 (success):**
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► QUICK ABANDONED ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Quick '${SLUG}' abandoned. Worktree removed.
+No changes merged to main.
+```
+
+**If error:**
+Display the error message from RESULT.
+
+</process>
+
+<success_criteria>
+- [ ] Active product-level quick validated
+- [ ] Confirmation required before abandonment
+- [ ] Worktree and branch removed without merging
+- [ ] active_context cleared
+- [ ] No commits from quick branch appear on base_branch
+</success_criteria>

package/deliver-great-systems/workflows/quick-complete.md

@@ -0,0 +1,106 @@
+<purpose>
+Complete the active product-level quick task: rebase onto base_branch, fast-forward merge, push to remote, and clean up the worktree. Uses the shared rebaseAndMerge() flow from worktrees.cjs.
+
+This workflow is only valid for product-level quicks. If the user is working in a milestone context, displays a clear error directing them to complete-milestone instead.
+</purpose>
+
+<context_tier>none</context_tier>
+
+<process>
+
+**Step 1: Generate inline review summary**
+
+Before rebase-and-merge, generate a review report while the quick branch still exists with original commits.
+
+```bash
+REVIEW_RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" quick generate-review --raw 2>&1)
+REVIEW_EXIT=$?
+```
+
+**If generation succeeds** (`REVIEW_EXIT` is 0):
+
+Parse JSON output for the summary:
+```bash
+REVIEW_PATH=$(echo "$REVIEW_RESULT" | jq -r '.relativePath // empty')
+REVIEW_COMMITS=$(echo "$REVIEW_RESULT" | jq -r '.stats.commits // 0')
+REVIEW_FILES=$(echo "$REVIEW_RESULT" | jq -r '.stats.filesChanged // 0')
+REVIEW_RISKS=$(echo "$REVIEW_RESULT" | jq -r '.stats.riskFlags // 0')
+```
+
+Display the stats banner:
+```
+Review: ${REVIEW_PATH} (${REVIEW_COMMITS} commits, ${REVIEW_FILES} files${REVIEW_RISKS > 0 ? ", ${REVIEW_RISKS} risk flags" : ""})
+```
+
+**If fast-forward detected** (output contains `"fastForward": true`):
+
+Display: `No code changes detected -- review not generated.`
+
+**If generation fails** (`REVIEW_EXIT` is non-zero):
+
+Log warning and continue -- do NOT block task completion:
+```
+Warning: Review generation failed. Continuing with completion.
+```
+
+Review generation failure is non-fatal. The quick task will still complete normally.
+
+**Step 2: Validate and execute quick-complete**
+
+Call the quick-complete CLI command which validates the active quick and executes the full flow:
+
+```bash
+RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" quick-complete 2>&1)
+EXIT_CODE=$?
+```
+
+**If exit code is non-zero** (error):
+
+Check if error contains "No active product-level quick":
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+No active product-level quick to complete.
+
+If working in a milestone context, changes merge with the milestone.
+Use: /dgs:complete-milestone
+
+If you abandoned the quick, the worktree was already removed.
+```
+End workflow.
+
+For other errors (including rebase conflicts), display the error message.
+If the error contains manual resolution instructions, display them verbatim, then:
+```
+After resolving conflicts manually, re-run:
+
+/dgs:quick-complete
+```
+End workflow.
+
+**Step 3: Display success**
+
+Parse JSON result from RESULT.
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► QUICK COMPLETE ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Quick '${slug}' merged to main (${commits} commits).
+Worktree cleaned up. Pushed to origin.
+```
+
+</process>
+
+<success_criteria>
+- [ ] Review summary generated before rebase-and-merge (or warning logged on failure)
+- [ ] Active product-level quick validated
+- [ ] Rebase-before-merge flow executed via rebaseAndMerge()
+- [ ] Worktree and branch cleaned up
+- [ ] active_context cleared
+- [ ] Success message includes commit count
+- [ ] Conflict case shows manual resolution instructions
+</success_criteria>