@ktpartners/dgs-platform 2.7.5 → 2.9.0

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

@@ -1,10 +1,10 @@
 /**
- * Tests for paths.cjs — Planning root detection and PATHS singleton
+ * Tests for paths.cjs -- Planning root detection and PATHS singleton
  *
  * Uses Node.js built-in test runner (node:test) and assert (node:assert/strict).
- * Each test creates an isolated temp directory fixture and cleans up after.
+ * Each test creates an isolated temp git repo fixture and cleans up after.
  *
- * Covers PATH-01 through PATH-05 requirements.
+ * Covers PATH-01 through PATH-06, OPT-01 requirements.
  */
 
 const { describe, it, afterEach } = require('node:test');
@@ -12,22 +12,42 @@ const assert = require('node:assert/strict');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execSync } = require('child_process');
 
-const { getPlanningRoot, getPaths, initPaths, resetPaths, PROJECTS_DIR } = require('./paths.cjs');
+const { getPlanningRoot, getPaths, initPaths, resetPaths, isV2Install, PROJECTS_DIR } = require('./paths.cjs');
+const { rejectV1Install } = require('./migration.cjs');
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
+const ISOLATED_ENV = Object.assign({}, process.env, {
+  GIT_CONFIG_GLOBAL: '/dev/null',
+  GIT_CONFIG_NOSYSTEM: '1',
+});
+
+function makeGitTempDir() {
+  // Use realpathSync to resolve macOS /var -> /private/var symlink so
+  // comparisons with git rev-parse --show-toplevel output match.
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-paths-test-')));
+  execSync('git init', { cwd: dir, stdio: 'pipe', env: ISOLATED_ENV });
+  execSync('git config user.name "Test"', { cwd: dir, stdio: 'pipe', env: ISOLATED_ENV });
+  execSync('git config user.email "test@test.com"', { cwd: dir, stdio: 'pipe', env: ISOLATED_ENV });
+  // Create initial commit so git rev-parse works
+  fs.writeFileSync(path.join(dir, '.gitkeep'), '');
+  execSync('git add .gitkeep && git commit -m "init"', { cwd: dir, stdio: 'pipe', env: ISOLATED_ENV });
+  return dir;
+}
+
 function makeTempDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-paths-test-'));
+  return fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'dgs-paths-test-')));
 }
 
 function removeTempDir(dir) {
   fs.rmSync(dir, { recursive: true, force: true });
 }
 
-// ─── 1. Detection cascade — .planning/ layout (PATH-01, PATH-02) ────────────
+// ─── 1. getPlanningRoot -- git rev-parse (PATH-01) ──────────────────────────
 
