@ktpartners/dgs-platform 2.7.5 → 2.9.0

package/CHANGELOG.md

@@ -8,6 +8,36 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [2.9.0] - 2026-03-25
+
+### Changed
+- **new-project/new-milestone split** — `/dgs:new-project` now only handles questioning and PROJECT.md creation; all milestone-scoped work (research, requirements, roadmap, STATE.md) moves to `/dgs:new-milestone`, which now handles both first and subsequent milestones
+- **Codereview gate moved to orchestrator** — code review execution moved from `dgs-executor` (which lacks Task tool) to `execute-phase` orchestrator where Task spawning is available; skips in non-interactive/job mode with log message
+- **Map-codebase staleness gate** — in `--auto` mode (job runs), checks git history since last map; skips if no changes, narrows to single repo if only one changed; `--force` flag bypasses
+
+### Added
+- **Job file commit+push on status changes** — `run-job` now commits and pushes the job file after every step status update (in-progress, completed, failed, move operations), making job progress visible on remote in real time
+- **First-milestone guards in new-milestone** — handles missing MILESTONES.md/STATE.md gracefully with v1.0 default, phase-1 numbering, greenfield research framing, and STATE.md creation
+
+### Fixed
+- **Codereview silent failure in job mode** — codereview was silently skipped in job mode because the executor agent lacked Task/Agent tools needed to spawn the 9 review subagents
+
+## [2.8.0] - 2026-03-25
+
+### Changed
+- **Root layout consolidation (v18.0)** — DGS now uses a single root layout format exclusively; the `.planning/` prefix path is no longer supported
+- **Path resolution simplified** — `getPlanningRoot()` reduced to a single `git rev-parse --show-toplevel` call with per-process cache, removing the detection cascade
+- **V1 support removed** — V1 single-repo installs are rejected with a clear error and `V1_UNSUPPORTED.md` guidance file; all V1-to-V2 migration code removed from `migration.cjs`
+
+### Added
+- **Automatic .planning/-to-root migration** — `migrateDotPlanningToRoot()` auto-migrates existing `.planning/` layouts on first DGS command with conflict detection, dry-run mode, rollback on failure, and non-git fallback
+- **Migration CLI** — `dgs-tools migrate --layout root` for manual triggering with `--dry-run` preview
+
+### Fixed
+- **Zero .planning references in production code** — all hardcoded `.planning` path literals removed from 20+ production modules and 11 workflow files (including 181 reference doc references)
+- **Test suite root-layout-only** — all 12 test files converted to root-layout fixtures; V1 detection and dual-layout test cases removed; comprehensive migration coverage added (6 scenarios)
+- **Stale test assertions** — removed `dotplanning` assertion from `init.test.cjs` and vestigial `planningRoot` write from `repos.cjs`
+
 ## [2.7.5] - 2026-03-22
 
 ### Added

package/README.md

@@ -194,7 +194,7 @@ If you prefer not to use that flag, add this to your project's `.claude/settings
 
 DGS operates at the **product** level. A product contains one or more **projects**, each with its own milestones and phases. Ideas and specs live at the product level and feed into project or milestone creation.
 
-> **Already have code?** Run `/dgs:map-codebase` first. It spawns parallel agents per registered repo to analyze stack, architecture, structure, conventions, testing, integrations, and concerns. Per-repo maps are synthesized into unified top-level files. Then `/dgs:new-project` knows your codebase — questions focus on what you're adding, and planning automatically loads your patterns. Update a single repo after changes with `/dgs:map-codebase <repo-name>`.
+> **Already have code?** Run `/dgs:map-codebase` first. It spawns parallel agents per registered repo to analyze stack, architecture, structure, conventions, testing, integrations, and concerns. Per-repo maps are synthesized into unified top-level files. Then `/dgs:new-project` captures your project identity — goals, constraints, and scope. `/dgs:new-milestone` takes it from there with research, requirements, and roadmap. Update a single repo after changes with `/dgs:map-codebase <repo-name>`.
 
 ### 1. Set Up Product
 
@@ -236,18 +236,21 @@ If you have OpenAI or Gemini API keys configured, the spec goes through a **cros
 
 ```
 /dgs:new-project
+/dgs:new-milestone
 ```
 
-One command, one flow. The system:
+Two commands, one setup. First, `/dgs:new-project` asks questions until it understands your idea completely — goals, constraints, tech preferences, edge cases — then creates `PROJECT.md`.
+
+Then `/dgs:new-milestone` takes over:
 
