@ktpartners/dgs-platform 2.7.5 → 2.9.0

package/deliver-great-systems/bin/lib/test-helpers.cjs

@@ -1,8 +1,8 @@
 /**
  * Shared test helper module for DGS test suite.
  *
- * Provides dual-mode fixture creation (v1 and v2 directory structures),
- * temp directory management, file writing, and git repo initialization.
+ * Provides root-layout fixture creation for DGS test suite.
+ * Temp directory management, file writing, and git repo initialization.
  *
  * All functions are synchronous, matching existing test patterns.
  */
@@ -11,7 +11,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
-const { initPaths, resetPaths, PROJECTS_DIR } = require('./paths.cjs');
+const { initPaths, resetPaths } = require('./paths.cjs');
 
 // ─── Utility Helpers ─────────────────────────────────────────────────────────
 
@@ -50,7 +50,7 @@ function writeFile(base, relPath, content) {
  */
 function initGitRepo(dir) {
   fs.mkdirSync(dir, { recursive: true });
-  execSync('git init', { cwd: dir, stdio: 'pipe' });
+  execSync('git init -b main', { cwd: dir, stdio: 'pipe' });
   execSync('git config user.email "test@test.com"', { cwd: dir, stdio: 'pipe' });
   execSync('git config user.name "Test"', { cwd: dir, stdio: 'pipe' });
   fs.writeFileSync(path.join(dir, '.gitkeep'), '');
@@ -69,13 +69,17 @@ function initGitRepo(dir) {
  *
  * Example:
  *   createFixture({
- *     '.planning/config.json': '{}',
- *     '.planning/STATE.md': '# State',
- *     '.planning/phases/': null,  // directory
+ *     'config.json': '{}',
+ *     'STATE.md': '# State',
+ *     'phases/': null,
  *   })
  */
 function createFixture(structure) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-test-'));
+  var cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-test-'));
+  cwd = fs.realpathSync(cwd);
+
+  // Initialize git repo so getPlanningRoot() works (root layout requires git)
+  initGitRepo(cwd);
 
   for (const [relPath, content] of Object.entries(structure)) {
     const fullPath = path.join(cwd, relPath);
@@ -100,182 +104,75 @@ function createFixture(structure) {
 }
 
 /**
- * Creates a temporary project fixture with either v1 or v2 directory structure.
+ * Creates a temporary project fixture with root-layout directory structure.
+ *
+ * Root layout means planning files live at the repo root (no .planning/ subdirectory).
  *
  * @param {Object} [options={}]
- * @param {number} [options.version=1] - 1 for v1 flat structure, 2 for v2 multi-project.
- * @param {string} [options.project] - Project slug (required when version=2).
- * @param {string} [options.projectName] - Display name (defaults to title-casing the slug).
- * @param {boolean} [options.withGit=false] - Initialize as git repo and commit the structure.
+ * @param {string} [options.projectName] - Display name (defaults to 'Test Project').
+ * @param {boolean} [options.withGit=false] - Commit the fixture structure to git (git always initialized for root layout).
  * @param {Object} [options.withConfig] - Additional config.json fields to merge.
  * @param {boolean} [options.withPhases=true] - Create phases/ directory with sample plan.
  * @param {boolean} [options.withTodos=false] - Create todos/pending/ and todos/completed/.
  * @param {boolean} [options.withResearch=false] - Create research/ directory.
  * @returns {{ cwd: string, cleanup: () => void, planningDir: string, projectRoot: string }}
+ *   planningDir === cwd (planning dir IS the repo root).
+ *   projectRoot === '.' (root-relative path to project).
  */
 function createTempProject(options) {
   const opts = options || {};
-  const version = opts.version || 1;
-  const layout = opts.layout || 'dotplanning';
-  const project = opts.project || null;
-  const projectName = opts.projectName || titleCase(project || 'Test Project');
+  const projectName = opts.projectName || 'Test Project';
   const withGit = opts.withGit || false;
   const withConfig = opts.withConfig || {};
   const withPhases = opts.withPhases !== undefined ? opts.withPhases : true;
   const withTodos = opts.withTodos || false;
   const withResearch = opts.withResearch || false;
 
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-test-'));
-
-  // If withGit, initialize repo first
-  if (withGit) {
-    initGitRepo(cwd);
-  }
-
-  var planningDir;
-  var projectRoot;
-
-  if (layout === 'root') {
-    // Root layout: planning files live at repo root
-    planningDir = cwd;
-    projectRoot = '.';
-
-    // Split withConfig into shared and local keys
-    var rootLocalKeys = { planningRoot: '.' };
-    var rootSharedKeys = {};
-    var LOCAL_KEY_SET = new Set(['current_project', 'planningRoot', 'v2_hint_shown', 'sync_hint_shown']);
-    for (var k in withConfig) {
-      if (LOCAL_KEY_SET.has(k)) {
-        rootLocalKeys[k] = withConfig[k];
-      } else {
-        rootSharedKeys[k] = withConfig[k];
-      }
-    }
-    writeFile(cwd, 'config.local.json', JSON.stringify(rootLocalKeys));
-    writeFile(cwd, 'config.json', JSON.stringify(rootSharedKeys));
-
-    // Project files at root
-    writeFile(cwd, 'PROJECT.md', '# Project: ' + projectName + '\n');
-    writeFile(cwd, 'REQUIREMENTS.md', '# Requirements\n');
-    writeFile(cwd, 'ROADMAP.md', '# Roadmap\n\n## Phases\n\n- [ ] **Phase 1: Test Phase** - A test\n');
-    writeFile(cwd, 'STATE.md', '# Project State\n\nPhase: 1\nStatus: Ready\nProgress: [░░░░░░░░░░] 0%\n');
+  var cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-test-'));
+  cwd = fs.realpathSync(cwd);
 
-    // v2 markers at root (for completeness if root-layout + v2 ever used)
-    writeFile(cwd, 'PROJECTS.md', '# Projects\n');
-    writeFile(cwd, 'REPOS.md', '# Repos\n');
-
-    if (withPhases) {
-      writeFile(cwd, 'phases/01-test-phase/01-01-PLAN.md',
-        '---\nphase: 01-test-phase\nplan: 01\n---\n# Plan\n');
-    }
-
-    if (withTodos) {
-      fs.mkdirSync(path.join(cwd, 'todos', 'pending'), { recursive: true });
-      fs.mkdirSync(path.join(cwd, 'todos', 'completed'), { recursive: true });
-    }
-
-    if (withResearch) {
-      fs.mkdirSync(path.join(cwd, 'research'), { recursive: true });
-    }
-
-  } else if (version === 2) {
-    if (!project) {
-      throw new Error('createTempProject: version 2 requires a project slug');
-    }
-    planningDir = path.join(cwd, '.planning');
-    projectRoot = path.join('.planning', PROJECTS_DIR, project);
-    var absProjectRoot = path.join(cwd, '.planning', PROJECTS_DIR, project);
-
-    // Product-level config: split into shared and local
-    var v2LocalKeys = { current_project: project };
-    var v2SharedKeys = {};
-    var LOCAL_KEY_SET_V2 = new Set(['current_project', 'planningRoot', 'v2_hint_shown', 'sync_hint_shown']);
-    for (var ck in withConfig) {
-      if (LOCAL_KEY_SET_V2.has(ck)) {
-        v2LocalKeys[ck] = withConfig[ck];
-      } else {
-        v2SharedKeys[ck] = withConfig[ck];
-      }
-    }
-    writeFile(cwd, '.planning/config.json', JSON.stringify(v2SharedKeys));
-    writeFile(cwd, '.planning/config.local.json', JSON.stringify(v2LocalKeys));
+  // Always initialize git repo (root layout requires git for getPlanningRoot)
+  initGitRepo(cwd);
 
-    // v2 markers
-    var projectsMd = '# Projects\n\n## Active\n\n';
-    projectsMd += '| Project | Status | Repos Touched | Current Phase |\n';
-    projectsMd += '|---------|--------|---------------|---------------|\n';
-    projectsMd += '| ' + project + ' | Active |  | Phase 1 |\n';
-    projectsMd += '\n## Completed\n\n';
-    projectsMd += '| Project | Completed | Duration |\n';
-    projectsMd += '|---------|-----------|----------|\n';
-    writeFile(cwd, '.planning/PROJECTS.md', projectsMd);
+  const planningDir = cwd;
+  const projectRoot = '.';
 
-    var reposMd = '# Repos\n\n';
-    reposMd += 'Registered repositories for this product. Managed by DGS — manual edits may be overwritten.\n\n';
-    reposMd += '| Name | Path | GitHub URL | Description |\n';
-    reposMd += '|------|------|------------|-------------|\n';
-    writeFile(cwd, '.planning/REPOS.md', reposMd);
-
-    // Project-level files under .planning/projects/<slug>/
-    writeFile(cwd, path.join('.planning', PROJECTS_DIR, project, 'PROJECT.md'), '# Project: ' + projectName + '\n');
-    writeFile(cwd, path.join('.planning', PROJECTS_DIR, project, 'REQUIREMENTS.md'), '# Requirements\n');
-    writeFile(cwd, path.join('.planning', PROJECTS_DIR, project, 'ROADMAP.md'), '# Roadmap\n\n## Phases\n\n- [ ] **Phase 1: Test Phase** - A test\n');
-    writeFile(cwd, path.join('.planning', PROJECTS_DIR, project, 'STATE.md'), '# Project State\n\nPhase: 1\nStatus: Ready\nProgress: [░░░░░░░░░░] 0%\n');
-
-    if (withPhases) {
-      writeFile(cwd, path.join('.planning', PROJECTS_DIR, project, 'phases', '01-test-phase', '01-01-PLAN.md'),
-        '---\nphase: 01-test-phase\nplan: 01\n---\n# Plan\n');
-    }
-
-    if (withTodos) {
-      fs.mkdirSync(path.join(cwd, '.planning', 'todos', 'pending'), { recursive: true });
-      fs.mkdirSync(path.join(cwd, '.planning', 'todos', 'completed'), { recursive: true });
-    }
-
-    if (withResearch) {
-      fs.mkdirSync(path.join(cwd, '.planning', PROJECTS_DIR, project, 'research'), { recursive: true });
-    }
-
-  } else {
-    // v1 mode (dotplanning layout)
-    planningDir = path.join(cwd, '.planning');
-    projectRoot = '.planning';
-
-    // Split withConfig into shared and local
-    var v1SharedKeys = {};
-    var v1LocalKeys = {};
-    var LOCAL_KEY_SET_V1 = new Set(['current_project', 'planningRoot', 'v2_hint_shown', 'sync_hint_shown']);
-    for (var vk in withConfig) {
-      if (LOCAL_KEY_SET_V1.has(vk)) {
-        v1LocalKeys[vk] = withConfig[vk];
-      } else {
-        v1SharedKeys[vk] = withConfig[vk];
-      }
-    }
-    writeFile(cwd, '.planning/config.json', JSON.stringify(v1SharedKeys));
-    if (Object.keys(v1LocalKeys).length > 0) {
-      writeFile(cwd, '.planning/config.local.json', JSON.stringify(v1LocalKeys));
-    }
-
-    // Project files
-    writeFile(cwd, '.planning/PROJECT.md', '# Project: ' + projectName + '\n');
-    writeFile(cwd, '.planning/REQUIREMENTS.md', '# Requirements\n');
-    writeFile(cwd, '.planning/ROADMAP.md', '# Roadmap\n\n## Phases\n\n- [ ] **Phase 1: Test Phase** - A test\n');
-    writeFile(cwd, '.planning/STATE.md', '# Project State\n\nPhase: 1\nStatus: Ready\nProgress: [░░░░░░░░░░] 0%\n');
-
-    if (withPhases) {
-      writeFile(cwd, '.planning/phases/01-test-phase/01-01-PLAN.md',
-        '---\nphase: 01-test-phase\nplan: 01\n---\n# Plan\n');
+  // Split withConfig into shared and local keys
+  var localKeys = { planningRoot: '.' };
+  var sharedKeys = {};
+  var LOCAL_KEY_SET = new Set(['current_project', 'planningRoot', 'v2_hint_shown', 'sync_hint_shown']);
+  for (var k in withConfig) {
+    if (LOCAL_KEY_SET.has(k)) {
+      localKeys[k] = withConfig[k];
+    } else {
+      sharedKeys[k] = withConfig[k];
     }
+  }
+  writeFile(cwd, 'config.local.json', JSON.stringify(localKeys));
+  writeFile(cwd, 'config.json', JSON.stringify(sharedKeys));
+
+  // Project files at root
+  writeFile(cwd, 'PROJECT.md', '# Project: ' + titleCase(projectName) + '\n');
+  writeFile(cwd, 'REQUIREMENTS.md', '# Requirements\n');
+  writeFile(cwd, 'ROADMAP.md', '# Roadmap\n\n## Phases\n\n- [ ] **Phase 1: Test Phase** - A test\n');
+  writeFile(cwd, 'STATE.md', '# Project State\n\nPhase: 1\nStatus: Ready\nProgress: [░░░░░░░░░░] 0%\n');
+
+  // v2 markers at root
+  writeFile(cwd, 'PROJECTS.md', '# Projects\n');
+  writeFile(cwd, 'REPOS.md', '# Repos\n');
+
+  if (withPhases) {
+    writeFile(cwd, 'phases/01-test-phase/01-01-PLAN.md',
+      '---\nphase: 01-test-phase\nplan: 01\n---\n# Plan\n');
+  }
 
-    if (withTodos) {
-      fs.mkdirSync(path.join(cwd, '.planning', 'todos', 'pending'), { recursive: true });
-      fs.mkdirSync(path.join(cwd, '.planning', 'todos', 'completed'), { recursive: true });
-    }
+  if (withTodos) {
+    fs.mkdirSync(path.join(cwd, 'todos', 'pending'), { recursive: true });
+    fs.mkdirSync(path.join(cwd, 'todos', 'completed'), { recursive: true });
+  }
 
-    if (withResearch) {
-      fs.mkdirSync(path.join(cwd, '.planning', 'research'), { recursive: true });
-    }
+  if (withResearch) {
+    fs.mkdirSync(path.join(cwd, 'research'), { recursive: true });
   }
 
   // If withGit, commit the fixture structure

package/deliver-great-systems/bin/lib/verify.cjs

@@ -537,9 +537,9 @@ function cmdValidateHealth(cwd, options, raw) {
     else info.push(issue);
   };
 
-  // ─── Check 1: .planning/ exists ───────────────────────────────────────────
+  // ─── Check 1: Planning files exist ──────────────────────────────────────────
   if (!fs.existsSync(planningDir)) {
-    addIssue('error', 'E001', '.planning/ directory not found', 'Run /dgs:new-project to initialize');
+    addIssue('error', 'E001', 'Planning files not found at root', 'Run /dgs:new-project to initialize');
     output({
       status: 'broken',
       errors,
@@ -742,7 +742,7 @@ function cmdValidateHealth(cwd, options, raw) {
             const milestone = getMilestoneInfo(cwd);
             let stateContent = `# Session State\n\n`;
             stateContent += `## Project Reference\n\n`;
-            stateContent += `See: .planning/PROJECT.md\n\n`;
+            stateContent += `See: PROJECT.md\n\n`;
             stateContent += `## Position\n\n`;
             stateContent += `**Milestone:** ${milestone.version} ${milestone.name}\n`;
             stateContent += `**Current phase:** (determining...)\n`;

package/deliver-great-systems/references/planning-config.md

@@ -11,12 +11,10 @@ DGS splits configuration across two files, both resolved via `getPlanningRoot()`
 | File | Tracked | Purpose | Keys |
 |------|---------|---------|------|
 | `config.json` | Yes (shared) | Team settings: model profile, workflow flags, git config, sync config, parallelization | All `VALID_CONFIG_KEYS` |
-| `config.local.json` | No (gitignored) | Per-machine state: which project is active, where planning lives | `current_project`, `planningRoot`, `v2_hint_shown`, `sync_hint_shown` |
+| `config.local.json` | No (gitignored) | Per-machine state: which project is active | `current_project`, `v2_hint_shown`, `sync_hint_shown` |
 
 `loadConfig()` in `core.cjs` merges both files -- local overrides shared. `writeConfigField()` in `config.cjs` routes writes to the correct file based on `isLocalKey()`.
 
-**Migration:** On first read, if only `dgs.config.json` exists, `_migrateLegacyConfig()` splits it into the two-file layout automatically.
-
 <config_schema>
 
 ## Config Schema
@@ -102,7 +100,6 @@ These keys are stored in `config.local.json` (gitignored, per-machine):
 | Key | Default | Description |
 |-----|---------|-------------|
 | `current_project` | -- | Active project slug for multi-project setups |
-| `planningRoot` | -- | Absolute path to planning root (when non-standard) |
 | `v2_hint_shown` | -- | Whether the v2 migration hint has been shown |
 | `sync_hint_shown` | -- | Whether the sync first-run hint has been shown |
 
@@ -176,14 +173,16 @@ To use uncommitted mode:
    }
    ```
 
-2. **Add to .gitignore:**
+2. **Add planning paths to .gitignore:**
    ```
-   .planning/
+   projects/
+   config.json
+   config.local.json
    ```
 
-3. **Existing tracked files:** If the planning directory was previously tracked:
+3. **Existing tracked files:** If planning files were previously tracked:
    ```bash
-   git rm -r --cached ${project_root}
+   git rm -r --cached projects/ config.json config.local.json
    git commit -m "chore: stop tracking planning docs"
    ```
 

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

@@ -50,7 +50,7 @@ TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" contex
 Verify the phase directory exists. If not:
 ```
 ERROR: Phase directory not found for phase ${PHASE_ARG}
-Ensure the phase exists in .planning/phases/
+Ensure the phase exists in phases/
 ```
 Exit.
 

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

@@ -114,17 +114,7 @@ This enforces APR-02.
 </step>
 
 <step name="warning_gate">
-**Check for roadmap linkage:**
-
-Read the spec's frontmatter for a `milestones` field (array of milestone references). If the field is empty, null, or absent, add an informational warning to the warnings list:
-
-```
-- This spec has no roadmap linkage (no milestones field). Consider linking it to a milestone for implementation tracking.
-```
-
-This is a warning, not a blocker. It runs after structural validation so it appears alongside other warnings in this gate.
-
-If warnings exist (from validate command output, plus any roadmap linkage warning added above):
+If warnings exist (from validate command output):
 - Display each warning clearly:
   ```
   ## Approval Warnings

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

@@ -500,7 +500,7 @@ rm ${project_root}/REQUIREMENTS.md
 
 Check for existing retrospective:
 ```bash
-ls .planning/RETROSPECTIVE.md 2>/dev/null
+ls RETROSPECTIVE.md 2>/dev/null
 ```
 
 **If exists:** Read the file, append new milestone section before the "## Cross-Milestone Trends" section.
@@ -550,7 +550,7 @@ If the "## Cross-Milestone Trends" section exists, update the tables with new da
 
 **Commit:**
 ```bash
-node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs: update retrospective for v${VERSION}" --files .planning/RETROSPECTIVE.md
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs: update retrospective for v${VERSION}" --files RETROSPECTIVE.md
 ```
 
 </step>

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": ".planning/ideas/pending/005-improve-api-resilience.md",
+  "path": "ideas/pending/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

@@ -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 .planning/jobs/pending/milestone-{version}.md
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "docs(50): create milestone job {version}" --files jobs/pending/milestone-{version}.md
 ```
 
 3. Display success and next steps:
 
 ```
-Job created: .planning/jobs/pending/milestone-{version}.md
+Job created: jobs/pending/milestone-{version}.md
 
 ---
 

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

@@ -190,7 +190,7 @@ Project-level files (PROJECT.md, REQUIREMENTS.md, STATE.md, ROADMAP.md, REPOS.md
 **Step 2: Read all prior CONTEXT.md files**
 ```bash
 # Find all CONTEXT.md files from phases before current
-find .planning/phases -name "*-CONTEXT.md" 2>/dev/null | sort
+find phases -name "*-CONTEXT.md" 2>/dev/null | sort
 ```
 
 For each CONTEXT.md where phase number < current phase:
@@ -230,7 +230,7 @@ Lightweight scan of existing code to inform gray area identification and discuss
 
 **Step 1: Check for existing codebase maps**
 ```bash
-ls .planning/codebase/*.md 2>/dev/null
+ls codebase/*.md 2>/dev/null
 ```
 
 **If codebase maps exist:** Read the most relevant ones (CONVENTIONS.md, STRUCTURE.md, STACK.md based on phase type). Extract:

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

@@ -283,7 +283,66 @@ Execute each wave in sequence. Within a wave: parallel if `PARALLELIZATION=true`
    - Bad: "Wave 2 complete. Proceeding to Wave 3."
    - Good: "Terrain system complete — 3 biome types, height-based texturing, physics collision meshes. Vehicle physics (Wave 3) can now reference ground surfaces."
 
-5. **Mid-workflow push (sync_mid_push):**
+5. **Codereview gate (per-plan, after spot-check passes):**
+
+   Check if code review is enabled:
+   ```bash
+   CODEREVIEW=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" config-get workflow.codereview 2>/dev/null || echo "false")
+   ```
+
+   If `CODEREVIEW` is not `true`: skip silently, proceed to next step.
+
+   **If `NON_INTERACTIVE` is true:**
+   Log: `[AUTO-RESOLVE] Code review enabled but skipping in non-interactive mode (codereview requires interactive Task spawning)`
+   Skip codereview, proceed to next step.
+
+   **If `NON_INTERACTIVE` is false (interactive mode) AND `CODEREVIEW` is `true`:**
+
+   For each plan that completed successfully in this wave:
+
+   Display:
+   ```
+   ------------------------------------------------------------
+    DGS > SPAWNING CODE REVIEW
+   ------------------------------------------------------------
+
+    Reviewing {phase}-{plan} changes across 3 passes...
+   ```
+
+   Compute diff reference for 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)
+   ```
+
+   If FIRST_TASK_COMMIT is empty (no task commits found), skip codereview for this plan with message: "No task commits found for {phase}-{plan}, skipping code review."
+
+   Otherwise, spawn the codereview workflow via Task:
+   ```
+   Task(
+     prompt="Run code review for plan {phase}-{plan}.
+
+     @~/.claude/deliver-great-systems/workflows/codereview.md
+
+     Inputs:
+     - PHASE: ${PHASE}
+     - PLAN: ${PLAN}
+     - PLAN_PATH: ${phase_dir}/{phase}-{plan}-PLAN.md
+     - PHASE_DIR: ${phase_dir}
+     - DIFF_REF: ${FIRST_TASK_COMMIT}^..HEAD
+     ",
+     model="{executor_model}"
+   )
+   ```
+
+   After codereview completes for a plan:
+   - If auto-fixes were committed, the fix commit hash is noted in the codereview output
+   - The SUMMARY.md already has codereview findings appended and CODEREVIEW.md has been created with the full report (both done by codereview workflow)
+   - If the codereview workflow committed auto-fixes, amend the plan's metadata commit to include the updated SUMMARY.md and CODEREVIEW.md:
+     ```bash
+     node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "" --files ${phase_dir}/{phase}-{plan}-SUMMARY.md ${phase_dir}/{phase}-{plan}-CODEREVIEW.md --amend
+     ```
+
+6. **Mid-workflow push (sync_mid_push):**
 
    After each wave completes successfully, push if sync is configured.
 
@@ -297,7 +356,7 @@ Execute each wave in sequence. Within a wave: parallel if `PARALLELIZATION=true`
    - If `action` is `"pushed"`: continue silently. If `message` mentions new remote branch, log: `Created remote branch: {branch}`
    - Push failure does NOT halt execution -- warnings are accumulated for end-of-workflow summary
 
-6. **Handle failures:**
+7. **Handle failures:**
 
    **Known Claude Code bug (classifyHandoffIfNeeded):** If an agent reports "failed" with error containing `classifyHandoffIfNeeded is not defined`, this is a Claude Code runtime bug — not a DGS or agent issue. The error fires in the completion handler AFTER all tool calls finish. In this case: run the same spot-checks as step 4 (SUMMARY.md exists, git commits present, no Self-Check: FAILED). If spot-checks PASS → treat as **successful**. If spot-checks FAIL → treat as real failure below.
 
@@ -308,9 +367,9 @@ Execute each wave in sequence. Within a wave: parallel if `PARALLELIZATION=true`
    **If `NON_INTERACTIVE` is false (interactive mode):**
    For real failures: report which plan failed → ask "Continue?" or "Stop?" → if continue, dependent plans may also fail. If stop, partial completion report.
 
-7. **Execute checkpoint plans between waves** — see `<checkpoint_handling>`.
+8. **Execute checkpoint plans between waves** — see `<checkpoint_handling>`.
 
-8. **Proceed to next wave.**
+9. **Proceed to next wave.**
 </step>
 
 <step name="checkpoint_handling">

package/deliver-great-systems/workflows/execute-plan.md

@@ -486,56 +486,6 @@ node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs({phase
 ```
 </step>
 
-<step name="codereview_gate">
-Check if code review is enabled:
-
-```bash
-CODEREVIEW=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" config-get workflow.codereview 2>/dev/null || echo "false")
-```
-
-If `CODEREVIEW` is `true`:
-
-Display:
-```
-------------------------------------------------------------
- DGS > SPAWNING CODE REVIEW
-------------------------------------------------------------
-
- Reviewing {phase}-{plan} changes across 3 passes...
-```
-
-Compute diff reference for 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)
-```
-
-If FIRST_TASK_COMMIT is empty (no task commits found), skip codereview with message: "No task commits found for {phase}-{plan}, skipping code review."
-
-Otherwise, invoke the codereview workflow:
-
-```
-@~/.claude/deliver-great-systems/workflows/codereview.md
-```
-
-With inputs:
-- PHASE: ${PHASE}
-- PLAN: ${PLAN}
-- PLAN_PATH: ${phase_dir}/{phase}-{plan}-PLAN.md
-- PHASE_DIR: ${phase_dir}
-- DIFF_REF: ${FIRST_TASK_COMMIT}^..HEAD
-
-After codereview completes:
-- If auto-fixes were committed, the fix commit hash is noted in the codereview output
-- The SUMMARY.md already has codereview findings appended and CODEREVIEW.md has been created with the full report (both done by codereview workflow)
-- If the codereview workflow committed auto-fixes, amend the metadata commit to include the updated SUMMARY.md and CODEREVIEW.md:
-  ```bash
-  node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "" --files ${phase_dir}/{phase}-{plan}-SUMMARY.md ${phase_dir}/{phase}-{plan}-CODEREVIEW.md --amend
-  ```
-
-If `CODEREVIEW` is `false` or absent: skip silently (no output).
-</step>
-
 <step name="update_codebase_map">
 If ${project_root}/codebase/ doesn't exist: skip.
 
@@ -588,5 +538,4 @@ All routes: `/clear` first for fresh context.
 - ROADMAP.md updated
 - If codebase map exists: map updated with execution changes (or skipped if no significant changes)
 - If USER-SETUP.md created: prominently surfaced in completion output
-- If codereview enabled: code review completed, auto-fixes committed separately, findings logged to SUMMARY, CODEREVIEW.md created with full report
 </success_criteria>

package/deliver-great-systems/workflows/find-related-ideas.md

@@ -115,7 +115,7 @@ ls ${codebase_dir}/*.md 2>/dev/null
 ls ${project_root}/docs/product/*.md 2>/dev/null
 ```
 
-Where `codebase_dir` is `.planning/codebase` (or the project-specific path if in multi-project mode) and `project_root` is the repo root.
+Where `codebase_dir` is `codebase` (or the project-specific path if in multi-project mode) and `project_root` is the repo root.
 
 Read available context files. Prioritise:
 1. `ARCHITECTURE.md` -- system structure and module boundaries