@ktpartners/dgs-platform 2.9.0 → 3.0.4

package/deliver-great-systems/templates/claude-md.md

@@ -46,12 +46,28 @@ When the request involves creating, modifying, or deleting code or configuration
 - Route through `/dgs:debug`
 - Example: "The tests started failing after yesterday's merge"
 
+**Is there an active milestone?** Check if the work relates to the milestone scope.
+- **Yes, related to milestone:** Route through `/dgs:quick` (milestone-context -- works in milestone worktree, no separate lifecycle)
+- **Yes, but unrelated to milestone:** Route through `/dgs:quick --main` (product-level -- creates separate worktree off main)
+- **No active milestone:** Route through `/dgs:quick` (product-level -- creates ephemeral worktree)
+
+**Is it a trivial 1-line fix?** Route through `/dgs:fast` (always direct to main, zero overhead)
+
 **When ambiguous, default to the smaller command.** Prefer `/dgs:fast` or `/dgs:quick` over `/dgs:execute-phase`.
 
 Before invoking, mention briefly: "Small fix, routing through `/dgs:fast`." -- command name and short reason.
 
 These routing rules apply whether the change is user-initiated or discovered by Claude during other work.
 
+**Quick task lifecycle:**
+- `/dgs:complete-quick` -- Merge quick work to main (rebase + merge + cleanup)
+- `/dgs:abandon-quick` -- Discard quick work without merging
+- These apply to product-level quicks only. Milestone-context quicks merge with the milestone.
+
+**Quick outgrew its scope?** Do NOT try to promote a quick to a milestone. Complete it (`/dgs:complete-quick`) or abandon it (`/dgs:abandon-quick`), then start a proper milestone for the larger work.
+
+**Need a product-level quick during milestone work?** Use `/dgs:quick --main "title"` to force a product-level quick that works off main, independent of the active milestone.
+
 ## 4. Override Requested? Acknowledge and Proceed
 
 The user can bypass DGS routing by including one of these phrases in their request:

package/deliver-great-systems/workflows/abandon-quick.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" abandon-quick --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/add-idea.md

