@ktpartners/dgs-platform 2.6.3 → 2.7.1

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

@@ -626,9 +626,9 @@ describe('requireProjectRoot', () => {
   it('throws PROJECT_NOT_FOUND when v2 install has current_project pointing to nonexistent directory', () => {
     const fixture = createTempProject({ version: 2, project: 'real-project' });
 
-    // Manually update config to point at a nonexistent project
+    // Manually update local config to point at a nonexistent project
     fs.writeFileSync(
-      path.join(fixture.cwd, '.planning', 'config.json'),
+      path.join(fixture.cwd, '.planning', 'config.local.json'),
       JSON.stringify({ current_project: 'ghost-project' })
     );
 
@@ -646,7 +646,7 @@ describe('requireProjectRoot', () => {
     const fixture = createTempProject({ version: 2, project: 'real-project' });
 
     fs.writeFileSync(
-      path.join(fixture.cwd, '.planning', 'config.json'),
+      path.join(fixture.cwd, '.planning', 'config.local.json'),
       JSON.stringify({ current_project: '../etc' })
     );
 
@@ -698,13 +698,13 @@ describe('root layout', () => {
     fixture = null;
   });
 
-  it('loadConfig reads from root-layout dgs.config.json', () => {
+  it('loadConfig reads from root-layout config.json', () => {
     fixture = createTempProject({ layout: 'root', withConfig: { model_profile: 'quality' } });
     const config = loadConfig(fixture.cwd);
     assert.equal(config.model_profile, 'quality');
   });
 
-  it('loadConfig returns defaults when root-layout dgs.config.json has no model_profile', () => {
+  it('loadConfig returns defaults when root-layout config.json has no model_profile', () => {
     fixture = createTempProject({ layout: 'root' });
     const config = loadConfig(fixture.cwd);
     assert.equal(config.model_profile, 'balanced');
@@ -713,7 +713,8 @@ describe('root layout', () => {
   it('getProjectRoot returns . for v1 root-layout', () => {
     // Create a root-layout v1 fixture (no v2 markers with valid headers)
     fixture = createFixture({
-      'dgs.config.json': JSON.stringify({ planningRoot: '.' }),
+      'config.local.json': JSON.stringify({ planningRoot: '.' }),
+      'config.json': JSON.stringify({}),
       'PROJECT.md': '# Project\n',
       'STATE.md': '# State\n',
       'ROADMAP.md': '# Roadmap\n',
@@ -731,7 +732,8 @@ describe('root layout', () => {
 
   it('isV2Install returns false for root-layout v1', () => {
     fixture = createFixture({
-      'dgs.config.json': JSON.stringify({ planningRoot: '.' }),
+      'config.local.json': JSON.stringify({ planningRoot: '.' }),
+      'config.json': JSON.stringify({}),
       'PROJECT.md': '# Project\n',
       'STATE.md': '# State\n',
     });
@@ -741,7 +743,8 @@ describe('root layout', () => {
 
   it('getProjectFolders works in root-layout v2', () => {
     fixture = createFixture({
-      'dgs.config.json': JSON.stringify({ planningRoot: '.', current_project: 'proj-a' }),
+      'config.local.json': JSON.stringify({ planningRoot: '.', current_project: 'proj-a' }),
+      'config.json': JSON.stringify({}),
       'PROJECTS.md': '# Projects\n',
       'REPOS.md': '# Repos\n',
       'projects/proj-a/STATE.md': '# State\n',
@@ -751,8 +754,8 @@ describe('root layout', () => {
     assert.ok(result.includes('proj-a'));
   });
 
-  it('loadConfig reads legacy config.json fallback in root-layout', () => {
-    // Root layout with only config.json (no dgs.config.json) + PROJECT.md auto-detect
+  it('loadConfig reads config.json in root-layout auto-detect', () => {
+    // Root layout with config.json + PROJECT.md auto-detect (no config.local.json needed)
     fixture = createFixture({
       'PROJECT.md': '# Project\n',
       'config.json': JSON.stringify({ model_profile: 'budget' }),
@@ -795,7 +798,7 @@ describe('getProjectDir', () => {
 
 // ─── Config Dual-Read Tests ─────────────────────────────────────────────────
 
-describe('config dual-read', () => {
+describe('config two-file merge', () => {
   let fixture;
 
   afterEach(() => {
@@ -803,20 +806,38 @@ describe('config dual-read', () => {
     fixture = null;
   });
 
-  it('loadConfig reads dgs.config.json when both exist in .planning/', () => {
+  it('loadConfig merges config.json and config.local.json', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ model_profile: 'quality' }),
+      '.planning/config.local.json': JSON.stringify({ current_project: 'my-app' }),
+    });
+    const config = loadConfig(fixture.cwd);
+    assert.equal(config.model_profile, 'quality');
+    assert.equal(config.current_project, 'my-app');
+  });
+
+  it('loadConfig local overrides shared for overlapping keys', () => {
     fixture = createFixture({
-      '.planning/dgs.config.json': JSON.stringify({ model_profile: 'quality' }),
       '.planning/config.json': JSON.stringify({ model_profile: 'speed' }),
+      '.planning/config.local.json': JSON.stringify({ model_profile: 'quality' }),
     });
     const config = loadConfig(fixture.cwd);
     assert.equal(config.model_profile, 'quality');
   });
 
-  it('loadConfig falls back to config.json when no dgs.config.json in .planning/', () => {
+  it('loadConfig reads config.json when no config.local.json exists', () => {
     fixture = createFixture({
       '.planning/config.json': JSON.stringify({ model_profile: 'speed' }),
     });
     const config = loadConfig(fixture.cwd);
     assert.equal(config.model_profile, 'speed');
   });
+
+  it('loadConfig falls back to legacy dgs.config.json', () => {
+    fixture = createFixture({
+      '.planning/dgs.config.json': JSON.stringify({ model_profile: 'quality' }),
+    });
+    const config = loadConfig(fixture.cwd);
+    assert.equal(config.model_profile, 'quality');
+  });
 });

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

@@ -9,6 +9,7 @@ const { loadConfig, resolveModelInternal, findPhaseInternal, getRoadmapPhaseInte
 const { requireGitIdentity, formatAuthorString } = require('./identity.cjs');
 const { getPlanningRoot, PROJECTS_DIR } = require('./paths.cjs');
 const { parseReposMd, validateReposMdEager } = require('./repos.cjs');
+const { getCadence } = require('./sync.cjs');
 
 /**
  * Safely resolve the current git author string.
@@ -163,6 +164,10 @@ function cmdInitExecutePhase(cwd, phase, raw) {
     milestone_branch_template: config.milestone_branch_template,
     verifier_enabled: config.verifier,
     base_branch: config.base_branch,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('execute-phase').pull,
+    cadence_push: getCadence('execute-phase').push,
 
     // Phase info
     phase_found: !!phaseInfo,
@@ -208,11 +213,11 @@ function cmdInitExecutePhase(cwd, phase, raw) {
     // File existence
     state_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'STATE.md')) : false,
     roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : false,
-    config_exists: pathExistsInternal(cwd, path.join(planRootRel, 'dgs.config.json')),
+    config_exists: pathExistsInternal(cwd, path.join(planRootRel, 'config.json')),
     // File paths (project-qualified)
     state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
     roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
-    config_path: path.join(planRootRel, 'dgs.config.json'),
+    config_path: path.join(planRootRel, 'config.json'),
     project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
     debug_dir: ctx.root ? path.join(ctx.root, 'debug') : path.join(planRootRel, 'debug'),
 
@@ -258,6 +263,10 @@ function cmdInitPlanPhase(cwd, phase, raw) {
     plan_checker_enabled: config.plan_checker,
     nyquist_validation_enabled: config.nyquist_validation,
     commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('plan-phase').pull,
+    cadence_push: getCadence('plan-phase').push,
 
     // Phase info
     phase_found: !!phaseInfo,
@@ -357,6 +366,10 @@ function cmdInitNewProject(cwd, raw) {
 
     // Config
     commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('new-project').pull,
+    cadence_push: getCadence('new-project').push,
 
     // Existing state (project-qualified)
     project_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'PROJECT.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'PROJECT.md')),
@@ -411,6 +424,10 @@ function cmdInitNewMilestone(cwd, raw) {
     // Config
     commit_docs: config.commit_docs,
     research_enabled: config.research,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('new-milestone').pull,
+    cadence_push: getCadence('new-milestone').push,
 
     // Current milestone
     current_milestone: milestone.version,
@@ -470,6 +487,10 @@ function cmdInitQuick(cwd, description, raw) {
 
     // Config
     commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('quick').pull,
+    cadence_push: getCadence('quick').push,
 
     // Quick task info
     quick_id: quickId,
@@ -535,6 +556,10 @@ function cmdInitResume(cwd, raw) {
 
     // Config
     commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('resume-work').pull,
+    cadence_push: getCadence('resume-work').push,
 
     // v2 context
     dgs_mode: ctx.dgs_mode,
@@ -563,6 +588,10 @@ function cmdInitVerifyWork(cwd, phase, raw) {
 
     // Config
     commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('verify-work').pull,
+    cadence_push: getCadence('verify-work').push,
 
     // Phase info
     phase_found: !!phaseInfo,
@@ -602,6 +631,10 @@ function cmdInitAuditPhase(cwd, phase, raw) {
 
     // Config
     commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('audit-phase').pull,
+    cadence_push: getCadence('audit-phase').push,
 
     // Phase info
     phase_found: !!phaseInfo,
@@ -625,11 +658,12 @@ function cmdInitAuditPhase(cwd, phase, raw) {
   output(result, raw);
 }
 
-function cmdInitPhaseOp(cwd, phase, raw) {
+function cmdInitPhaseOp(cwd, phase, raw, workflow) {
   const config = loadConfig(cwd);
   const ctx = resolveProjectContext(cwd);
   const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
   let phaseInfo = findPhaseInternal(cwd, phase);
+  const cadence = getCadence(workflow || 'plan-phase');
 
   // Fallback to ROADMAP.md if no directory exists (e.g., Plans: TBD)
   if (!phaseInfo) {
@@ -656,6 +690,10 @@ function cmdInitPhaseOp(cwd, phase, raw) {
     // Config
     commit_docs: config.commit_docs,
     brave_search: config.brave_search,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: cadence.pull,
+    cadence_push: cadence.push,
 
     // Phase info
     phase_found: !!phaseInfo,
@@ -720,7 +758,7 @@ function cmdInitPhaseOp(cwd, phase, raw) {
   output(result, raw);
 }
 
-function cmdInitTodos(cwd, area, raw) {
+function cmdInitTodos(cwd, area, raw, workflow) {
   const config = loadConfig(cwd);
   const ctx = resolveProjectContext(cwd);
   const now = new Date();
@@ -762,6 +800,10 @@ function cmdInitTodos(cwd, area, raw) {
   const result = {
     // Config
     commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence(workflow || 'check-todos').pull,
+    cadence_push: getCadence(workflow || 'check-todos').push,
 
     // Timestamps
     date: now.toISOString().split('T')[0],
@@ -795,11 +837,12 @@ function cmdInitTodos(cwd, area, raw) {
   output(result, raw);
 }
 
-function cmdInitMilestoneOp(cwd, raw) {
+function cmdInitMilestoneOp(cwd, raw, workflow) {
   const config = loadConfig(cwd);
   const ctx = resolveProjectContext(cwd);
   const milestone = getMilestoneInfo(cwd);
   const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+  const cadence = getCadence(workflow || 'complete-milestone');
 
   // Count phases (project-qualified)
   let phaseCount = 0;
@@ -838,6 +881,10 @@ function cmdInitMilestoneOp(cwd, raw) {
     branching_strategy: config.branching_strategy,
     phase_branch_template: config.phase_branch_template,
     milestone_branch_template: config.milestone_branch_template,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: cadence.pull,
+    cadence_push: cadence.push,
 
     // Current milestone
     milestone_version: milestone.version,
@@ -943,6 +990,10 @@ function cmdInitMapCodebase(cwd, onlyRepo, raw) {
     commit_docs: config.commit_docs,
     search_gitignored: config.search_gitignored,
     parallelization: config.parallelization,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('map-codebase').pull,
+    cadence_push: getCadence('map-codebase').push,
 
     // Paths — codebase stays product-level
     codebase_dir: path.join(planRootRel, 'codebase'),
@@ -1056,6 +1107,10 @@ function cmdInitProgress(cwd, raw) {
 
     // Config
     commit_docs: config.commit_docs,
+    sync_push: config.sync_push,
+    sync_pull: config.sync_pull,
+    cadence_pull: getCadence('progress').pull,
+    cadence_push: getCadence('progress').push,
 
     // Milestone
     milestone_version: milestone.version,
@@ -1081,7 +1136,7 @@ function cmdInitProgress(cwd, raw) {
     state_path: statePath,
     roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
     project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
-    config_path: path.join(planRootRel, 'dgs.config.json'),
+    config_path: path.join(planRootRel, 'config.json'),
 
     // Author
     author: resolveAuthorSafe(cwd),

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

@@ -164,8 +164,8 @@ describe('v1 mode: init execute-phase', () => {
     assert.equal(result.roadmap_path, '.planning/ROADMAP.md');
   });
 
-  it('returns config_path as .planning/dgs.config.json (always product-level)', () => {
-    assert.equal(result.config_path, '.planning/dgs.config.json');
+  it('returns config_path as .planning/config.json (always product-level)', () => {
+    assert.equal(result.config_path, '.planning/config.json');
   });
 
   it('returns project_path as .planning/PROJECT.md', () => {
@@ -248,7 +248,7 @@ describe('v1 mode: init progress', () => {
     assert.equal(result.state_path, '.planning/STATE.md');
     assert.equal(result.roadmap_path, '.planning/ROADMAP.md');
     assert.equal(result.project_path, '.planning/PROJECT.md');
-    assert.equal(result.config_path, '.planning/dgs.config.json');
+    assert.equal(result.config_path, '.planning/config.json');
   });
 
   it('returns dgs_mode v1', () => {
@@ -404,7 +404,7 @@ describe('v2 mode with project: init execute-phase', () => {
   });
 
   it('config_path stays product-level', () => {
-    assert.equal(result.config_path, '.planning/dgs.config.json');
+    assert.equal(result.config_path, '.planning/config.json');
   });
 
   it('returns project-qualified project_path', () => {
@@ -482,7 +482,7 @@ describe('v2 mode with project: init progress', () => {
   });
 
   it('config_path stays product-level', () => {
-    assert.equal(result.config_path, '.planning/dgs.config.json');
+    assert.equal(result.config_path, '.planning/config.json');
   });
 
   it('phase directory is project-qualified', () => {
@@ -505,12 +505,12 @@ describe('v2 mode with project: init todos', () => {
     fixture.cleanup();
   });
 
-  it('returns project-qualified pending_dir', () => {
-    assert.equal(result.pending_dir, path.join('.planning', 'projects', 'test-project', 'todos', 'pending'));
+  it('returns product-level pending_dir', () => {
+    assert.equal(result.pending_dir, path.join('.planning', 'todos', 'pending'));
   });
 
-  it('returns project-qualified completed_dir', () => {
-    assert.equal(result.completed_dir, path.join('.planning', 'projects', 'test-project', 'todos', 'completed'));
+  it('returns product-level completed_dir', () => {
+    assert.equal(result.completed_dir, path.join('.planning', 'todos', 'completed'));
   });
 
   it('returns dgs_mode v2', () => {

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

@@ -138,7 +138,7 @@ function createBackupTag(cwd) {
 // ─── Migration Planning ─────────────────────────────────────────────────────
 
 // Directories to move (project-level, order: directories first)
-const DIRS_TO_MOVE = ['phases', 'research', 'todos', 'quick', 'debug'];
+const DIRS_TO_MOVE = ['phases', 'research', 'quick', 'debug'];
 
 // Files to move (project-level)
 const FILES_TO_MOVE = ['PROJECT.md', 'REQUIREMENTS.md', 'ROADMAP.md', 'STATE.md'];

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

@@ -293,12 +293,13 @@ describe('migrateV1ToV2', () => {
     assert.ok(content.startsWith('# Projects'));
   });
 
-  it('sets current_project in config.json', () => {
+  it('sets current_project in config.local.json', () => {
     createV1Install(tmpDir, 'Test App');
     migrateV1ToV2(tmpDir, 'test-app');
 
-    const configPath = path.join(tmpDir, '.planning', 'dgs.config.json');
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    const localConfigPath = path.join(tmpDir, '.planning', 'config.local.json');
+    assert.ok(fs.existsSync(localConfigPath), 'config.local.json should exist');
+    const config = JSON.parse(fs.readFileSync(localConfigPath, 'utf-8'));
     assert.strictEqual(config.current_project, 'test-app');
   });
 
@@ -326,13 +327,13 @@ describe('migrateV1ToV2', () => {
     assert.ok(log.includes('rename'));
   });
 
-  it('moves todos/ directory if it exists', () => {
+  it('preserves todos/ at product level (not moved to project)', () => {
     writeFile(tmpDir, '.planning/todos/pending/task1.md', '# Todo 1\n');
     createV1Install(tmpDir, 'Test App');
     migrateV1ToV2(tmpDir, 'test-app');
 
-    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'todos', 'pending', 'task1.md')));
-    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'todos')));
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'todos', 'pending', 'task1.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'todos')));
   });
 
   it('moves quick/ directory if it exists', () => {
@@ -406,18 +407,15 @@ describe('collectMigrationMoves', () => {
     writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
     writeFile(tmpDir, '.planning/phases/01-setup/01-01-PLAN.md', '---\n---\n');
     writeFile(tmpDir, '.planning/research/notes.md', '# Notes\n');
-    writeFile(tmpDir, '.planning/todos/pending/task.md', '# Todo\n');
 
     const { moves } = collectMigrationMoves(tmpDir, 'test');
 
     const phasesMove = moves.find(m => m.relSource.endsWith('phases'));
     const researchMove = moves.find(m => m.relSource.endsWith('research'));
-    const todosMove = moves.find(m => m.relSource.endsWith('todos'));
     const projectMove = moves.find(m => m.relSource.endsWith('PROJECT.md'));
 
     assert.strictEqual(phasesMove.isDir, true);
     assert.strictEqual(researchMove.isDir, true);
-    assert.strictEqual(todosMove.isDir, true);
     assert.strictEqual(projectMove.isDir, false);
   });
 });

package/deliver-great-systems/bin/lib/path-audit.test.cjs

@@ -41,7 +41,7 @@ const COMPREHENSIVE_PATTERN = /\.planning\//;
  * multi-project install because they resolve to the root instead of
  * .planning/<project>/<path>.
  */
-const PROJECT_SCOPED_PATTERN = /\.planning\/(?:STATE|ROADMAP|PROJECT(?!S\.md)|REQUIREMENTS|phases|archive|quick|todos|debug|research)/;
+const PROJECT_SCOPED_PATTERN = /\.planning\/(?:STATE|ROADMAP|PROJECT(?!S\.md)|REQUIREMENTS|phases|archive|quick|debug|research)/;
 
 /**
  * Workflow files allowlisted from comprehensive .planning/ scanning.

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

@@ -1,19 +1,20 @@
 /**
- * paths.cjs — Planning root detection and path constants
+ * paths.cjs -- Planning root detection and path constants
  *
  * LEAF MODULE: Zero DGS imports. Uses only Node.js built-in fs and path.
  * This module sits at the bottom of the dependency graph to prevent
  * circular dependencies with core.cjs and config.cjs.
  *
  * Exports:
- *   getPlanningRoot(cwd) — Returns absolute path to planning root
- *   getPaths(cwd)        — Returns frozen PATHS object with all standard paths
- *   initPaths(cwd)       — Alias for getPaths (explicit cache population)
- *   resetPaths()         — Clears the cwd-keyed cache (for test isolation)
+ *   getPlanningRoot(cwd) -- Returns absolute path to planning root
+ *   getPaths(cwd)        -- Returns frozen PATHS object with all standard paths
+ *   initPaths(cwd)       -- Alias for getPaths (explicit cache population)
+ *   resetPaths()         -- Clears the cwd-keyed cache (for test isolation)
  *
  * Detection cascade (getPlanningRoot):
- *   1. .planning/dgs.config.json or .planning/config.json exists -> .planning/ layout
- *   2. dgs.config.json at root with planningRoot: '.' -> root layout
+ *   1. .planning/config.json or .planning/config.local.json exists -> .planning/ layout
+ *   2. config.local.json at root with planningRoot: '.' -> root layout
+ *      (legacy fallback: dgs.config.json at root with planningRoot: '.')
  *   3. dgs.config.json at root without planningRoot: '.' -> .planning/ layout
  *   4. PROJECT.md at root AND no .planning/ directory -> root layout (auto-detect)
  *   5. No signals -> .planning/ layout (default)
@@ -26,7 +27,7 @@ const _cache = new Map();
 
 /**
  * The canonical directory name for the projects container.
- * Single source of truth — all project path construction should reference
+ * Single source of truth -- all project path construction should reference
  * this constant instead of using the string literal 'projects'.
  */
 const PROJECTS_DIR = 'projects';
@@ -41,32 +42,40 @@ function getPlanningRoot(cwd) {
   const resolved = path.resolve(cwd || process.cwd());
   const dotPlanning = path.join(resolved, '.planning');
 
-  // Step 1: .planning/ layout — config files inside .planning/
+  // Step 1: .planning/ layout -- config files inside .planning/
   if (
-    fs.existsSync(path.join(dotPlanning, 'dgs.config.json')) ||
-    fs.existsSync(path.join(dotPlanning, 'config.json'))
+    fs.existsSync(path.join(dotPlanning, 'config.json')) ||
+    fs.existsSync(path.join(dotPlanning, 'config.local.json')) ||
+    fs.existsSync(path.join(dotPlanning, 'dgs.config.json'))
   ) {
     return dotPlanning;
   }
 
-  // Step 2: Root layout — dgs.config.json at repo root
+  // Step 2: Root layout -- config.local.json at repo root with planningRoot: '.'
+  const rootLocalConfigPath = path.join(resolved, 'config.local.json');
+  if (fs.existsSync(rootLocalConfigPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(rootLocalConfigPath, 'utf-8'));
+      if (config.planningRoot === '.') return resolved;
+    } catch {
+      // Malformed JSON -- fall through
+    }
+  }
+
+  // Step 2b: Legacy fallback -- dgs.config.json at repo root
   const rootConfigPath = path.join(resolved, 'dgs.config.json');
   if (fs.existsSync(rootConfigPath)) {
     try {
       const config = JSON.parse(fs.readFileSync(rootConfigPath, 'utf-8'));
       if (config.planningRoot === '.') return resolved;
     } catch {
-      // Malformed JSON — fall through to next check
+      // Malformed JSON -- fall through to next check
     }
     // dgs.config.json exists but no planningRoot: '.' or malformed
-    // If malformed, we already fell through the try/catch
-    // If valid but no planningRoot: '.', return .planning/
-    // We need to distinguish: if we got here via catch, we should fall through
-    // If we got here via the normal flow (no planningRoot), return .planning/
     return dotPlanning;
   }
 
-  // Step 3: Auto-detect root layout — PROJECT.md at root, no .planning/ dir
+  // Step 3: Auto-detect root layout -- PROJECT.md at root, no .planning/ dir
   if (
     fs.existsSync(path.join(resolved, 'PROJECT.md')) &&
     !fs.existsSync(dotPlanning)
@@ -74,7 +83,7 @@ function getPlanningRoot(cwd) {
     return resolved;
   }
 
-  // Step 4: Default — .planning/
+  // Step 4: Default -- .planning/
   return dotPlanning;
 }
 
@@ -101,8 +110,9 @@ function getPaths(cwd) {
     DOCS: path.join(root, 'docs'),
     CODEBASE: path.join(root, 'codebase'),
     MILESTONES: path.join(root, 'milestones'),
-    CONFIG: path.join(root, 'dgs.config.json'),
-    CONFIG_LEGACY: path.join(root, 'config.json'),
+    CONFIG: path.join(root, 'config.json'),
+    CONFIG_LOCAL: path.join(root, 'config.local.json'),
+    CONFIG_LEGACY: path.join(root, 'dgs.config.json'),
     QUICK: path.join(root, 'quick'),
     TODOS: path.join(root, 'todos'),
     RESEARCH: path.join(root, 'research'),
@@ -118,7 +128,7 @@ function getPaths(cwd) {
 
 /**
  * Populate the cache for the given cwd and return the PATHS object.
- * Alias for getPaths — provides explicit intent for test setup.
+ * Alias for getPaths -- provides explicit intent for test setup.
  *
  * @param {string} [cwd] - Working directory (defaults to process.cwd())
  * @returns {Readonly<Object>} Frozen PATHS object

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

@@ -185,11 +185,11 @@ describe('PATHS object shape', () => {
 
   const EXPECTED_KEYS = [
     'ROOT', 'PHASES', 'IDEAS', 'SPECS', 'JOBS', 'DOCS',
-    'CODEBASE', 'MILESTONES', 'CONFIG', 'CONFIG_LEGACY',
+    'CODEBASE', 'MILESTONES', 'CONFIG', 'CONFIG_LOCAL', 'CONFIG_LEGACY',
     'QUICK', 'TODOS', 'RESEARCH', 'DEBUG', 'ARCHIVE', 'PROJECTS', 'LAYOUT',
   ];
 
-  it('returns object with all 17 expected keys', () => {
+  it('returns object with all 18 expected keys', () => {
     cwd = makeTempDir();
     fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
     fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
@@ -235,22 +235,32 @@ describe('PATHS object shape', () => {
     }
   });
 
-  it('CONFIG ends with dgs.config.json', () => {
+  it('CONFIG ends with config.json', () => {
     cwd = makeTempDir();
     fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
     fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
 
     const paths = getPaths(cwd);
-    assert.ok(paths.CONFIG.endsWith('dgs.config.json'));
+    assert.ok(paths.CONFIG.endsWith('config.json'));
+    assert.ok(!paths.CONFIG.endsWith('dgs.config.json'));
   });
 
-  it('CONFIG_LEGACY ends with config.json', () => {
+  it('CONFIG_LOCAL ends with config.local.json', () => {
     cwd = makeTempDir();
     fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
     fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
 
     const paths = getPaths(cwd);
-    assert.ok(paths.CONFIG_LEGACY.endsWith('config.json'));
+    assert.ok(paths.CONFIG_LOCAL.endsWith('config.local.json'));
+  });
+
+  it('CONFIG_LEGACY ends with dgs.config.json', () => {
+    cwd = makeTempDir();
+    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
+    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
+
+    const paths = getPaths(cwd);
+    assert.ok(paths.CONFIG_LEGACY.endsWith('dgs.config.json'));
   });
 
   it('subdirectory paths are derived from ROOT', () => {

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

@@ -14,7 +14,7 @@ const { getPlanningRoot } = require('./paths.cjs');
 
 // ─── Constants ──────────────────────────────────────────────────────────────
 
-const STANDARD_DIRS = ['phases', 'research', 'todos', 'quick', 'debug'];
+const STANDARD_DIRS = ['phases', 'research', 'quick', 'debug'];
 
 // ─── Project Subfolder Creation ─────────────────────────────────────────────
 

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

@@ -64,7 +64,7 @@ describe('createProjectSubfolder', () => {
 
   it('creates all required subdirectories', () => {
     createProjectSubfolder(tmpDir, 'auth-overhaul', 'Auth Overhaul');
-    const expectedDirs = ['phases', 'research', 'todos', 'quick', 'debug'];
+    const expectedDirs = ['phases', 'research', 'quick', 'debug'];
     for (const dir of expectedDirs) {
       assert.ok(
         fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'auth-overhaul', dir)),