@ktpartners/dgs-platform 2.9.0 → 3.3.0

package/deliver-great-systems/workflows/codereview.md

@@ -9,7 +9,10 @@ Multi-agent code review that runs 3 passes of 3 parallel agents each (9 total re
 - PLAN: plan number
 - PLAN_PATH: path to the PLAN.md file
 - PHASE_DIR: phase directory path
+- CODE_REPO_PATH: absolute path to the code repo where task commits live. All git commands in this workflow MUST run against this repo via `git -C "${CODE_REPO_PATH}"`, because the spawned subagent inherits the orchestrator's cwd (the planning repo), not the code repo.
 - DIFF_REF: git ref range for the code diff (from first task commit to HEAD)
+- PROJECT_ROOT: project root directory path (e.g., projects/gsd). Passed by execute-phase. Used to resolve project-scoped context files.
+- PLANNING_ROOT: planning root directory path (git repo root). Passed by execute-phase. Used as fallback for product-level context files.
 </inputs>
 
 <process>
@@ -18,7 +21,7 @@ Multi-agent code review that runs 3 passes of 3 parallel agents each (9 total re
 Compute the diff from the plan's task commits.
 
 ```bash
-FIRST_TASK_COMMIT=$(git log --oneline --grep="feat(${PHASE}-${PLAN}):" --grep="fix(${PHASE}-${PLAN}):" --grep="test(${PHASE}-${PLAN}):" --grep="refactor(${PHASE}-${PLAN}):" --reverse | head -1 | cut -d' ' -f1)
+FIRST_TASK_COMMIT=$(git -C "${CODE_REPO_PATH}" log --oneline --grep="feat(${PHASE}-${PLAN}):" --grep="fix(${PHASE}-${PLAN}):" --grep="test(${PHASE}-${PLAN}):" --grep="refactor(${PHASE}-${PLAN}):" --reverse | head -1 | cut -d' ' -f1)
 ```
 
 If FIRST_TASK_COMMIT is empty, exit with message: "No task commits found for ${PHASE}-${PLAN}, skipping code review."
@@ -26,13 +29,13 @@ If FIRST_TASK_COMMIT is empty, exit with message: "No task commits found for ${P
 Otherwise, compute the full diff:
 
 ```bash
-REVIEW_DIFF=$(git diff ${FIRST_TASK_COMMIT}^..HEAD)
+REVIEW_DIFF=$(git -C "${CODE_REPO_PATH}" diff ${FIRST_TASK_COMMIT}^..HEAD)
 ```
 
 Store REVIEW_DIFF for use by all review agents. Also store the file list:
 
 ```bash
-CHANGED_FILES=$(git diff --name-only ${FIRST_TASK_COMMIT}^..HEAD)
+CHANGED_FILES=$(git -C "${CODE_REPO_PATH}" diff --name-only ${FIRST_TASK_COMMIT}^..HEAD)
 ```
 
 Display:
@@ -43,11 +46,77 @@ Reviewing ${PHASE}-${PLAN} changes:
 ```
 </step>
 
+<step name="load_context">
+Load project context files for domain-specific review. These files provide architecture rules, coding conventions, and design principles that the review agents use to catch project-specific violations alongside generic code quality issues.
+
+If PROJECT_ROOT is empty or not provided, skip the entire step silently (backward compatibility for codereview spawned without PROJECT_ROOT).
+
+**Context files (in truncation priority order -- first truncated = least valuable):**
+1. `codebase/ARCHITECTURE.md` -- auto-generated codebase structure overview
+2. `codebase/CONVENTIONS.md` -- auto-generated naming/import/error handling patterns
+3. `docs/product/ARCHITECTURE.md` -- hand-written target architecture and domain rules
+4. `docs/product/DESIGN-PRINCIPLES.md` -- hand-written design principles and lessons learned
+
+**Path resolution (dual-path fallback):**
+For each file, try two paths in order:
+1. `${PROJECT_ROOT}/<file>` (v2 project-scoped path)
+2. `${PLANNING_ROOT}/<file>` (v1 product-level / synthesized fallback)
+
+Use the Read tool to load each file. If Read returns an error (file not found), silently skip that file. Do NOT error or warn for individual missing files.
+
+**Build PROJECT_CONTEXT:**
+For each successfully loaded file, prepend a header line:
+```
+--- {filename} ({byte_count} bytes) ---
+{file_content}
+```
+
+Concatenate all loaded file contents into a single `PROJECT_CONTEXT` variable.
+
+**Size guard:**
+After loading all files, measure total byte length of PROJECT_CONTEXT.
+
+If total exceeds 51200 bytes (~50KB):
+- Truncate files in priority order (ARCHITECTURE.md from codebase/ first, then CONVENTIONS.md from codebase/, then docs/product/ARCHITECTURE.md, then docs/product/DESIGN-PRINCIPLES.md last)
+- For each truncated file, cut to fit within the remaining budget and append: `\n[Truncated from {original_bytes} bytes to {truncated_bytes} bytes]`
+- After truncation, log a warning:
+  ```
+  ⚠ Project context truncated to ~50KB:
+    {filename}: truncated from {original} to {truncated} bytes
+  ```
+
+**Logging:**
+Display which context files were loaded:
+
+When at least one file found:
+```
+Project context loaded:
+  codebase/ARCHITECTURE.md: {N} bytes
+  codebase/CONVENTIONS.md: {N} bytes (or "not found")
+  docs/product/ARCHITECTURE.md: {N} bytes (or "not found")
+  docs/product/DESIGN-PRINCIPLES.md: {N} bytes (or "not found")
+  Total: {N} bytes
+```
+
+When no files found:
+```
+Project context: no context files found (skipped)
+```
+</step>
+
 <step name="pass_1_foundational">
 **Pass 1: Foundational Review** -- Spawn 3 parallel Task() subagents.
 
 Each agent receives REVIEW_DIFF and CHANGED_FILES as input context.
 
+If PROJECT_CONTEXT is non-empty, also provide it to each agent wrapped in tags:
+
+<project_context>
+{PROJECT_CONTEXT}
+</project_context>
+
+If PROJECT_CONTEXT is empty (no context files found), omit the <project_context> block entirely -- agents receive the same prompt as before this feature was added.
+
 **Agent 1A: Correctness and Security**
 
 Review REVIEW_DIFF for:
@@ -57,6 +126,7 @@ Review REVIEW_DIFF for:
 - Auth bypass, missing authorization checks
 - Secret exposure (hardcoded keys, tokens, passwords)
 - Race conditions, deadlocks
+- Violations of domain-specific rules from PROJECT_CONTEXT (if provided): architecture constraints, module boundary contracts, security policies declared in project docs
 - Memory leaks, resource cleanup
 
 Output: Structured findings list with fields:
@@ -81,7 +151,7 @@ Review REVIEW_DIFF against the plan's `<context>` file patterns for:
 - Type safety (any usage, missing types, loose generics)
 - Consistency with existing codebase patterns
 
-If a codebase/ map exists at ${project_root}/codebase/, reference CONVENTIONS.md for established patterns.
+Reference the project conventions and patterns from PROJECT_CONTEXT (if provided) when evaluating naming, import patterns, error handling, and code organization. Flag deviations from the project's established conventions documented in PROJECT_CONTEXT.
 
 Output: Structured findings list with fields:
 - id: "1B-{N}"
@@ -113,6 +183,14 @@ Output: Structured findings list with fields:
 
 Each agent receives REVIEW_DIFF, CHANGED_FILES, and all Pass 1 findings as input context.
 
+If PROJECT_CONTEXT is non-empty, also provide it to each agent wrapped in tags:
+
+<project_context>
+{PROJECT_CONTEXT}
+</project_context>
+
+If PROJECT_CONTEXT is empty (no context files found), omit the <project_context> block entirely -- agents receive the same prompt as before this feature was added.
+
 **Agent 2A: Fix Verification**
 
 For each auto-fixable finding from Pass 1 (severity medium or low with a clear fix), propose a concrete code change.
@@ -174,6 +252,14 @@ Output: Structured findings list with fields:
 
 Each agent receives REVIEW_DIFF, CHANGED_FILES, and all findings from Pass 1 and Pass 2 as input context.
 
+If PROJECT_CONTEXT is non-empty, also provide it to each agent wrapped in tags:
+
+<project_context>
+{PROJECT_CONTEXT}
+</project_context>
+
+If PROJECT_CONTEXT is empty (no context files found), omit the <project_context> block entirely -- agents receive the same prompt as before this feature was added.
+
 **Agent 3A: Fresh Eyes**
 
 Re-read REVIEW_DIFF without bias from prior findings. Identify anything missed by the previous 6 agents. Focus on:
@@ -181,6 +267,7 @@ Re-read REVIEW_DIFF without bias from prior findings. Identify anything missed b
 - Edge cases in business logic
 - Assumptions that may not hold in production
 - Missing error messages or unhelpful error messages
+- Violations of design principles stated in PROJECT_CONTEXT (if provided) that previous agents may have missed — compare implementation choices against documented principles and architectural decisions
 
 Output: Net-new findings only (deduplicated against all prior findings). Use fields:
 - id: "3A-{N}"
@@ -367,8 +454,8 @@ Take the proposed fixes from Agent 2A.
 4. Stage all successful fixes and commit:
 
 ```bash
-git add [fixed files]
-git commit -m "fix(${PHASE}-${PLAN}): codereview auto-fixes
+git -C "${CODE_REPO_PATH}" add [fixed files]
+git -C "${CODE_REPO_PATH}" commit -m "fix(${PHASE}-${PLAN}): codereview auto-fixes
 
 - [list each fix applied, one per bullet]
 
@@ -409,15 +496,22 @@ No fixes qualified for auto-application (all findings were critical/high severit
 
 Update the frontmatter: set `stats.auto_fixed` to `{FIXES_APPLIED}`.
 
-Include CODEREVIEW.md in the auto-fix commit by adding it to the staged files:
+**Do NOT include CODEREVIEW.md in the auto-fix commit.** CODEREVIEW.md lives in the planning repo under `${PHASE_DIR}`, while the auto-fix commit lives in the code repo. `git -C "${CODE_REPO_PATH}" add ${CODEREVIEW_PATH}` would fail because `${CODEREVIEW_PATH}` is not inside `${CODE_REPO_PATH}`. CODEREVIEW.md will be picked up by the amend-metadata-commit at the bottom of the execute-phase codereview gate (which commits it in the planning repo).
+
+For the auto-fix commit, stage only the code-repo files:
 
-Change the existing `git add [fixed files]` to also include CODEREVIEW.md:
 ```bash
-git add [fixed files] ${CODEREVIEW_PATH}
+git -C "${CODE_REPO_PATH}" add [fixed files]
+git -C "${CODE_REPO_PATH}" commit -m "fix(${PHASE}-${PLAN}): codereview auto-fixes
+
+- [list each fix applied, one per bullet]
+
+Co-Authored-By: Claude Code Review <noreply@anthropic.com>"
 ```
 
 If no auto-fixes were applied (commit skipped), commit CODEREVIEW.md alone:
 ```bash
+# CODEREVIEW.md lives in the planning repo under ${PHASE_DIR}. This commit intentionally runs in the inherited (planning) cwd — do NOT use git -C "${CODE_REPO_PATH}" here.
 git add ${CODEREVIEW_PATH}
 git commit -m "docs(${PHASE}-${PLAN}): codereview report
 

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

@@ -25,8 +25,8 @@ Read these AFTER running the initialize step, not before.
 
 When a milestone completes:
 
-1. Extract full milestone details to `${project_root}/milestones/v[X.Y]-ROADMAP.md`
-2. Archive requirements to `${project_root}/milestones/v[X.Y]-REQUIREMENTS.md`
+1. Extract full milestone details to `milestones/v[X.Y]-ROADMAP.md`
+2. Archive requirements to `milestones/v[X.Y]-REQUIREMENTS.md`
 3. Update ROADMAP.md — replace milestone details with one-line summary
 4. Delete REQUIREMENTS.md (fresh one for next milestone)
 5. Perform full PROJECT.md evolution review
@@ -50,7 +50,7 @@ Load project context and resolve paths:
 INIT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" init milestone-op)
 ```
 
-Parse JSON for: `commit_docs`, `state_path`, `roadmap_path`, `project_path`, `requirements_path`, `phases_dir`, `archive_dir`, `project_root`, `phase_count`, `completed_phases`, `all_phases_complete`.
+Parse JSON for: `commit_docs`, `state_path`, `roadmap_path`, `project_path`, `requirements_path`, `phases_dir`, `archive_dir`, `project_root`, `phase_count`, `completed_phases`, `all_phases_complete`, `milestone_slug`, `milestone_version`, `milestone_name`.
 
 **Load verification tier context:**
 
@@ -65,6 +65,22 @@ Detect `JOB_MODE`:
 - Check if `<job-mode>silent</job-mode>` is present in the invoking context
 - Store as `JOB_MODE = true/false`
 
+**Manual-only enforcement (CMP-01):**
+
+If `JOB_MODE` is true OR `--auto` flag is present OR `--non-interactive` flag is present:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+complete-milestone cannot run in automated/job mode.
+Milestone completion requires manual oversight for conflict resolution.
+
+**To fix:** Run `/dgs:complete-milestone` interactively.
+```
+**STOP.** Do not proceed. Exit the workflow.
+
 </step>
 
 <step name="verify_readiness">
@@ -124,6 +140,24 @@ MUST present 3 options:
 
 If user selects "Proceed anyway": note incomplete requirements in MILESTONES.md under `### Known Gaps` with REQ-IDs and descriptions.
 
+**REVIEW.md existence check:**
+
+```bash
+REVIEW_PATH="${project_root}/../milestones/${milestone_version}-REVIEW.md"
+if [ ! -f "$REVIEW_PATH" ]; then
+  # Also check archive directory
+  REVIEW_PATH="${archive_dir}/${milestone_version}-REVIEW.md"
+fi
+```
+
+If REVIEW.md does not exist at either path:
+
+```
+Warning: REVIEW.md not found — run `dgs-tools jobs generate-review` before sharing with reviewers
+```
+
+This is a warning only — REVIEW.md absence does NOT block milestone completion. The report is supplementary context for four-eyes reviewers and can be generated after completion if needed.
+
 <config-check>
 
 ```bash
@@ -169,6 +203,177 @@ Wait for confirmation.
 
 </step>
 
+<step name="rebase_and_merge_code_repos">
+
+**Skip if:** No REPOS.md exists or no code repos registered. Log: `No code repos — skipping rebase and merge.`
+
+**Check for active worktree:**
+
+```bash
+WORKTREE_LIST=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" worktrees list 2>/dev/null)
+```
+
+Parse JSON. Find entry matching `milestone_slug`. If no worktree found:
+
+<!-- LEGACY: One-time migration path for users upgrading mid-milestone.
+     This code path handles milestones started with the old branching model.
+     Can be removed in a future version once all users have upgraded. -->
+
+**Legacy branch detection (mid-milestone upgrade):**
+
+Before skipping code repo merge, check if a milestone branch exists in the main checkout without a worktree entry. This handles users who upgraded to the worktree model mid-milestone.
+
+```bash
+# Check for legacy milestone branches in each registered code repo
+REPO_NAMES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" repos list --names-only 2>/dev/null)
+for REPO in $REPO_NAMES; do
+  REPO_PATH=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" repos resolve-path "$REPO" 2>/dev/null)
+  LEGACY_BRANCH=$(git -C "$REPO_PATH" branch --list "dgs/*${MILESTONE_SLUG}*" "milestone/${MILESTONE_SLUG}" "*-${MILESTONE_SLUG}" 2>/dev/null | head -1 | tr -d '* ')
+done
+```
+
+**If legacy branch found in any repo:**
+
+Display: `Legacy milestone detected — merging without worktree.`
+
+For each repo with a legacy branch:
+1. Ensure on base branch: `git -C "$REPO_PATH" checkout ${BASE_BRANCH}`
+2. Pull latest: `git -C "$REPO_PATH" pull --ff-only origin ${BASE_BRANCH}`
+3. Rebase milestone branch: `git -C "$REPO_PATH" rebase ${BASE_BRANCH} ${LEGACY_BRANCH}`
+   - If conflicts: abort rebase and show manual instructions (same pattern as worktree flow)
+4. Fast-forward merge: `git -C "$REPO_PATH" merge --ff-only ${LEGACY_BRANCH}`
+5. Delete legacy branch: `git -C "$REPO_PATH" branch -d ${LEGACY_BRANCH}`
+6. Push: `git -C "$REPO_PATH" push origin ${BASE_BRANCH}`
+7. Skip worktree cleanup (no worktree exists)
+
+Continue to gather_stats (skip the worktree-based merge flow below).
+
+**If no legacy branch found either:**
+
+```
+No milestone worktree or legacy branch found for '${MILESTONE_SLUG}'.
+No code repo merge needed — continuing with planning repo completion.
+```
+Skip to gather_stats.
+
+**If worktree found:**
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DGS ► MERGING CODE REPOS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**For each code repo in REPOS.md (sequentially):**
+
+```bash
+REPO_NAMES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" repos list --names-only 2>/dev/null)
+```
+
+For each repo name:
+
+1. **Check if repo is in the worktree state.** If not, skip (repo may not have been part of this milestone).
+
+2. **Check if already merged.** The milestone branch may have already been merged for this repo in a prior run. Check if the branch still exists:
+```bash
+BRANCH_EXISTS=$(git -C "${MAIN_CHECKOUT}" branch --list "milestone/${MILESTONE_SLUG}" 2>/dev/null)
+```
+If branch does not exist, log `${REPO_NAME}: Already merged (branch deleted). Skipping.` and continue to next repo.
+
+3. **Run rebaseAndMerge:**
+```bash
+MERGE_RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" worktrees rebase-and-merge "${MILESTONE_SLUG}" --repo "${REPO_NAME}")
+```
+
+4. **Handle rebaseAndMerge result:**
+
+**If `success: true`:**
+```
+✓ ${REPO_NAME}: Rebased and merged to ${BASE_BRANCH}
+```
+Continue to next repo.
+
+**If `conflicted: true`:**
+Display the `manualInstructions` from the result:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  CHECKPOINT: Action Required                                  ║
+╚══════════════════════════════════════════════════════════════╝
+
+Rebase conflict in ${REPO_NAME}. Automatic resolution failed.
+
+${MANUAL_INSTRUCTIONS}
+
+──────────────────────────────────────────────────────────────
+→ After resolving conflicts, re-run: /dgs:complete-milestone
+──────────────────────────────────────────────────────────────
+```
+**STOP.** Do not proceed to the next repo or to archival. The user must resolve conflicts manually and re-run.
+
+**If `success: false` (non-conflict error):**
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+Merge failed for ${REPO_NAME}: ${ERROR}
+
+**To fix:** Check the worktree state and re-run /dgs:complete-milestone
+```
+**STOP.**
+
+**After all repos merged successfully:**
+
+5. **Clean up worktree:**
+```bash
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" worktrees remove "${MILESTONE_SLUG}"
+```
+
+This removes:
+- All worktree directories for this milestone
+- Git worktree registrations
+- Milestone branches
+- active_context cleared to null
+
+```
+✓ Worktree cleanup complete for milestone '${MILESTONE_SLUG}'
+✓ Active context cleared
+```
+
+6. **Continue to mark_planning_repo_complete.**
+
+</step>
+
+<step name="mark_planning_repo_complete">
+
+**Guard:** This step only runs after ALL code repos have successfully merged in the rebase_and_merge_code_repos step. The sequential stop-on-failure behavior ensures that if any repo fails, the workflow stops before reaching this step.
+
+Mark the planning repo's STATE.md as milestone-complete, commit, and push:
+
+```
+Marking milestone complete in planning repo...
+```
+
+```bash
+MARK_RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" state mark-milestone-complete --raw 2>&1)
+```
+
+Parse the result. If successful:
+
+```bash
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs(state): mark milestone ${MILESTONE_NAME} complete" --push --files "${STATE_PATH}"
+```
+
+```
+✓ Planning repo marked complete and pushed.
+```
+
+If mark-milestone-complete fails, log a warning but continue to gather_stats (non-critical for the merge flow).
+
+</step>
+
 <step name="gather_stats">
 
 Calculate milestone statistics:
@@ -416,41 +621,30 @@ Update `${roadmap_path}` — group completed milestone phases:
 **Delegate archival to dgs-tools:**
 
 ```bash
-ARCHIVE=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" milestone complete "v[X.Y]" --name "[Milestone Name]")
+ARCHIVE=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" milestone complete "v[X.Y]" --name "[Milestone Name]" --archive-phases)
 ```
 
 The CLI handles:
-- Creating `${project_root}/milestones/` directory
+- Creating `milestones/` directory (planning root)
 - Archiving ROADMAP.md to `milestones/v[X.Y]-ROADMAP.md`
 - Archiving REQUIREMENTS.md to `milestones/v[X.Y]-REQUIREMENTS.md` with archive header
 - Moving audit file to milestones if it exists
 - Creating/appending MILESTONES.md entry with accomplishments from SUMMARY.md files
 - Updating STATE.md (status, last activity)
+- Moving milestone phase directories to `milestones/v[X.Y]-phases/` (planning root)
+- Moving completed quick task directories to `milestones/v[X.Y]-quick/` (those with SUMMARY.md)
 
 Extract from result: `version`, `date`, `phases`, `plans`, `tasks`, `accomplishments`, `archived`.
 
-Verify: `✅ Milestone archived to ${project_root}/milestones/`
+Verify: `✅ Milestone archived to milestones/`
 
-**If `JOB_MODE` is true:**
-- Log: `[AUTO-RESOLVE] Skipping phase archival in job mode`
-- Keep phases in place (select "Skip" path automatically)
-- Skip the AskUserQuestion below
-
-**If `JOB_MODE` is false (default):**
+Verify `archived.phases` is `true` in the result. If false, error: "Phase archival failed — check ${phases_dir} and milestones/ directory."
 
-**Phase archival (optional):** After archival completes, ask the user:
+Verify: `✅ Phase directories archived to milestones/v[X.Y]-phases/`
 
-AskUserQuestion(header="Archive Phases", question="Archive phase directories to milestones/?", options: "Yes — move to milestones/v[X.Y]-phases/" | "Skip — keep phases in place")
-
-If "Yes": move phase directories to the milestone archive:
-```bash
-mkdir -p ${project_root}/milestones/v[X.Y]-phases
-# For each phase directory in ${phases_dir}/:
-mv ${phases_dir}/{phase-dir} ${project_root}/milestones/v[X.Y]-phases/
-```
-Verify: `✅ Phase directories archived to ${project_root}/milestones/v[X.Y]-phases/`
+Verify `archived.quick` is `true` in the result if completed quick tasks existed. If false but quick dirs were expected, warn: "Quick archival returned false -- check projects/{project}/quick/ directory."
 
-If "Skip": Phase directories remain in `${phases_dir}/` as raw execution history. Use `/dgs:cleanup` later to archive retroactively.
+Verify: `completed quick directories archived to milestones/v[X.Y]-quick/`
 
 After archival, the AI still handles:
 - Reorganizing ROADMAP.md with milestone grouping (requires judgment)
@@ -1211,7 +1405,7 @@ git push origin v[X.Y]
 Commit milestone completion.
 
 ```bash
-node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "chore: complete v[X.Y] milestone" --push --files ${project_root}/milestones/v[X.Y]-ROADMAP.md ${project_root}/milestones/v[X.Y]-REQUIREMENTS.md ${project_root}/v[X.Y]-MILESTONE-AUDIT.md ${project_root}/MILESTONES.md ${project_path} ${state_path}
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "chore: complete v[X.Y] milestone" --push --files milestones/v[X.Y]-ROADMAP.md milestones/v[X.Y]-REQUIREMENTS.md milestones/v[X.Y]-MILESTONE-AUDIT.md MILESTONES.md ${project_path} ${state_path}
 ```
 ```
 

package/deliver-great-systems/workflows/complete-quick.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 complete-quick**
+
+Call the complete-quick CLI command which validates the active quick and executes the full flow:
+
+```bash
+RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" complete-quick 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:complete-quick
+```
+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>

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

@@ -307,7 +307,7 @@ Write multi-line parameters (body, discussion, research) to temporary files usin
 {
   "id": 5,
   "filename": "005-improve-api-resilience.md",
-  "path": "ideas/pending/005-improve-api-resilience.md",
+  "path": "ideas/005-improve-api-resilience.md",
   "title": "Improve API resilience",
   "consolidated_from": ["001", "003", "017"],
   "moved_files": [

package/deliver-great-systems/workflows/create-milestone-job.md

@@ -24,7 +24,7 @@ Use `TIER_FILES` JSON `files` array for project context (PROJECT.md, STATE.md, c
 Parse `$ARGUMENTS` to extract version and flags.
 
 - **Version:** First non-flag argument (e.g., `v6`, `v6.0`). If omitted, auto-detection happens in the preview step.
-- **--no-check flag:** If present, omit audit-milestone and complete-milestone steps from the generated job.
+- **--no-check flag:** If present, omit the audit-milestone step from the generated job.
 
 ```bash
 # Pseudocode for argument parsing:
@@ -97,7 +97,7 @@ Present in this format:
 5. execute-phase 52
 6. verify-work 52
 ...
-N. complete-milestone v6.0
+N. audit-milestone v6.0
 
 Create this job? (yes/no)
 ```
@@ -123,13 +123,13 @@ node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs jobs create-milestone VER
 2. Commit the job file:
 
 ```bash
-node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "docs(50): create milestone job {version}" --files jobs/pending/milestone-{version}.md
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "docs(50): create milestone job {version}" --files jobs/milestone-{version}.md
 ```
 
 3. Display success and next steps:
 
 ```
-Job created: jobs/pending/milestone-{version}.md
+Job created: jobs/milestone-{version}.md
 
 ---