-1. **Questions** — Asks until it understands your idea completely (goals, constraints, tech preferences, edge cases)
-2. **Research** — Spawns parallel agents to investigate the domain (optional but recommended)
-3. **Requirements** — Extracts what's v1, v2, and out of scope
-4. **Roadmap** — Creates phases mapped to requirements
+1. **Research** — Spawns parallel agents to investigate the domain (optional but recommended)
+2. **Requirements** — Extracts what's v1, v2, and out of scope
+3. **Roadmap** — Creates phases mapped to requirements
 
 You approve the roadmap. Now you're ready to build.
 
-**Creates:** `PROJECT.md`, `REQUIREMENTS.md`, `ROADMAP.md`, `STATE.md`, `.planning/research/`
+**`new-project` creates:** `PROJECT.md`
+**`new-milestone` creates:** `REQUIREMENTS.md`, `ROADMAP.md`, `STATE.md`, `research/`
 
 ---
 
@@ -393,7 +396,7 @@ When all phases are done, `/dgs:complete-milestone` archives the milestone and t
 
 **Automated alternative:** Instead of running each phase command manually, use `/dgs:create-milestone-job` to generate a build job and `/dgs:run-job` to execute the entire milestone pipeline automatically with subagent isolation per step. See the [User Guide](docs/USER-GUIDE.md#milestone-jobs) for details.
 
-Then `/dgs:new-milestone` starts the next version — same flow as `new-project` but for your existing codebase. You describe what you want to build next, the system researches the domain, you scope requirements, and it creates a fresh roadmap. Each milestone is a clean cycle: define → build → ship.
+Then `/dgs:new-milestone` starts the next cycle. This is the same command used after `new-project` — it handles research, requirements, and roadmap for each version. You describe what you want to build next, it researches the domain, you scope requirements, and it creates a fresh roadmap. Each milestone is a clean cycle: define → build → ship.
 
 ---
 
@@ -460,7 +463,7 @@ DGS handles it for you:
 | `REQUIREMENTS.md` | Scoped v1/v2 requirements with phase traceability |
 | `ROADMAP.md` | Where you're going, what's done |
 | `STATE.md` | Decisions, blockers, position — memory across sessions |
-| `docs/product/` | Product-level documents (architecture, summary) — loaded as context by write-spec, plan-phase, new-project, new-milestone |
+| `docs/product/` | Product-level documents (architecture, summary) — loaded as context by write-spec, plan-phase, new-milestone |
 | `codebase/` | Per-repo maps + unified synthesis from `/dgs:map-codebase` |
 | `research/` | Ecosystem knowledge (stack, features, architecture, pitfalls) |
 | `PLAN.md` | Atomic task with XML structure, verification steps |
@@ -554,7 +557,7 @@ See the [User Guide](docs/USER-GUIDE.md#context-tiers) for the complete command-
 
 | Command | What it does |
 |---------|--------------|
-| `/dgs:new-project [--auto]` | Full initialization: questions → research → requirements → roadmap |
+| `/dgs:new-project [--auto]` | Project identity: questioning → PROJECT.md |
 | `/dgs:discuss-phase [N] [--auto]` | Capture implementation decisions before planning |
 | `/dgs:plan-phase [N] [--auto]` | Research + plan + verify for a phase |
 | `/dgs:execute-phase <N>` | Execute all plans in parallel waves, verify when complete |
@@ -562,7 +565,7 @@ See the [User Guide](docs/USER-GUIDE.md#context-tiers) for the complete command-
 | `/dgs:audit-phase <phase> [--rerun-failed]` | Automated phase verification: test execution + structural inspection |
 | `/dgs:audit-milestone` | Verify milestone achieved its definition of done |
 | `/dgs:complete-milestone` | Archive milestone, tag release |
-| `/dgs:new-milestone [name]` | Start next version: questions → research → requirements → roadmap |
+| `/dgs:new-milestone [name]` | Start milestone: research → requirements → roadmap (first or subsequent) |
 
 ### Navigation
 
@@ -665,7 +668,7 @@ See the [User Guide](docs/USER-GUIDE.md#context-tiers) for the complete command-
 
 ## Configuration
 
-DGS stores product-level settings in `.planning/config.json`. This file is shared across all projects in the product. Configure during `/dgs:init-product` or `/dgs:new-project`, and update later with `/dgs:settings`. For the full config schema, workflow toggles, git branching options, and per-agent model breakdown, see the [User Guide](docs/USER-GUIDE.md#configuration-reference).
+DGS stores product-level settings in `.planning/config.json`. This file is shared across all projects in the product. Configure during `/dgs:init-product`, and update later with `/dgs:settings`. For the full config schema, workflow toggles, git branching options, and per-agent model breakdown, see the [User Guide](docs/USER-GUIDE.md#configuration-reference).
 
 ### Core Settings
 

package/agents/dgs-executor.md

@@ -516,57 +516,6 @@ node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs({phase
 
 Separate from per-task commits — captures execution results only.
 </final_commit>
-
-<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).
-</codereview_gate>
-
 <completion_format>
 ```markdown
 ## PLAN COMPLETE
@@ -596,6 +545,5 @@ Plan execution complete when:
 - [ ] STATE.md updated (position, decisions, issues, session)
 - [ ] ROADMAP.md updated with plan progress (via `roadmap update-plan-progress`)
 - [ ] Final metadata commit made (includes SUMMARY.md, STATE.md, ROADMAP.md)
-- [ ] Codereview gate checked (if enabled: codereview invoked, if auto-fixes committed: metadata commit amended)
 - [ ] Completion format returned to orchestrator
 </success_criteria>

package/deliver-great-systems/bin/dgs-tools.cjs

@@ -22,7 +22,7 @@
  *   current-timestamp [format]         Get timestamp (full|date|filename)
  *   list-todos [area]                  Count and enumerate pending todos
  *   verify-path-exists <path>          Check file/directory existence
- *   config-ensure-section              Initialize .planning/config.json
+ *   config-ensure-section              Initialize config.json
  *   review-config                      Load review config with defaults
  *   check-config-gitignore             Check if config.json needs .gitignore
  *   history-digest                     Aggregate all SUMMARY.md data
@@ -55,7 +55,7 @@
  *
  * Validation:
  *   validate consistency               Check phase numbering, disk/roadmap sync
- *   validate health [--repair]         Check .planning/ integrity, optionally repair
+ *   validate health [--repair]         Check planning file integrity, optionally repair
  *
  * Progress:
  *   progress [json|table|bar]          Render progress in various formats
@@ -70,6 +70,11 @@
  *   scaffold phase-dir --phase <N>     Create phase directory
  *     --name <name>
  *
+ * Migration:
+ *   migrate --layout root              Migrate .planning/ to root layout
+ *     [--dry-run]                       Show what would change without modifying
+ *     [--raw]                           JSON output for scripting
+ *
  * Context:
  *   context load-tier <name>          Get file list for a context tier
  *     [--phase N] [--idea N] [--spec N]  Scope-specific enrichment
@@ -167,7 +172,6 @@
  *   repos scan-tags <phase-dir>         Scan plan files for <repos> tags
  *   repos auto-populate <plan-file>    Auto-populate <repos> tags from <files> paths
  *   repos validate-consistency <plan>  Validate <repos>/<files> consistency
- *   repos migrate <slug>              Migrate v1 install to v2 structure
  *
  * Sync:
  *   sync pull [--dry-run] [--force]    Pull from all repos (ff-only)
@@ -279,6 +283,7 @@ const mergeConflicts = require('./lib/merge-conflicts.cjs');
 const conflictAgent = require('./lib/conflict-agent.cjs');
 const { requireGitIdentity, formatAuthorString, cmdIdentityResolve } = require('./lib/identity.cjs');
 const { pullAll, pushAll, getCadence, checkStaleState, shouldShowFirstRunHint, markFirstRunHintShown, isWithinSuppressionWindow, recordPromptYes } = require('./lib/sync.cjs');
+const { migrateDotPlanningToRoot, rejectV1Install } = require('./lib/migration.cjs');
 
 // ─── Identity Gate ────────────────────────────────────────────────────────────
 
@@ -564,8 +569,32 @@ async function main() {
   const command = args[0];
   const cwd = process.cwd();
 
+  // V1 rejection: single call site — library callers skip this guard
+  rejectV1Install(cwd);
+
+  // .planning/ to root layout migration: auto-trigger before command dispatch
+  // Silent migration with compact banner — original command continues after
+  // Skip auto-trigger when user explicitly invokes 'migrate' (they control the options)
+  if (command !== 'migrate') try {
+    const migrationResult = migrateDotPlanningToRoot(cwd);
+    if (migrationResult.migrated) {
+      const parts = [`DGS migrated .planning/ to root layout. ${migrationResult.filesMoved} file(s) moved.`];
+      if (migrationResult.identicalResolved > 0) {
+        parts.push(`${migrationResult.identicalResolved} identical file(s) resolved (kept root copy).`);
+      }
+      if (migrationResult.commitHash) {
+        parts.push(`See commit ${migrationResult.commitHash}.`);
+      }
+      process.stderr.write(parts.join(' ') + '\n');
+    }
+  } catch {
+    // Migration errors are already handled by error() inside migrateDotPlanningToRoot.
+    // This catch handles unexpected errors — let command continue if migration
+    // fails for unexpected reasons (defensive, should not normally trigger).
+  }
+
   if (!command) {
-    error('Usage: dgs-tools <command> [args] [--raw]\nCommands: state, resolve-model, find-phase, commit, verify-summary, verify, frontmatter, template, generate-slug, current-timestamp, list-todos, verify-path-exists, config-ensure-section, repos, projects, overlap, merge-conflicts, conflict-agent, init');
+    error('Usage: dgs-tools <command> [args] [--raw]\nCommands: state, resolve-model, find-phase, commit, verify-summary, verify, frontmatter, template, generate-slug, current-timestamp, list-todos, verify-path-exists, config-ensure-section, repos, projects, overlap, merge-conflicts, conflict-agent, init, migrate');
   }
 
   switch (command) {
@@ -927,13 +956,8 @@ async function main() {
       } else if (subcommand === 'validate-consistency') {
         const planFile = args[2];
         repos.cmdReposValidateConsistency(cwd, planFile, raw);
-      } else if (subcommand === 'migrate') {
-        const migrationMod = require('./lib/migration.cjs');
-        const slug = args[2];
-        if (!slug) error('Usage: repos migrate <slug>');
-        migrationMod.cmdMigrateV1ToV2(cwd, slug, raw);
       } else {
-        error('Unknown repos subcommand. Available: list, add, remove, validate, resolve, init-product, detect-layout, scan-tags, auto-populate, validate-consistency, migrate');
+        error('Unknown repos subcommand. Available: list, add, remove, validate, resolve, init-product, detect-layout, scan-tags, auto-populate, validate-consistency');
       }
       break;
     }
@@ -1723,6 +1747,38 @@ async function main() {
       break;
     }
 
+    case 'migrate': {
+      const layoutIdx = args.indexOf('--layout');
+      const layout = layoutIdx !== -1 ? args[layoutIdx + 1] : null;
+      if (layout !== 'root') {
+        error('Usage: dgs-tools migrate --layout root [--dry-run] [--raw]');
+      }
+      const dryRun = args.includes('--dry-run');
+      const result = migrateDotPlanningToRoot(cwd, { dryRun });
+      if (raw) {
+        const { output: out } = require('./lib/core.cjs');
+        out(result, raw);
+      } else if (result.dryRun) {
+        if (result.actions.length === 0) {
+          process.stderr.write('Nothing to migrate. Already in root layout.\n');
+        } else {
+          process.stderr.write('Dry run — the following changes would be made:\n');
+          for (const action of result.actions) {
+            const label = action.type === 'identical' ? '(identical, delete .planning copy)' : '';
+            process.stderr.write(`  ${action.from} -> ${action.to} ${label}\n`);
+          }
+          process.stderr.write(`\n${result.filesMoved} file(s) to move, ${result.identicalResolved} identical conflict(s) to resolve.\n`);
+        }
+      } else if (result.migrated) {
+        process.stderr.write(`Migration complete. ${result.filesMoved} file(s) moved.`);
+        if (result.commitHash) process.stderr.write(` Commit: ${result.commitHash}`);
+        process.stderr.write('\n');
+      } else {
+        process.stderr.write('Nothing to migrate. Already in root layout.\n');
+      }
+      break;
+    }
+
     default:
       error(`Unknown command: ${command}`);
   }

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

@@ -228,15 +228,8 @@ function cmdCommit(cwd, message, files, raw, amend, push) {
     return;
   }
 
-  // Check if .planning is gitignored
-  if (isGitIgnored(cwd, '.planning')) {
-    const result = { committed: false, hash: null, reason: 'skipped_gitignored' };
-    output(result, raw, 'skipped');
-    return;
-  }
-
   // Stage files
-  const filesToStage = files && files.length > 0 ? files : ['.planning/'];
+  const filesToStage = files && files.length > 0 ? files : ['.'];
   for (const file of filesToStage) {
     execGit(cwd, ['add', file]);
   }

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

@@ -9,7 +9,7 @@
  * writeConfigField routes writes to the correct file based on isLocalKey().
  * loadConfig (in core.cjs) merges both files with local overriding shared.
  *
- * Zero hardcoded .planning/config.json paths -- all resolved via getPlanningRoot.
+ * Zero hardcoded config.json paths -- all resolved via getPlanningRoot.
  */
 
 const fs = require('fs');
@@ -33,7 +33,7 @@ const VALID_CONFIG_KEYS = new Set([
   'search_gitignored', 'brave_search',
   'workflow.research', 'workflow.plan_check', 'workflow.verifier',
   'workflow.nyquist_validation', 'workflow.ui_phase', 'workflow.ui_safety_gate',
-  'workflow._auto_chain_active', 'workflow.discipline',
+  'workflow._auto_chain_active', 'workflow.discipline', 'workflow.codereview',
   'git.base_branch', 'git.branching_strategy', 'git.phase_branch_template', 'git.milestone_branch_template',
   'git.sync', 'git.sync_push', 'git.sync_pull',
   'planning.commit_docs', 'planning.search_gitignored',
@@ -63,21 +63,13 @@ function getLocalConfigPath(cwd) {
  * @deprecated Use getSharedConfigPath or getLocalConfigPath instead.
  * Resolve the config file path for the given cwd and mode.
  * Now returns config.json (shared) for both read and write modes.
- * Falls back to legacy dgs.config.json for read mode.
  *
  * @param {string} cwd - Working directory
  * @param {'read'|'write'} mode - 'read' or 'write'
  * @returns {string} Absolute path to the config file
  */
 function getConfigPath(cwd, mode) {
-  const root = getPlanningRoot(cwd);
-  const sharedPath = path.join(root, 'config.json');
-  if (mode === 'write') return sharedPath;
-  // Read mode: prefer config.json, fall back to legacy dgs.config.json
-  if (fs.existsSync(sharedPath)) return sharedPath;
-  const legacyPath = path.join(root, 'dgs.config.json');
-  if (fs.existsSync(legacyPath)) return legacyPath;
-  return sharedPath; // default when neither exists
+  return getSharedConfigPath(cwd);
 }
 
 /**
@@ -120,56 +112,6 @@ function _writeJson(filePath, data) {
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
 }
 
-/**
- * Perform a one-time migration of legacy dgs.config.json to the two-file layout.
- * Separates local keys from shared keys and writes to the appropriate files.
- *
- * @param {string} cwd - Working directory
- * @returns {boolean} True if migration was performed
- */
-function _migrateLegacyConfig(cwd) {
-  const root = getPlanningRoot(cwd);
-  const legacyPath = path.join(root, 'dgs.config.json');
-  const sharedPath = path.join(root, 'config.json');
-  const localPath = path.join(root, 'config.local.json');
-
-  if (!fs.existsSync(legacyPath)) return false;
-  if (fs.existsSync(sharedPath) || fs.existsSync(localPath)) return false;
-
-  try {
-    const legacy = JSON.parse(fs.readFileSync(legacyPath, 'utf-8'));
-    const shared = {};
-    const local = {};
-
-    for (const [key, value] of Object.entries(legacy)) {
-      if (LOCAL_KEYS.has(key)) {
-        local[key] = value;
-      } else if (key === 'git' && typeof value === 'object') {
-        // Split git section: sync_hint_shown is local, rest is shared
-        const gitShared = {};
-        for (const [gk, gv] of Object.entries(value)) {
-          if (gk === 'sync_hint_shown') {
-            local.sync_hint_shown = gv;
-          } else {
-            gitShared[gk] = gv;
-          }
-        }
-        if (Object.keys(gitShared).length > 0) {
-          shared.git = gitShared;
-        }
-      } else {
-        shared[key] = value;
-      }
-    }
-
-    if (Object.keys(shared).length > 0) _writeJson(sharedPath, shared);
-    if (Object.keys(local).length > 0) _writeJson(localPath, local);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 function cmdConfigEnsureSection(cwd, raw) {
   const sharedPath = getSharedConfigPath(cwd);
   const parentDir = path.dirname(sharedPath);
@@ -183,23 +125,13 @@ function cmdConfigEnsureSection(cwd, raw) {
     error('Failed to create config directory: ' + err.message);
   }
 
-  // Check if config already exists (shared config.json or legacy dgs.config.json)
+  // Check if config already exists
   if (fs.existsSync(sharedPath)) {
     const result = { created: false, reason: 'already_exists' };
     output(result, raw, 'exists');
     return;
   }
 
-  // Check for legacy dgs.config.json and migrate if found
-  const root = getPlanningRoot(cwd);
-  const legacyPath = path.join(root, 'dgs.config.json');
-  if (fs.existsSync(legacyPath)) {
-    _migrateLegacyConfig(cwd);
-    const result = { created: false, reason: 'already_exists' };
-    output(result, raw, 'exists');
-    return;
-  }
-
   // Detect Brave Search API key availability
   const homedir = require('os').homedir();
   const braveKeyFile = path.join(homedir, '.dgs', 'brave_api_key');
@@ -342,15 +274,10 @@ function cmdConfigGet(cwd, keyPath, raw) {
   const shared = _readJsonSafe(getSharedConfigPath(cwd));
   const local = _readJsonSafe(getLocalConfigPath(cwd));
 
-  // Fall back to legacy dgs.config.json if neither new file has data
   let config;
   if (Object.keys(shared).length === 0 && Object.keys(local).length === 0) {
-    const root = getPlanningRoot(cwd);
-    const legacyPath = path.join(root, 'dgs.config.json');
-    config = _readJsonSafe(legacyPath);
-    if (Object.keys(config).length === 0) {
-      error('No config file found at ' + getSharedConfigPath(cwd));
-    }
+    config = {};
+    error('No config file found at ' + getSharedConfigPath(cwd));
   } else {
     config = { ...shared, ...local };
   }
@@ -386,12 +313,8 @@ function cmdConfigGet(cwd, keyPath, raw) {
  * @returns {object} Updated merged config object
  */
 function writeConfigField(cwd, keyPath, value) {
-  // Attempt migration if needed
   const sharedPath = getSharedConfigPath(cwd);
   const localPath = getLocalConfigPath(cwd);
-  if (!fs.existsSync(sharedPath) && !fs.existsSync(localPath)) {
-    _migrateLegacyConfig(cwd);
-  }
 
   // git.sync is a virtual shorthand -- sets both sync_push and sync_pull in shared config
   if (keyPath === 'git.sync') {
@@ -533,9 +456,7 @@ function checkConfigGitignore(cwd) {
       const content = fs.readFileSync(gitignorePath, 'utf-8');
       const lines = content.split('\n').map((l) => l.trim());
       gitignoreCoversReviewKeys = lines.some(
-        (line) =>
-          line === 'review-keys.json' ||
-          line === '.planning/review-keys.json'
+        (line) => line === 'review-keys.json'
       );
     }
   } catch {
@@ -569,8 +490,8 @@ function ensureConfigGitignored(cwd) {
 
   // Check if already present
   const lines = content.split('\n').map((l) => l.trim());
-  const hasLocalConfig = lines.some((line) => line === 'config.local.json' || line === '.planning/config.local.json');
-  const hasReviewKeys = lines.some((line) => line === 'review-keys.json' || line === '.planning/review-keys.json');
+  const hasLocalConfig = lines.some((line) => line === 'config.local.json');
+  const hasReviewKeys = lines.some((line) => line === 'review-keys.json');
 
   if (hasLocalConfig && hasReviewKeys) {
     return { added: false, reason: 'already_present' };
@@ -581,12 +502,10 @@ function ensureConfigGitignored(cwd) {
   if (!hasLocalConfig) {
     entry += '\n# DGS local config (per-machine state)\n';
     entry += 'config.local.json\n';
-    entry += '.planning/config.local.json\n';
   }
   if (!hasReviewKeys) {
     entry += '\n# DGS review keys (contains API keys)\n';
     entry += 'review-keys.json\n';
-    entry += '.planning/review-keys.json\n';
   }
   fs.writeFileSync(gitignorePath, content + entry, 'utf-8');
   return { added: true };

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

@@ -531,7 +531,7 @@ function getMilestoneSummaries(cwd, planningRoot, currentPhaseNum) {
     const { getProjectRoot } = require('./core.cjs');
     projectRoot = getProjectRoot(cwd);
   } catch {
-    projectRoot = path.relative(cwd, planningRoot) || '.planning';
+    projectRoot = path.relative(cwd, planningRoot) || '.';
   }
 
   const phasesDir = path.join(cwd, projectRoot, 'phases');
@@ -818,7 +818,7 @@ function loadTierInternal(tierName, planningRoot, options) {
     let relPath;
     if (entry._fromScope) {
       relPath = entry.path;
-    } else if (entry.path.startsWith(planRootRel) || entry.path.startsWith('.planning')) {
+    } else if (entry.path.startsWith(planRootRel)) {
       // Already relative to cwd
       relPath = entry.path;
     } else {