@@ -33,7 +33,7 @@ Use `TIER_FILES` JSON `files` array for project context (PROJECT.md, STATE.md, c
 
 <step name="ensure_directories">
 ```bash
-mkdir -p ${project_root}/ideas/pending ${project_root}/ideas/done ${project_root}/ideas/rejected
+mkdir -p ${project_root}/ideas
 ```
 </step>
 
@@ -72,7 +72,7 @@ Parse the JSON result to get `id`, `filename`, `path`.
 
 <step name="git_commit">
 ```bash
-node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "ideas: add #${id} - ${title}" --push --files ${project_root}/ideas/pending/${filename} ${project_root}/ideas/manifest.json
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "ideas: add #${id} - ${title}" --push --files ${project_root}/ideas/${filename} ${project_root}/ideas/manifest.json
 ```
 </step>
 
@@ -89,7 +89,7 @@ Nothing else -- no file path, no tags display, no next steps.
 </process>
 
 <success_criteria>
-- [ ] Idea file exists in `ideas/pending/` with correct frontmatter
+- [ ] Idea file exists in `ideas/` with correct frontmatter
 - [ ] Manifest updated with incremented next_id
 - [ ] Git commit created
 - [ ] Minimal confirmation displayed

package/deliver-great-systems/workflows/add-tests.md

@@ -66,6 +66,20 @@ This command works on completed phases. Run /dgs:execute-phase first.
 ```
 Exit.
 
+**Worktree-aware code directory resolution (resolveCodeContext):**
+
+For each registered code repo, resolve the correct working directory. When a milestone or quick worktree is active, test generation must target the worktree directory, not the main checkout, so generated test files land in the correct location.
+
+```javascript
+// In the agent's execution context, use resolveCodeContext to determine the code directory:
+const { resolveCodeContext } = require('./bin/lib/context.cjs');
+const ctx = resolveCodeContext(planningRoot, repoName);
+// ctx.type: 'main' | 'milestone' | 'quick'
+// ctx.directory: absolute path to the correct working directory
+```
+
+Use `ctx.directory` for all file operations within code repos.
+
 Present banner:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

package/deliver-great-systems/workflows/add-todo.md

@@ -95,6 +95,7 @@ Write to `${pending_dir}/${date}-${slug}.md`:
 
 ```markdown
 ---
+status: pending
 created: [timestamp]
 title: [title]
 area: [area]

package/deliver-great-systems/workflows/approve-spec.md

@@ -143,16 +143,36 @@ Perform the approval state transition and audit trail update.
    node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs specs set-status --id "$SPEC_SLUG" --status final
    ```
 
-2. Run `add-log-entry` to record the approval in the Refinement Log:
+2. Mark source ideas as done (if any):
+   Read the spec file to extract `source_ideas` from frontmatter (array of idea filenames).
+   If `source_ideas` exists and is non-empty:
+   ```bash
+   # For each source idea in the array:
+   for IDEA_FILE in ${SOURCE_IDEAS[@]}; do
+     node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs ideas set-status --id "$IDEA_FILE" --status done 2>/dev/null || true
+   done
+   ```
+   The `|| true` ensures silent skip if an idea is already done, consolidated, or not found (idempotent).
+   Track the idea file paths for inclusion in the commit.
+
+3. Run `add-log-entry` to record the approval in the Refinement Log:
    ```bash
    node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs specs add-log-entry --id "$SPEC_SLUG" --date "$(date +%Y-%m-%d)" --version "$VERSION" --action Approved --summary "Spec approved after completeness validation"
    ```
 
-3. Determine the spec filename from the validate output or Read step.
+4. Determine the spec filename from the validate output or Read step.
 
-4. Commit the changes:
+5. Commit the changes (include modified idea files):
    ```bash
-   node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "specs: approve $SPEC_ID v$VERSION" --push --files "$SPEC_FILE_PATH"
+   # Build files list: spec + any modified idea files
+   COMMIT_FILES="$SPEC_FILE_PATH"
+   if [ -n "$SOURCE_IDEAS" ]; then
+     for IDEA_FILE in ${SOURCE_IDEAS[@]}; do
+       IDEA_PATH=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs ideas find --id "$IDEA_FILE" --raw 2>/dev/null | jq -r '.path // empty')
+       [ -n "$IDEA_PATH" ] && COMMIT_FILES="$COMMIT_FILES ${project_root}/${IDEA_PATH}"
+     done
+   fi
+   node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "specs: approve $SPEC_ID v$VERSION" --push --files $COMMIT_FILES
    ```
 </step>
 
@@ -180,5 +200,6 @@ Next steps:
 - [ ] Validation errors block approval with clear messages
 - [ ] Validation warnings allow user confirmation before proceeding
 - [ ] Blocking open questions are detected and treated as errors
+- [ ] Source ideas marked as done when spec has source_ideas in frontmatter
 - [ ] Changes committed to git
 </success_criteria>

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

@@ -51,15 +51,25 @@ REPOS_MD=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs repos list --r
 
 Parse JSON for the list of registered repos with paths.
 
-**Resolve test execution directory (v2 only):**
+**Resolve test execution directory with resolveCodeContext (v2 only):**
 
 If `dgs_mode` is `v2` and repos were detected from REPOS_MD:
 
 1. Parse REPOS_MD JSON for the list of repos (each has `name` and `path`)
-2. If exactly 1 repo registered: use its `path` as `TEST_CWD`
-3. If multiple repos: check PLAN.md files in the phase for `<repos>` tags. Use the first repo name found, look up its path from REPOS_MD. If no `<repos>` tag found, use the first registered repo's path.
-4. Resolve `TEST_CWD` to an absolute path: if the repo path is relative (starts with `../`), resolve it relative to `process.cwd()` / the current working directory.
-5. Set `CWD_FLAG` to `--cwd "${TEST_CWD}"` if TEST_CWD was determined, otherwise set to empty string.
+2. Determine the target repo name:
+   - If exactly 1 repo registered: use its name
+   - If multiple repos: check PLAN.md files in the phase for `<repos>` tags. Use the first repo name found. If no `<repos>` tag found, use the first registered repo's name.
+3. **Resolve code context (worktree-aware):** Use resolveCodeContext to determine the correct working directory. When a milestone or quick worktree is active, the audit must examine code in the worktree directory, not the main checkout.
+   ```javascript
+   const { resolveCodeContext } = require('./bin/lib/context.cjs');
+   const ctx = resolveCodeContext(planningRoot, repoName);
+   // ctx.type: 'main' | 'milestone' | 'quick'
+   // ctx.directory: absolute path to the correct working directory
+   ```
+   Use `ctx.directory` as `TEST_CWD`.
+4. If resolveCodeContext returns main type, fall back to resolving the repo path from REPOS_MD as before.
+5. Resolve `TEST_CWD` to an absolute path: if the repo path is relative (starts with `../`), resolve it relative to `process.cwd()` / the current working directory.
+6. Set `CWD_FLAG` to `--cwd "${TEST_CWD}"` if TEST_CWD was determined, otherwise set to empty string.
 
 If `dgs_mode` is NOT `v2` or no repos detected: set `CWD_FLAG` to empty string (single-repo, no override needed).
 

package/deliver-great-systems/workflows/cancel-job.md

@@ -46,7 +46,7 @@ Parse the JSON result. The response contains:
   "cancelled": true,
   "version": "v6.0",
   "steps_reset": 2,
-  "path": "jobs/pending/milestone-v6.0.md"
+  "path": "jobs/milestone-v6.0.md"
 }
 ```
 

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

