@ktpartners/dgs-platform 2.8.0 → 3.0.4

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,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 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 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/quick.md

@@ -26,6 +26,8 @@ Parse `$ARGUMENTS` for:
 - `--dry-run` flag → store as `$DRY_RUN` (true/false)
 - `--full` flag → store as `$FULL_MODE` (true/false)
 - `--discuss` flag → store as `$DISCUSS_MODE` (true/false)
+- `--main` flag → store as `$FORCE_MAIN` (true/false)
+- `--debug` flag → store as `$DEBUG_MODE` (true/false)
 - Remaining text (after stripping all flags) → use as `$DESCRIPTION` if non-empty
 
 If `$DESCRIPTION` is empty after parsing, prompt user interactively:
@@ -82,6 +84,108 @@ If `$FULL_MODE` only:
 
 ---
 
+**Step 1.5: Detect quick mode and handle worktree lifecycle**
+
+This step runs for BOTH fast and non-fast paths. For `$FAST_MODE`, it performs mode detection ONLY (no worktree creation) so the fast path can route commits correctly based on the active context.
+
+Determine the effective mode flag:
+- If `$DEBUG_MODE`: set `$QUICK_MODE_FLAG = 'debug'`
+- If `$FULL_MODE`: set `$QUICK_MODE_FLAG = 'full'`
+- Otherwise: set `$QUICK_MODE_FLAG = null`
+
+Detect whether this is a product-level or milestone-context quick:
+
+```bash
+QUICK_DETECT=$(node -e "
+  const q = require('$HOME/.claude/deliver-great-systems/bin/lib/quick.cjs');
+  const r = q.detectQuickMode(process.cwd(), ${FORCE_MAIN:-false});
+  process.stdout.write(JSON.stringify(r));
+")
+```
+
+Parse `QUICK_DETECT` for `mode` field.
+
+**If mode is 'product':**
+
+**If NOT `$FAST_MODE`:**
+
+Check the one-active-quick guard and create worktree:
+
+```bash
+QUICK_START=$(node -e "
+  const q = require('$HOME/.claude/deliver-great-systems/bin/lib/quick.cjs');
+  const r = q.startProductQuick(process.cwd(), '${DESCRIPTION}', ${QUICK_MODE_FLAG ? \"'\" + QUICK_MODE_FLAG + \"'\" : 'null'});
+  process.stdout.write(JSON.stringify(r));
+")
+```
+
+Parse `QUICK_START` result.
+
+If `success` is false (guard triggered or creation failed):
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+${error message from QUICK_START}
+```
+End workflow.
+
+If `success` is true:
+Set `$QUICK_CONTEXT = 'product'`
+Set `$QUICK_SLUG` from result `slug`
+Set `$QUICK_REPOS` from result `repos` (object mapping repoName -> worktreePath, may be empty `{}`)
+Display: `Product-level quick created: ${QUICK_SLUG}`
+
+**If `$FAST_MODE`:**
+
+Skip worktree creation entirely. Fast in product mode commits directly to `base_branch` in the main checkout.
+
+Set `$QUICK_CONTEXT = 'product'`
+Set `$QUICK_REPO_CWD = null` (unset — git ops run in planning-root cwd)
+Display: `Fast: product-level (no milestone) — committing to base_branch in main checkout.`
+
+**If mode is 'milestone-context':**
+
+Set `$QUICK_CONTEXT = 'milestone-context'`
+Set `$MILESTONE_SLUG` from `activeMilestone` in detect result
+
+**If `$FAST_MODE`:** Resolve the milestone worktree directory for the active repo so fast commits land on the milestone branch:
+
+```bash
+QUICK_REPO_CWD=$(node -e "
+  const fs = require('fs');
+  const path = require('path');
+  const localPath = path.join(process.cwd(), 'config.local.json');
+  const local = JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+  const { loadConfig } = require('$HOME/.claude/deliver-great-systems/bin/lib/core.cjs');
+  const cfg = loadConfig(process.cwd());
+  const proj = cfg.current_project;
+  const wt = (local.projects && local.projects[proj] && local.projects[proj].worktrees && local.projects[proj].worktrees['${MILESTONE_SLUG}']) || {};
+  const repos = Object.entries(wt.repos || {});
+  if (repos.length === 0) process.exit(1);
+  // Multi-repo: prefer the worktree with pending edits. Single-repo: the
+  // only entry. Fall back to the first entry if no diffs are detected.
+  const { execSync } = require('child_process');
+  let pick = repos[0][1];
+  for (const [name, dir] of repos) {
+    try {
+      const diff = execSync('git -C \"' + dir + '\" diff --stat', { encoding: 'utf-8' }).trim();
+      if (diff.length > 0) { pick = dir; break; }
+    } catch {}
+  }
+  process.stdout.write(pick);
+")
+```
+
+Display: `Fast: milestone-context (${MILESTONE_SLUG}) — committing to milestone branch in worktree ${QUICK_REPO_CWD}.`
+
+**If NOT `$FAST_MODE`:** Leave `$QUICK_REPO_CWD` unset. Display: `Working in milestone context (${MILESTONE_SLUG}). Changes will be part of the milestone.`
+
+No worktree creation. No guard check. Continue to Step 2.
+
+---
+
 **Step 2: Initialize**
 
 ```bash
@@ -140,10 +244,12 @@ Then continue from Step 3 as normal quick mode (skip the rest of the fast path).
 
 Read the relevant file(s) based on `$DESCRIPTION`, make the requested changes directly using Read/Edit/Write tools. No planner, no executor — the orchestrator acts as the implementer.
 
+If `$QUICK_CONTEXT` is `'milestone-context'`, relevant files live under `$QUICK_REPO_CWD` (the milestone worktree). Prefix Read/Edit/Write absolute paths with that directory — the main-checkout paths will be on `base_branch` and miss in-progress milestone work.
+
 If `$DRY_RUN`:
   After making edits but BEFORE committing, show the diff:
   ```bash
-  git diff
+  git -C "${QUICK_REPO_CWD:-.}" diff
   ```
   Then ask:
   ```
@@ -158,7 +264,7 @@ If `$DRY_RUN`:
   ```
   If user chooses "No, discard":
     ```bash
-    git checkout -- .
+    git -C "${QUICK_REPO_CWD:-.}" checkout -- .
     ```
     Display: "Changes discarded."
     Skip to completion output with message: "Dry run complete — no changes applied."
@@ -166,9 +272,9 @@ If `$DRY_RUN`:
 
 **F3. Post-edit scope check**
 
-After edits are made, check actual scope:
+After edits are made, check actual scope (run in the worktree when milestone-context):
 ```bash
-git diff --stat
+git -C "${QUICK_REPO_CWD:-.}" diff --stat
 ```
 
 Parse the output to count:
@@ -207,13 +313,19 @@ Commit message is NOT shown to user before committing — just commit silently.
 
 **F5. Commit**
 
+When `$QUICK_REPO_CWD` is set (milestone-context), route git operations through the worktree via `--repo-cwd`. Config (commit_docs, sync_push, current_project, worktree map) is still loaded from the planning-root cwd.
+
 ```bash
-node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "${commit_message}" --push
+if [ -n "$QUICK_REPO_CWD" ]; then
+  node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "${commit_message}" --push --repo-cwd "$QUICK_REPO_CWD"
+else
+  node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "${commit_message}" --push
+fi
 ```
 
-Get the short hash:
+Get the short hash (from the same directory the commit landed in):
 ```bash
-git rev-parse --short HEAD
+git -C "${QUICK_REPO_CWD:-.}" rev-parse --short HEAD
 ```
 
 Store as `$COMMIT_HASH`.
@@ -260,17 +372,26 @@ If archival occurred (result contains `"archived": true`), `quick/HISTORY.md` wa
 
 **F6c. Commit tracking (fast path only)**
 
-Commit STATE.md and HISTORY.md together so archival data is persisted:
+Commit STATE.md and HISTORY.md together so archival data is persisted. Uses `dgs-tools quick finalize --fast` — a single CLI call that stages both files (HISTORY.md optional) and commits with message `docs(quick-${quick_id}): track fast task`.
 
 ```bash
-FILE_LIST="${state_path}"
-if [ -f "${project_root}/quick/HISTORY.md" ]; then
-  FILE_LIST="${FILE_LIST} ${project_root}/quick/HISTORY.md"
+if [ -n "$QUICK_REPO_CWD" ]; then
+  node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" quick finalize ${quick_id} \
+    --quick-dir "${project_root}/quick" \
+    --state-path "${state_path}" \
+    --fast \
+    --push \
+    --repo-cwd "$QUICK_REPO_CWD" 2>/dev/null || true
+else
+  node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" quick finalize ${quick_id} \
+    --quick-dir "${project_root}/quick" \
+    --state-path "${state_path}" \
+    --fast \
+    --push 2>/dev/null || true
 fi
-node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs(quick-${quick_id}): track fast task" --push --files ${FILE_LIST} 2>/dev/null || true
 ```
 
-The `|| true` handles the case where nothing changed (e.g., STATE.md wasn't modified).
+The `|| true` handles the case where nothing changed (e.g., STATE.md wasn't modified) — `quick finalize` returns `commit_reason: 'nothing_to_commit'` cleanly in that scenario.
 
 **F7. Output**
 
@@ -616,6 +737,12 @@ Task(
   prompt="
 Execute quick task ${quick_id}.
 
+${QUICK_CONTEXT === 'product' && QUICK_REPOS && Object.keys(QUICK_REPOS).length > 0 ? `
+<worktree_context>
+This quick task is executing in a git worktree. Work in these directories — do NOT use the main checkout paths:
+${Object.entries(QUICK_REPOS).map(([name, dir]) => '- ' + name + ': ' + dir).join('\n')}
+</worktree_context>
+` : ''}
 <files_to_read>
 - ${QUICK_DIR}/${quick_id}-PLAN.md (Plan)
 - ${state_path} (Project state)
@@ -751,6 +878,10 @@ node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" state archive-quick
 
 If archival occurred, `quick/HISTORY.md` was created or updated. Include it in Step 8's commit file list.
 
+**7c3. Milestone-context quick tracking**
+
+If `$QUICK_CONTEXT` is 'milestone-context', note this in the Directory column of the table row. Instead of a directory link, use: `milestone (${MILESTONE_SLUG})`.
+
 **7d. Update "Last activity" line:**
 
 Use `date` from init:
@@ -764,20 +895,18 @@ Use Edit tool to make these changes atomically
 
 **Step 8: Final commit and completion**
 
-Stage and commit quick task artifacts:
-
-Build file list:
-- `${QUICK_DIR}/${quick_id}-PLAN.md`
-- `${QUICK_DIR}/${quick_id}-SUMMARY.md`
-- `${state_path}`
-- `${project_root}/quick/HISTORY.md` (if it exists — may have been created by archival)
-- If `$DISCUSS_MODE` and context file exists: `${QUICK_DIR}/${quick_id}-CONTEXT.md`
-- If `$FULL_MODE` and verification file exists: `${QUICK_DIR}/${quick_id}-VERIFICATION.md`
+Commit all quick task artifacts atomically via `dgs-tools quick finalize`. This single CLI call stages and commits PLAN, SUMMARY, STATE, and any optional artifacts present on disk (CONTEXT, VERIFICATION, HISTORY) in one commit — no file-list assembly needed.
 
 ```bash
-node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs(quick-${quick_id}): ${DESCRIPTION}" --push --files ${file_list}
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" quick finalize ${quick_id} \
+  --quick-dir "${project_root}/quick" \
+  --state-path "${state_path}" \
+  --description "${DESCRIPTION}" \
+  --push
 ```
 
+Missing optional artifacts are skipped gracefully (no error if CONTEXT.md, VERIFICATION.md, or HISTORY.md do not exist).
+
 Get final commit hash:
 ```bash
 commit_hash=$(git rev-parse --short HEAD)

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

@@ -125,7 +125,7 @@ Context is used to inform the conversation -- for example, when discussing imple
 
 3. Load source idea docs:
    Read the spec's frontmatter to find `source_ideas` (array of idea filenames). For each source idea:
-   a. Derive the idea docs path (same pattern as write-spec: strip prefix/suffix for slug, check `${project_root}/ideas/pending/{slug}/docs/` or done/rejected paths)
+   a. Derive the idea docs path: strip prefix/suffix for slug, check `${project_root}/docs/ideas/{slug}/`
    b. If docs/ directory exists, read all files using the same pattern above
    c. Idea docs are loaded first (source material), then spec docs (refinements). If too many, cap spec docs.
 

package/deliver-great-systems/workflows/research-idea.md

@@ -1,7 +1,7 @@
 <purpose>
 Subagent-driven research workflow that investigates an idea's feasibility and technical landscape across five adaptive dimensions. Claude acts as an analyst -- purposeful and efficient, adapting depth to what the idea actually needs rather than running a checklist.
 
-Produces a structured research document at `${project_root}/docs/ideas/pending/{slug}-research.md` and appends a Research Log entry to the idea file. Commits both files together and suggests the next step based on findings.
+Produces a structured research document at `${project_root}/docs/ideas/{slug}-research.md` and appends a Research Log entry to the idea file. Commits both files together and suggests the next step based on findings.
 
 When re-researching a previously-researched idea, the document is overwritten with a "Changes from Prior Research" section highlighting what shifted. Each re-research appends a fresh Research Log entry.
 </purpose>
@@ -84,7 +84,7 @@ Also check for prior research document:
 ```bash
 # Derive slug from filename (strip id prefix and .md suffix)
 SLUG=$(echo "${filename}" | sed 's/^[0-9]*-//' | sed 's/\.md$//')
-RESEARCH_DOC="${project_root}/docs/ideas/pending/${SLUG}-research.md"
+RESEARCH_DOC="${project_root}/docs/ideas/${SLUG}-research.md"
 ```
 If the research document file exists, read it for prior research context.
 
@@ -98,7 +98,7 @@ IDEA_DOCS_DIR="${IDEA_DIR}/docs"
 
 If a flat structure is used (ideas stored as files, not directories), derive from the filename:
 ```bash
-IDEA_DOCS_DIR="${project_root}/docs/ideas/pending/${SLUG}"
+IDEA_DOCS_DIR="${project_root}/docs/ideas/${SLUG}"
 ```
 
 Check both paths. Use whichever exists.
@@ -213,10 +213,10 @@ Create (or overwrite) the research document.
 
 Ensure directory exists:
 ```bash
-mkdir -p ${project_root}/docs/ideas/pending
+mkdir -p ${project_root}/docs/ideas
 ```
 
-Write the research document to `${project_root}/docs/ideas/pending/${SLUG}-research.md` using the Write tool.
+Write the research document to `${project_root}/docs/ideas/${SLUG}-research.md` using the Write tool.
 
 **Document structure:**
 ```markdown
@@ -280,7 +280,7 @@ Build the entry JSON:
   "summary": "{Actionable summary paragraph -- findings, recommendation, key risks. Enough to act on without opening the full document.}",
   "keyFindings": "- {finding 1}\n- {finding 2}\n- {finding 3}",
   "recommendation": "{Strong recommendation or neutral options presentation}",
-  "documentLink": "${project_root}/docs/ideas/pending/${SLUG}-research.md",
+  "documentLink": "${project_root}/docs/ideas/${SLUG}-research.md",
   "outcome": "{Recommended next step: 'Ready for spec', 'Needs more discussion', 'Not feasible', etc.}"
 }
 ```
@@ -296,7 +296,7 @@ Parse the JSON result to confirm success.
 <step name="git_commit">
 Commit both the research document and the updated idea file:
 ```bash
-node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "docs: research idea #${id} -- ${title}" --files ${project_root}/docs/ideas/pending/${SLUG}-research.md ${project_root}/ideas/${state}/${filename}
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "docs: research idea #${id} -- ${title}" --files ${project_root}/docs/ideas/${SLUG}-research.md ${project_root}/ideas/${filename}
 ```
 </step>
 
@@ -318,7 +318,7 @@ Suggest next step based on outcome:
 <success_criteria>
 - [ ] Idea loaded with full context (body, tags, notes, discussion log, research log)
 - [ ] Research dimensions executed with progress announcements
-- [ ] Research document created at `${project_root}/docs/ideas/pending/{slug}-research.md` with frontmatter
+- [ ] Research document created at `${project_root}/docs/ideas/{slug}-research.md` with frontmatter
 - [ ] Research Log entry saved to idea file via research-save CLI
 - [ ] Both files committed together
 - [ ] Key finding + recommendation + next step displayed

package/deliver-great-systems/workflows/resume-project.md

@@ -247,7 +247,7 @@ Based on user selection, route to appropriate workflow:
   ---
   ```
 - **Transition** → ./transition.md
-- **Check todos** → Read ${project_root}/todos/pending/, present summary
+- **Check todos** → Run `node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" todos list --status pending`, present summary
 - **Review alignment** → Read PROJECT.md, compare to current state
 - **Something else** → Ask what they need
 </step>
@@ -278,7 +278,7 @@ If STATE.md is missing but other artifacts exist:
 1. Read PROJECT.md → Extract "What This Is" and Core Value
 2. Read ROADMAP.md → Determine phases, find current position
 3. Scan \*-SUMMARY.md files → Extract decisions, concerns
-4. Count pending todos in ${project_root}/todos/pending/
+4. Count pending todos via `node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" todos list --status pending --count`
 5. Check for .continue-here files → Session continuity
 
 Reconstruct and write STATE.md, then proceed normally.