@ktpartners/dgs-platform 2.6.2

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

@@ -0,0 +1,822 @@
+/**
+ * Tests for core.cjs v2 path resolution functions
+ *
+ * Uses Node.js built-in test runner (node:test) and assert (node:assert).
+ * Each test creates an isolated temp directory fixture and cleans up after.
+ */
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { createFixture, createTempProject } = require('./test-helpers.cjs');
+
+// Import the functions under test
+const {
+  resolveProjectPath,
+  getProjectRoot,
+  requireProjectRoot,
+  isV2Install,
+  getProjectFolders,
+  getV2Hint,
+  loadConfig,
+  isProjectCompleted,
+  getProjectDir,
+} = require('./core.cjs');
+
+// ─── v1 Mode Tests ────────────────────────────────────────────────────────────
+
+describe('v1 mode (no v2 markers)', () => {
+  let fixture;
+
+  beforeEach(() => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/ROADMAP.md': '# Roadmap',
+      '.planning/phases/': null,
+    });
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('getProjectRoot returns .planning', () => {
+    const result = getProjectRoot(fixture.cwd);
+    assert.equal(result, '.planning');
+  });
+
+  it('resolveProjectPath with relative path returns .planning/<path>', () => {
+    const result = resolveProjectPath(fixture.cwd, 'STATE.md');
+    assert.equal(result, path.join('.planning', 'STATE.md'));
+  });
+
+  it('resolveProjectPath with nested path returns correct path', () => {
+    const result = resolveProjectPath(fixture.cwd, 'phases/01-foo');
+    assert.equal(result, path.join('.planning', 'phases', '01-foo'));
+  });
+
+  it('resolveProjectPath without second arg returns .planning', () => {
+    const result = resolveProjectPath(fixture.cwd);
+    assert.equal(result, '.planning');
+  });
+
+  it('isV2Install returns false', () => {
+    const result = isV2Install(fixture.cwd);
+    assert.equal(result, false);
+  });
+});
+
+// ─── v2 Mode with current_project Tests ───────────────────────────────────────
+
+describe('v2 mode with current_project', () => {
+  let fixture;
+
+  beforeEach(() => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'auth-overhaul' }),
+      '.planning/PROJECTS.md': '# Projects\n\n| Project | Status |\n',
+      '.planning/REPOS.md': '# Repos\n\n| Name | Path |\n',
+      '.planning/projects/auth-overhaul/STATE.md': '# State',
+      '.planning/projects/auth-overhaul/ROADMAP.md': '# Roadmap',
+      '.planning/projects/auth-overhaul/phases/': null,
+    });
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('getProjectRoot returns .planning/projects/<project>', () => {
+    const result = getProjectRoot(fixture.cwd);
+    assert.equal(result, path.join('.planning', 'projects', 'auth-overhaul'));
+  });
+
+  it('resolveProjectPath with STATE.md returns project-qualified path', () => {
+    const result = resolveProjectPath(fixture.cwd, 'STATE.md');
+    assert.equal(result, path.join('.planning', 'projects', 'auth-overhaul', 'STATE.md'));
+  });
+
+  it('resolveProjectPath with nested path returns project-qualified path', () => {
+    const result = resolveProjectPath(fixture.cwd, 'phases/01-foo');
+    assert.equal(result, path.join('.planning', 'projects', 'auth-overhaul', 'phases', '01-foo'));
+  });
+});
+
+// ─── v2 Mode without current_project (guard trigger) Tests ────────────────────
+
+describe('v2 mode without current_project (guard trigger)', () => {
+  it('throws NO_CURRENT_PROJECT_V2 when PROJECTS.md exists with valid header', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECTS.md': '# Projects\n\n| Project | Status |\n',
+    });
+
+    try {
+      assert.throws(
+        () => getProjectRoot(fixture.cwd),
+        (err) => err.message === 'NO_CURRENT_PROJECT_V2'
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('throws NO_CURRENT_PROJECT_V2 when REPOS.md exists with valid header', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/REPOS.md': '# Repos\n\n| Name | Path |\n',
+    });
+
+    try {
+      assert.throws(
+        () => getProjectRoot(fixture.cwd),
+        (err) => err.message === 'NO_CURRENT_PROJECT_V2'
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});
+
+// ─── Strict v2 Marker Validation Tests ────────────────────────────────────────
+
+describe('strict v2 marker validation', () => {
+  it('isV2Install returns false when PROJECTS.md has non-DGS content', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECTS.md': 'Shopping List\n- apples\n- bananas',
+    });
+
+    try {
+      assert.equal(isV2Install(fixture.cwd), false);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('isV2Install returns true when PROJECTS.md starts with # Projects', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECTS.md': '# Projects\n\n## Active\n',
+    });
+
+    try {
+      assert.equal(isV2Install(fixture.cwd), true);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('isV2Install returns true when REPOS.md starts with # Repos', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/REPOS.md': '# Repos\n\n| Name | Path |\n',
+    });
+
+    try {
+      assert.equal(isV2Install(fixture.cwd), true);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('isV2Install returns false when neither file exists', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    try {
+      assert.equal(isV2Install(fixture.cwd), false);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});
+
+// ─── Project Directory Validation Tests ───────────────────────────────────────
+
+describe('project directory validation', () => {
+  it('throws PROJECT_NOT_FOUND when current_project dir does not exist', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'ghost-project' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+    });
+
+    try {
+      assert.throws(
+        () => getProjectRoot(fixture.cwd),
+        (err) => err.message.includes('PROJECT_NOT_FOUND')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});
+
+// ─── Completed Project Guards Tests ───────────────────────────────────────────
+
+describe('completed project guards', () => {
+  it('getProjectRoot throws PROJECT_COMPLETED when project STATUS is completed', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'done-proj' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/projects/done-proj/STATE.md': '# Project State\n\nStatus: completed\nCompleted: 2026-02-20\n',
+    });
+
+    try {
+      assert.throws(
+        () => getProjectRoot(fixture.cwd),
+        (err) => err.message.includes('PROJECT_COMPLETED')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('getProjectRoot throws PROJECT_COMPLETED for case-insensitive status (Completed)', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'done-proj' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/projects/done-proj/STATE.md': '# Project State\n\nStatus: Completed\n',
+    });
+
+    try {
+      assert.throws(
+        () => getProjectRoot(fixture.cwd),
+        (err) => err.message.includes('PROJECT_COMPLETED')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('getProjectRoot does NOT throw for active project', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'active-proj' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/projects/active-proj/STATE.md': '# Project State\n\nStatus: Active\n',
+    });
+
+    try {
+      const result = getProjectRoot(fixture.cwd);
+      assert.equal(result, path.join('.planning', 'projects', 'active-proj'));
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('getProjectRoot does NOT throw when STATE.md is missing', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'no-state-proj' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/projects/no-state-proj/': null,
+    });
+
+    try {
+      const result = getProjectRoot(fixture.cwd);
+      assert.equal(result, path.join('.planning', 'projects', 'no-state-proj'));
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('requireProjectRoot propagates PROJECT_COMPLETED', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'done-proj' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/projects/done-proj/STATE.md': '# Project State\n\nStatus: completed\n',
+    });
+
+    try {
+      assert.throws(
+        () => requireProjectRoot(fixture.cwd),
+        (err) => err.message.includes('PROJECT_COMPLETED')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('resolveProjectPath throws PROJECT_COMPLETED for completed project', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'done-proj' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/projects/done-proj/STATE.md': '# Project State\n\nStatus: completed\n',
+    });
+
+    try {
+      assert.throws(
+        () => resolveProjectPath(fixture.cwd, 'STATE.md'),
+        (err) => err.message.includes('PROJECT_COMPLETED')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('isProjectCompleted returns true for completed project', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/projects/done-proj/STATE.md': '# Project State\n\nStatus: completed\n',
+    });
+
+    try {
+      assert.equal(isProjectCompleted(fixture.cwd, 'done-proj'), true);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('isProjectCompleted returns false for active project', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/projects/active-proj/STATE.md': '# Project State\n\nStatus: Active\n',
+    });
+
+    try {
+      assert.equal(isProjectCompleted(fixture.cwd, 'active-proj'), false);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('isProjectCompleted returns false when STATE.md missing', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/projects/no-state-proj/': null,
+    });
+
+    try {
+      assert.equal(isProjectCompleted(fixture.cwd, 'no-state-proj'), false);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});
+
+// ─── getProjectFolders Tests ──────────────────────────────────────────────────
+
+describe('getProjectFolders', () => {
+  it('returns empty array for v1 install', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/phases/': null,
+    });
+
+    try {
+      const result = getProjectFolders(fixture.cwd);
+      assert.deepEqual(result, []);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('returns project folder names from projects/ directory', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/projects/auth-overhaul/STATE.md': '# State',
+      '.planning/projects/dashboard-v2/STATE.md': '# State',
+      '.planning/phases/': null,
+      '.planning/codebase/': null,
+      '.planning/archive/': null,
+      '.planning/todos/': null,
+    });
+
+    try {
+      const result = getProjectFolders(fixture.cwd);
+      assert.deepEqual(result, ['auth-overhaul', 'dashboard-v2']);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('only includes directories containing STATE.md', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/projects/valid-project/STATE.md': '# State',
+      '.planning/projects/empty-folder/': null,
+    });
+
+    try {
+      const result = getProjectFolders(fixture.cwd);
+      assert.deepEqual(result, ['valid-project']);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('excludes dot-directories', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/projects/.hidden/STATE.md': '# State',
+      '.planning/projects/real-project/STATE.md': '# State',
+    });
+
+    try {
+      const result = getProjectFolders(fixture.cwd);
+      assert.deepEqual(result, ['real-project']);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('returns empty array when .planning does not exist', () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-test-'));
+    try {
+      const result = getProjectFolders(cwd);
+      assert.deepEqual(result, []);
+    } finally {
+      fs.rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('returns empty array when projects/ directory does not exist', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECTS.md': '# Projects\n',
+      '.planning/phases/': null,
+    });
+
+    try {
+      const result = getProjectFolders(fixture.cwd);
+      assert.deepEqual(result, []);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});
+
+// ─── getV2Hint Tests ──────────────────────────────────────────────────────────
+
+describe('getV2Hint', () => {
+  it('returns hint text when v2_hint_shown is falsy', () => {
+    const config = {};
+    const result = getV2Hint(null, config);
+    assert.equal(typeof result, 'string');
+    assert.ok(result.includes('v2'));
+    assert.ok(result.includes('/dgs:init-product'));
+  });
+
+  it('returns null when v2_hint_shown is true', () => {
+    const config = { v2_hint_shown: true };
+    const result = getV2Hint(null, config);
+    assert.equal(result, null);
+  });
+});
+
+// ─── Edge Cases ───────────────────────────────────────────────────────────────
+
+describe('edge cases', () => {
+  it('resolveProjectPath with empty string returns project root', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    try {
+      const result = resolveProjectPath(fixture.cwd, '');
+      assert.equal(result, '.planning');
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('getProjectRoot handles missing .planning gracefully', () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-test-'));
+    try {
+      // Should not crash — returns .planning (v1 fallback since no markers)
+      const result = getProjectRoot(cwd);
+      assert.equal(result, '.planning');
+    } finally {
+      fs.rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('treats empty string current_project as unset', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: '' }),
+    });
+
+    try {
+      // Should return .planning (v1 fallback), not .planning/
+      const result = getProjectRoot(fixture.cwd);
+      assert.equal(result, '.planning');
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('rejects current_project with path traversal (..)', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: '../etc' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+    });
+
+    try {
+      assert.throws(
+        () => getProjectRoot(fixture.cwd),
+        (err) => err.message.includes('INVALID_PROJECT_NAME')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('rejects current_project with forward slash', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'foo/bar' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+    });
+
+    try {
+      assert.throws(
+        () => getProjectRoot(fixture.cwd),
+        (err) => err.message.includes('INVALID_PROJECT_NAME')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('rejects current_project with backslash', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: 'foo\\bar' }),
+      '.planning/PROJECTS.md': '# Projects\n',
+    });
+
+    try {
+      assert.throws(
+        () => getProjectRoot(fixture.cwd),
+        (err) => err.message.includes('INVALID_PROJECT_NAME')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});
+
+// ─── requireProjectRoot Tests ─────────────────────────────────────────────────
+
+describe('requireProjectRoot', () => {
+  it('returns .planning/projects/<project> when v2 install has current_project set and directory exists', () => {
+    const fixture = createTempProject({ version: 2, project: 'my-app' });
+
+    try {
+      const result = requireProjectRoot(fixture.cwd);
+      assert.equal(result, path.join('.planning', 'projects', 'my-app'));
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('throws NO_CURRENT_PROJECT_V2 when v2 install has no current_project', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECTS.md': '# Projects\n\n| Project | Status |\n',
+    });
+
+    try {
+      assert.throws(
+        () => requireProjectRoot(fixture.cwd),
+        (err) => err.message === 'NO_CURRENT_PROJECT_V2'
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('throws NO_CURRENT_PROJECT_V2 when v2 install has empty string current_project', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: '' }),
+      '.planning/PROJECTS.md': '# Projects\n\n| Project | Status |\n',
+    });
+
+    try {
+      assert.throws(
+        () => requireProjectRoot(fixture.cwd),
+        (err) => err.message === 'NO_CURRENT_PROJECT_V2'
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('throws NO_CURRENT_PROJECT_V2 when v2 install has whitespace-only current_project', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ current_project: '   ' }),
+      '.planning/PROJECTS.md': '# Projects\n\n| Project | Status |\n',
+    });
+
+    try {
+      assert.throws(
+        () => requireProjectRoot(fixture.cwd),
+        (err) => err.message === 'NO_CURRENT_PROJECT_V2'
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  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
+    fs.writeFileSync(
+      path.join(fixture.cwd, '.planning', 'config.json'),
+      JSON.stringify({ current_project: 'ghost-project' })
+    );
+
+    try {
+      assert.throws(
+        () => requireProjectRoot(fixture.cwd),
+        (err) => err.message.includes('PROJECT_NOT_FOUND')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('throws INVALID_PROJECT_NAME when current_project contains ..', () => {
+    const fixture = createTempProject({ version: 2, project: 'real-project' });
+
+    fs.writeFileSync(
+      path.join(fixture.cwd, '.planning', 'config.json'),
+      JSON.stringify({ current_project: '../etc' })
+    );
+
+    try {
+      assert.throws(
+        () => requireProjectRoot(fixture.cwd),
+        (err) => err.message.includes('INVALID_PROJECT_NAME')
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('returns .planning for v1 install (backward compatible)', () => {
+    const fixture = createTempProject({ version: 1 });
+
+    try {
+      const result = requireProjectRoot(fixture.cwd);
+      assert.equal(result, '.planning');
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('resolveProjectPath throws NO_CURRENT_PROJECT_V2 on v2 install without current_project (guard propagates)', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECTS.md': '# Projects\n\n| Project | Status |\n',
+    });
+
+    try {
+      assert.throws(
+        () => resolveProjectPath(fixture.cwd, 'STATE.md'),
+        (err) => err.message === 'NO_CURRENT_PROJECT_V2'
+      );
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});
+
+// ─── Root Layout Tests ───────────────────────────────────────────────────────
+
+describe('root layout', () => {
+  let fixture;
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+    fixture = null;
+  });
+
+  it('loadConfig reads from root-layout dgs.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', () => {
+    fixture = createTempProject({ layout: 'root' });
+    const config = loadConfig(fixture.cwd);
+    assert.equal(config.model_profile, 'balanced');
+  });
+
+  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: '.' }),
+      'PROJECT.md': '# Project\n',
+      'STATE.md': '# State\n',
+      'ROADMAP.md': '# Roadmap\n',
+      'phases/': null,
+    });
+    const result = getProjectRoot(fixture.cwd);
+    assert.equal(result, '.');
+  });
+
+  it('isV2Install detects v2 markers in root-layout', () => {
+    fixture = createTempProject({ layout: 'root' });
+    const result = isV2Install(fixture.cwd);
+    assert.equal(result, true);
+  });
+
+  it('isV2Install returns false for root-layout v1', () => {
+    fixture = createFixture({
+      'dgs.config.json': JSON.stringify({ planningRoot: '.' }),
+      'PROJECT.md': '# Project\n',
+      'STATE.md': '# State\n',
+    });
+    const result = isV2Install(fixture.cwd);
+    assert.equal(result, false);
+  });
+
+  it('getProjectFolders works in root-layout v2', () => {
+    fixture = createFixture({
+      'dgs.config.json': JSON.stringify({ planningRoot: '.', current_project: 'proj-a' }),
+      'PROJECTS.md': '# Projects\n',
+      'REPOS.md': '# Repos\n',
+      'projects/proj-a/STATE.md': '# State\n',
+      'projects/proj-a/phases/': null,
+    });
+    const result = getProjectFolders(fixture.cwd);
+    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
+    fixture = createFixture({
+      'PROJECT.md': '# Project\n',
+      'config.json': JSON.stringify({ model_profile: 'budget' }),
+      'STATE.md': '# State\n',
+    });
+    const config = loadConfig(fixture.cwd);
+    assert.equal(config.model_profile, 'budget');
+  });
+});
+
+// ─── getProjectDir Tests ─────────────────────────────────────────────────────
+
+describe('getProjectDir', () => {
+  it('returns absolute path under .planning/projects/<slug> for v2 install', () => {
+    const fixture = createTempProject({ version: 2, project: 'my-app' });
+
+    try {
+      const result = getProjectDir(fixture.cwd, 'my-app');
+      assert.ok(path.isAbsolute(result), 'Expected absolute path');
+      assert.equal(result, path.join(fixture.cwd, '.planning', 'projects', 'my-app'));
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('returns absolute path for any slug even if directory does not exist', () => {
+    const fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    try {
+      const result = getProjectDir(fixture.cwd, 'nonexistent');
+      assert.ok(path.isAbsolute(result), 'Expected absolute path');
+      assert.ok(result.endsWith(path.join('projects', 'nonexistent')));
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});
+
+// ─── Config Dual-Read Tests ─────────────────────────────────────────────────
+
+describe('config dual-read', () => {
+  let fixture;
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+    fixture = null;
+  });
+
+  it('loadConfig reads dgs.config.json when both exist in .planning/', () => {
+    fixture = createFixture({
+      '.planning/dgs.config.json': JSON.stringify({ model_profile: 'quality' }),
+      '.planning/config.json': JSON.stringify({ model_profile: 'speed' }),
+    });
+    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/', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({ model_profile: 'speed' }),
+    });
+    const config = loadConfig(fixture.cwd);
+    assert.equal(config.model_profile, 'speed');
+  });
+});