@@ -130,7 +130,7 @@ Use AskUserQuestion:
 <step name="execute_action">
 **Work on it now:**
 ```bash
-mv "${pending_dir}/[filename]" "${project_root}/todos/done/"
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" todos set-status --id "[filename]" --status done
 ```
 Update STATE.md todo count. Present problem/solution context. Begin work or ask how to proceed.
 
@@ -158,8 +158,7 @@ Re-run `init todos` to get updated count, then update STATE.md "### Pending Todo
 If todo was moved to done/, commit the change:
 
 ```bash
-git rm --cached ${pending_dir}/[filename] 2>/dev/null || true
-node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs: start work on todo - [title]" --files ${project_root}/todos/done/[filename] ${state_path}
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs: start work on todo - [title]" --files ${project_root}/todos/[filename] ${state_path}
 ```
 
 Tool respects `commit_docs` config and gitignore automatically.

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">
@@ -169,6 +185,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:
@@ -420,7 +607,7 @@ ARCHIVE=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" milestone
 ```
 
 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
@@ -429,28 +616,16 @@ The CLI handles:
 
 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):**
+**Phase archival (mandatory):** After milestone archival completes, archive phase directories. Phase directories are fully committed to git history, so they are always recoverable.
 
-**Phase archival (optional):** After archival completes, ask the user:
-
-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
+mkdir -p milestones/v[X.Y]-phases
 # For each phase directory in ${phases_dir}/:
-mv ${phases_dir}/{phase-dir} ${project_root}/milestones/v[X.Y]-phases/
+mv ${phases_dir}/{phase-dir} milestones/v[X.Y]-phases/
 ```
-Verify: `✅ Phase directories archived to ${project_root}/milestones/v[X.Y]-phases/`
-
-If "Skip": Phase directories remain in `${phases_dir}/` as raw execution history. Use `/dgs:cleanup` later to archive retroactively.
+Verify: `✅ Phase directories archived to milestones/v[X.Y]-phases/`
 
 After archival, the AI still handles:
 - Reorganizing ROADMAP.md with milestone grouping (requires judgment)
@@ -1211,7 +1386,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,68 @@
+<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: 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 2: 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>
+- [ ] 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": [