-describe('detection cascade — .planning/ layout', () => {
+describe('getPlanningRoot -- git rev-parse', () => {
   let cwd;
 
   afterEach(() => {
@@ -36,38 +56,30 @@ describe('detection cascade — .planning/ layout', () => {
     cwd = null;
   });
 
-  it('detects .planning/ layout from .planning/dgs.config.json', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'dgs.config.json'), '{}');
-
+  it('returns git repo root for a git-initialized directory', () => {
+    cwd = makeGitTempDir();
     const root = getPlanningRoot(cwd);
-    assert.equal(root, path.join(cwd, '.planning'));
+    assert.equal(root, cwd);
   });
 
-  it('detects .planning/ layout from .planning/config.json', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
-    const root = getPlanningRoot(cwd);
-    assert.equal(root, path.join(cwd, '.planning'));
+  it('returns git repo root from a subdirectory', () => {
+    cwd = makeGitTempDir();
+    const sub = path.join(cwd, 'a', 'b', 'c');
+    fs.mkdirSync(sub, { recursive: true });
+    const root = getPlanningRoot(sub);
+    assert.equal(root, cwd);
   });
 
-  it('detects .planning/ layout when both config files exist', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'dgs.config.json'), '{}');
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+  it('returns absolute path', () => {
+    cwd = makeGitTempDir();
     const root = getPlanningRoot(cwd);
-    assert.equal(root, path.join(cwd, '.planning'));
+    assert.ok(path.isAbsolute(root), 'Expected absolute path');
   });
 });
 
-// ─── 2. Detection cascade — root layout (PATH-01, PATH-02) ──────────────────
+// ─── 2. getPlanningRoot -- per-process caching (OPT-01) ─────────────────────
 
-describe('detection cascade — root layout', () => {
+describe('getPlanningRoot -- per-process cache', () => {
   let cwd;
 
   afterEach(() => {
@@ -76,59 +88,56 @@ describe('detection cascade — root layout', () => {
     cwd = null;
   });
 
-  it('detects root layout from dgs.config.json with planningRoot "."', () => {
-    cwd = makeTempDir();
-    fs.writeFileSync(
-      path.join(cwd, 'dgs.config.json'),
-      JSON.stringify({ planningRoot: '.' })
-    );
-
-    const root = getPlanningRoot(cwd);
-    assert.equal(root, cwd);
+  it('returns cached value on subsequent calls', () => {
+    cwd = makeGitTempDir();
+    const first = getPlanningRoot(cwd);
+    // Second call with different cwd should still return cached value
+    const second = getPlanningRoot('/some/other/path');
+    assert.equal(first, second, 'Expected cached value to be returned');
   });
 
-  it('returns .planning/ when root dgs.config.json has no planningRoot field', () => {
-    cwd = makeTempDir();
-    fs.writeFileSync(
-      path.join(cwd, 'dgs.config.json'),
-      JSON.stringify({ mode: 'interactive' })
-    );
-
-    const root = getPlanningRoot(cwd);
-    assert.equal(root, path.join(cwd, '.planning'));
-  });
-
-  it('falls through when root dgs.config.json has malformed JSON', () => {
-    cwd = makeTempDir();
-    fs.writeFileSync(path.join(cwd, 'dgs.config.json'), '{not valid json!!!');
-
-    // Should NOT crash — falls through to default
-    const root = getPlanningRoot(cwd);
-    // Malformed config falls through; no PROJECT.md => default .planning/
-    assert.equal(root, path.join(cwd, '.planning'));
-  });
-
-  it('auto-detects root layout when PROJECT.md exists at root with no .planning/ dir', () => {
-    cwd = makeTempDir();
-    fs.writeFileSync(path.join(cwd, 'PROJECT.md'), '# Project: Test');
-
-    const root = getPlanningRoot(cwd);
-    assert.equal(root, cwd);
+  it('resetPaths clears the cache so next call re-detects', () => {
+    cwd = makeGitTempDir();
+    const first = getPlanningRoot(cwd);
+    resetPaths();
+    // After reset, calling with same cwd should re-detect (same result, but not from cache)
+    const second = getPlanningRoot(cwd);
+    assert.equal(first, second, 'Expected same root after cache clear + re-detect');
   });
+});
 
-  it('returns .planning/ when PROJECT.md exists at root AND .planning/ directory exists', () => {
-    cwd = makeTempDir();
-    fs.writeFileSync(path.join(cwd, 'PROJECT.md'), '# Project: Test');
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
+// ─── 3. getPlanningRoot -- non-git directory ────────────────────────────────
 
-    const root = getPlanningRoot(cwd);
-    assert.equal(root, path.join(cwd, '.planning'));
+describe('getPlanningRoot -- non-git directory', () => {
+  it('exits with error when not in a git repo (subprocess)', () => {
+    const dir = makeTempDir();
+    try {
+      const script = `
+        const { getPlanningRoot } = require(${JSON.stringify(path.join(__dirname, 'paths.cjs'))});
+        getPlanningRoot(${JSON.stringify(dir)});
+      `;
+      const tmpScript = path.join(dir, 'test-no-git.cjs');
+      fs.writeFileSync(tmpScript, script);
+      try {
+        execSync(`node ${JSON.stringify(tmpScript)}`, {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: ISOLATED_ENV,
+        });
+        assert.fail('Expected process to exit with error');
+      } catch (err) {
+        assert.ok(err.status === 1, `Expected exit code 1, got ${err.status}`);
+        assert.ok(err.stderr.includes('DGS requires a git repository'), 'Expected git repo error message');
+      }
+    } finally {
+      removeTempDir(dir);
+    }
   });
 });
 
-// ─── 3. Detection cascade — default (PATH-02) ───────────────────────────────
+// ─── 4. rejectV1Install ─────────────────────────────────────────────────────
 
-describe('detection cascade — default', () => {
+describe('rejectV1Install', () => {
   let cwd;
 
   afterEach(() => {
@@ -137,17 +146,60 @@ describe('detection cascade — default', () => {
     cwd = null;
   });
 
-  it('defaults to .planning/ when no signals are found', () => {
-    cwd = makeTempDir();
+  it('does nothing when no .planning/PROJECT.md exists', () => {
+    cwd = makeGitTempDir();
+    // No error, no exit
+    rejectV1Install(cwd);
+  });
 
-    const root = getPlanningRoot(cwd);
-    assert.equal(root, path.join(cwd, '.planning'));
+  it('does nothing when .planning/PROJECT.md exists with PROJECTS.md at root', () => {
+    cwd = makeGitTempDir();
+    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
+    fs.writeFileSync(path.join(cwd, '.planning', 'PROJECT.md'), '# Project');
+    fs.writeFileSync(path.join(cwd, 'PROJECTS.md'), '# Projects');
+    rejectV1Install(cwd);
+  });
+
+  it('does nothing when .planning/PROJECT.md exists with REPOS.md at root', () => {
+    cwd = makeGitTempDir();
+    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
+    fs.writeFileSync(path.join(cwd, '.planning', 'PROJECT.md'), '# Project');
+    fs.writeFileSync(path.join(cwd, 'REPOS.md'), '# Repos');
+    rejectV1Install(cwd);
+  });
+
+  it('exits with code 1 and writes V1_UNSUPPORTED.md for V1 layout (subprocess)', () => {
+    cwd = makeGitTempDir();
+    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
+    fs.writeFileSync(path.join(cwd, '.planning', 'PROJECT.md'), '# Project');
+
+    const script = `
+      const { rejectV1Install } = require(${JSON.stringify(path.join(__dirname, 'migration.cjs'))});
+      rejectV1Install(${JSON.stringify(cwd)});
+      process.stdout.write('should-not-reach');
+    `;
+    const tmpScript = path.join(cwd, 'test-v1-reject.cjs');
+    fs.writeFileSync(tmpScript, script);
+    try {
+      execSync(`node ${JSON.stringify(tmpScript)}`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: ISOLATED_ENV,
+      });
+      assert.fail('Expected process to exit with error');
+    } catch (err) {
+      assert.equal(err.status, 1, 'Expected exit code 1');
+      assert.ok(err.stderr.includes('V1 single-repo layout is no longer supported'), 'Expected V1 rejection error');
+      assert.ok(!err.stdout.includes('should-not-reach'), 'Process should have exited before reaching stdout write');
+    }
+    // V1_UNSUPPORTED.md should have been written
+    assert.ok(fs.existsSync(path.join(cwd, 'V1_UNSUPPORTED.md')), 'Expected V1_UNSUPPORTED.md to be written');
   });
 });
 
-// ─── 4. Detection cascade — priority (PATH-02) ──────────────────────────────
+// ─── 5. isV2Install ─────────────────────────────────────────────────────────
 
-describe('detection cascade — priority', () => {
+describe('isV2Install', () => {
   let cwd;
 
   afterEach(() => {
@@ -156,23 +208,31 @@ describe('detection cascade — priority', () => {
     cwd = null;
   });
 
-  it('.planning/config.json takes precedence over root dgs.config.json with planningRoot "."', () => {
-    cwd = makeTempDir();
-    // .planning/ layout signal
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-    // Root layout signal
-    fs.writeFileSync(
-      path.join(cwd, 'dgs.config.json'),
-      JSON.stringify({ planningRoot: '.' })
-    );
+  it('returns true when PROJECTS.md with correct header exists at repo root', () => {
+    cwd = makeGitTempDir();
+    fs.writeFileSync(path.join(cwd, 'PROJECTS.md'), '# Projects\n\n| Project | Status |');
+    assert.equal(isV2Install(cwd), true);
+  });
 
-    const root = getPlanningRoot(cwd);
-    assert.equal(root, path.join(cwd, '.planning'));
+  it('returns true when REPOS.md with correct header exists at repo root', () => {
+    cwd = makeGitTempDir();
+    fs.writeFileSync(path.join(cwd, 'REPOS.md'), '# Repos\n\n| Name | Path |');
+    assert.equal(isV2Install(cwd), true);
+  });
+
+  it('returns false when neither marker file exists', () => {
+    cwd = makeGitTempDir();
+    assert.equal(isV2Install(cwd), false);
+  });
+
+  it('returns false when PROJECTS.md has wrong header', () => {
+    cwd = makeGitTempDir();
+    fs.writeFileSync(path.join(cwd, 'PROJECTS.md'), 'Not a projects file');
+    assert.equal(isV2Install(cwd), false);
   });
 });
 
-// ─── 5. PATHS object shape (PATH-03) ────────────────────────────────────────
+// ─── 6. PATHS object shape (PATH-03) ────────────────────────────────────────
 
 describe('PATHS object shape', () => {
   let cwd;
@@ -185,49 +245,26 @@ describe('PATHS object shape', () => {
 
   const EXPECTED_KEYS = [
     'ROOT', 'PHASES', 'IDEAS', 'SPECS', 'JOBS', 'DOCS',
-    'CODEBASE', 'MILESTONES', 'CONFIG', 'CONFIG_LOCAL', 'CONFIG_LEGACY',
-    'QUICK', 'TODOS', 'RESEARCH', 'DEBUG', 'ARCHIVE', 'PROJECTS', 'LAYOUT',
+    'CODEBASE', 'MILESTONES', 'CONFIG', 'CONFIG_LOCAL',
+    'QUICK', 'TODOS', 'RESEARCH', 'DEBUG', 'ARCHIVE', 'PROJECTS',
   ];
 
-  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'), '{}');
-
+  it('returns object with all 16 expected keys', () => {
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     assert.deepEqual(Object.keys(paths).sort(), EXPECTED_KEYS.slice().sort());
   });
 
-  it('for .planning/ layout: ROOT ends with .planning and LAYOUT is dotplanning', () => {
-    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.ROOT.endsWith('.planning'));
-    assert.equal(paths.LAYOUT, 'dotplanning');
-  });
-
-  it('for root layout: ROOT equals cwd and LAYOUT is root', () => {
-    cwd = makeTempDir();
-    fs.writeFileSync(
-      path.join(cwd, 'dgs.config.json'),
-      JSON.stringify({ planningRoot: '.' })
-    );
-
+  it('ROOT equals git repo root', () => {
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     assert.equal(paths.ROOT, cwd);
-    assert.equal(paths.LAYOUT, 'root');
   });
 
-  it('all path values (except LAYOUT) are absolute', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+  it('all path values are absolute', () => {
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     for (const [key, value] of Object.entries(paths)) {
-      if (key === 'LAYOUT') continue;
       assert.ok(
         path.isAbsolute(value),
         `Expected ${key} to be absolute, got: ${value}`
@@ -236,38 +273,19 @@ describe('PATHS object shape', () => {
   });
 
   it('CONFIG ends with config.json', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     assert.ok(paths.CONFIG.endsWith('config.json'));
-    assert.ok(!paths.CONFIG.endsWith('dgs.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'), '{}');
-
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     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', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     assert.equal(paths.PHASES, path.join(paths.ROOT, 'phases'));
     assert.equal(paths.IDEAS, path.join(paths.ROOT, 'ideas'));
@@ -283,9 +301,16 @@ describe('PATHS object shape', () => {
     assert.equal(paths.ARCHIVE, path.join(paths.ROOT, 'archive'));
     assert.equal(paths.PROJECTS, path.join(paths.ROOT, 'projects'));
   });
+
+  it('does not contain LAYOUT or CONFIG_LEGACY keys', () => {
+    cwd = makeGitTempDir();
+    const paths = getPaths(cwd);
+    assert.equal('LAYOUT' in paths, false, 'LAYOUT should not exist in paths object');
+    assert.equal('CONFIG_LEGACY' in paths, false, 'CONFIG_LEGACY should not exist in paths object');
+  });
 });
 
-// ─── 6. Object.freeze (PATH-03) ─────────────────────────────────────────────
+// ─── 7. Object.freeze (PATH-03) ─────────────────────────────────────────────
 
 describe('Object.freeze', () => {
   let cwd;
@@ -297,19 +322,13 @@ describe('Object.freeze', () => {
   });
 
   it('getPaths returns a frozen object', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     assert.equal(Object.isFrozen(paths), true);
   });
 
   it('attempting to add a property does not modify the object', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     try {
       paths.NEW_PROP = 'value';
@@ -320,7 +339,7 @@ describe('Object.freeze', () => {
   });
 });
 
-// ─── 7. Caching (PATH-03, PATH-04) ──────────────────────────────────────────
+// ─── 8. Caching (PATH-03, OPT-01) ──────────────────────────────────────────
 
 describe('caching', () => {
   let cwdA, cwdB;
@@ -333,35 +352,15 @@ describe('caching', () => {
     cwdB = null;
   });
 
-  it('same cwd returns same object (referential equality)', () => {
-    cwdA = makeTempDir();
-    fs.mkdirSync(path.join(cwdA, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwdA, '.planning', 'config.json'), '{}');
-
+  it('same cwd returns same getPaths object (referential equality)', () => {
+    cwdA = makeGitTempDir();
     const first = getPaths(cwdA);
     const second = getPaths(cwdA);
     assert.equal(first === second, true, 'Expected referential equality');
   });
 
-  it('different cwd returns different object', () => {
-    cwdA = makeTempDir();
-    fs.mkdirSync(path.join(cwdA, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwdA, '.planning', 'config.json'), '{}');
-
-    cwdB = makeTempDir();
-    fs.mkdirSync(path.join(cwdB, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwdB, '.planning', 'config.json'), '{}');
-
-    const pathsA = getPaths(cwdA);
-    const pathsB = getPaths(cwdB);
-    assert.notEqual(pathsA === pathsB, true, 'Expected different objects');
-  });
-
-  it('resetPaths clears the cache (new reference after reset)', () => {
-    cwdA = makeTempDir();
-    fs.mkdirSync(path.join(cwdA, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwdA, '.planning', 'config.json'), '{}');
-
+  it('resetPaths clears the getPaths cache (new reference after reset)', () => {
+    cwdA = makeGitTempDir();
     const before = getPaths(cwdA);
     resetPaths();
     const after = getPaths(cwdA);
@@ -369,7 +368,7 @@ describe('caching', () => {
   });
 });
 
-// ─── 8. initPaths / resetPaths (PATH-04) ─────────────────────────────────────
+// ─── 9. initPaths / resetPaths (PATH-04) ─────────────────────────────────────
 
 describe('initPaths / resetPaths', () => {
   let cwd;
@@ -381,20 +380,14 @@ describe('initPaths / resetPaths', () => {
   });
 
   it('initPaths returns the same PATHS object as getPaths', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+    cwd = makeGitTempDir();
     const fromInit = initPaths(cwd);
     const fromGet = getPaths(cwd);
     assert.equal(fromInit === fromGet, true, 'initPaths and getPaths should return same reference');
   });
 
   it('resetPaths clears cache (verified by reference comparison)', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+    cwd = makeGitTempDir();
     const before = initPaths(cwd);
     resetPaths();
     const after = initPaths(cwd);
@@ -402,7 +395,7 @@ describe('initPaths / resetPaths', () => {
   });
 });
 
-// ─── 9. Leaf module constraint (PATH-05) ─────────────────────────────────────
+// ─── 10. Leaf module constraint (PATH-05) ────────────────────────────────────
 
 describe('leaf module constraint', () => {
   it('paths.cjs has no DGS module imports (no require("./") patterns)', () => {
@@ -410,12 +403,12 @@ describe('leaf module constraint', () => {
       path.join(__dirname, 'paths.cjs'),
       'utf-8'
     );
-    // Check for require('./anything') — would indicate DGS module import
+    // Check for require('./anything') -- would indicate DGS module import
     const dgsImports = source.match(/require\s*\(\s*['"]\.\/[^'"]*['"]\s*\)/g);
     assert.equal(dgsImports, null, 'paths.cjs should have zero DGS module imports');
   });
 
-  it('paths.cjs uses fs and path builtins', () => {
+  it('paths.cjs uses fs, path, and child_process builtins', () => {
     const source = fs.readFileSync(
       path.join(__dirname, 'paths.cjs'),
       'utf-8'
@@ -428,10 +421,14 @@ describe('leaf module constraint', () => {
       /require\s*\(\s*['"]path['"]\s*\)/.test(source),
       'Expected require("path") in paths.cjs'
     );
+    assert.ok(
+      /require\s*\(\s*['"]child_process['"]\s*\)/.test(source),
+      'Expected require("child_process") in paths.cjs'
+    );
   });
 });
 
-// ─── 10. Edge cases ──────────────────────────────────────────────────────────
+// ─── 11. Edge cases ─────────────────────────────────────────────────────────
 
 describe('edge cases', () => {
   let cwd;
@@ -443,11 +440,9 @@ describe('edge cases', () => {
   });
 
   it('paths returned even when subdirectories do not exist on disk', () => {
-    cwd = makeTempDir();
-    // No .planning/ directory created, no config files — default case
-
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
-    // Should still return all paths even though none of these directories exist
+    // Should return all paths even though none of these directories exist
     assert.ok(paths.PHASES);
     assert.ok(paths.IDEAS);
     assert.ok(paths.SPECS);
@@ -459,38 +454,10 @@ describe('edge cases', () => {
   });
 
   it('getPaths().PROJECTS returns absolute path ending in /projects', () => {
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
+    cwd = makeGitTempDir();
     const paths = getPaths(cwd);
     assert.ok(path.isAbsolute(paths.PROJECTS), 'Expected PROJECTS to be absolute');
     assert.ok(paths.PROJECTS.endsWith('/projects') || paths.PROJECTS.endsWith('\\projects'),
       'Expected PROJECTS path to end with /projects');
   });
-
-  it('relative cwd is normalized to absolute path', () => {
-    // This test verifies that passing a relative cwd gives the same result
-    // as passing the equivalent absolute path
-    cwd = makeTempDir();
-    fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
-    fs.writeFileSync(path.join(cwd, '.planning', 'config.json'), '{}');
-
-    // Get paths with absolute cwd
-    const absResult = getPaths(cwd);
-    resetPaths();
-
-    // Calling with '.' should resolve to process.cwd(), which is different from
-    // our temp dir, but the key behavior is that relative paths get resolved
-    // to absolute via path.resolve()
-    const dotResult = getPaths('.');
-    // The important assertion: all returned paths are absolute regardless of input
-    for (const [key, value] of Object.entries(dotResult)) {
-      if (key === 'LAYOUT') continue;
-      assert.ok(
-        path.isAbsolute(value),
-        `Expected ${key} to be absolute even with relative cwd input`
-      );
-    }
-  });
 });

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

@@ -10,27 +10,28 @@ const { writeStateMd } = require('./state.cjs');
 
 /**
  * Resolve the phases directory for the current project context.
- * v2: .planning/<project>/phases/  |  v1: .planning/phases/
+ * Returns path.join(cwd, projectRoot, 'phases') where projectRoot is
+ * from getProjectRoot() or '.' as fallback.
  */
 function resolvePhasesDir(cwd) {
   let projectRoot;
   try {
     projectRoot = getProjectRoot(cwd);
   } catch {
-    projectRoot = '.planning';
+    projectRoot = '.';
   }
   return path.join(cwd, projectRoot, 'phases');
 }
 
 /**
  * Resolve the project root path (relative) for the current context.
- * v2: .planning/<project>  |  v1: .planning
+ * Returns getProjectRoot() result or '.' as fallback.
  */
 function resolveProjectRoot(cwd) {
   try {
     return getProjectRoot(cwd);
   } catch {
-    return '.planning';
+    return '.';
   }
 }