gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.d8826a445

package/src/resources/extensions/gsd/tests/path-normalization-unified.test.ts

@@ -0,0 +1,175 @@
+// GSD-2 + Unified path normalization tests: normalizeRealPath and tryRealpath parity
+
+import { describe, test, before, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  existsSync,
+  rmSync,
+  realpathSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { normalizeRealPath } from "../paths.ts";
+import { createWorkspace } from "../workspace.ts";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Detect whether the filesystem hosting `dir` is case-insensitive.
+ * Creates a file with a lowercase name, then probes it via an uppercase name.
+ */
+function isCaseInsensitiveFs(dir: string): boolean {
+  const lower = join(dir, "ci_probe_lower.txt");
+  const upper = join(dir, "CI_PROBE_LOWER.TXT");
+  try {
+    writeFileSync(lower, "probe");
+    return existsSync(upper);
+  } finally {
+    try { rmSync(lower); } catch { /* ignore */ }
+  }
+}
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pathnorm-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// ─── Suite 1: normalizeRealPath and tryRealpath return identical strings ──────
+
+describe("normalizeRealPath and tryRealpath produce identical results", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("normalizeRealPath on an existing directory matches realpathSync.native", () => {
+    const result = normalizeRealPath(projectDir);
+    // realpathSync.native is the canonical form — result must equal it
+    const expected = realpathSync.native(projectDir);
+    assert.equal(result, expected);
+  });
+
+  test("createWorkspace identityKey equals normalizeRealPath of projectRoot", () => {
+    const ws = createWorkspace(projectDir);
+    // identityKey is computed via tryRealpath → normalizeRealPath
+    assert.equal(ws.identityKey, normalizeRealPath(ws.projectRoot));
+  });
+
+  test("createWorkspace identityKey and normalizeRealPath agree on the same input", () => {
+    const ws = createWorkspace(projectDir);
+    const direct = normalizeRealPath(projectDir);
+    assert.equal(ws.identityKey, direct);
+  });
+});
+
+// ─── Suite 2: non-existent path fallback ─────────────────────────────────────
+
+describe("normalizeRealPath: fallback for non-existent paths", () => {
+  test("returns a resolved (absolute) path for a non-existent input", () => {
+    const ghost = join(tmpdir(), "gsd-pathnorm-ghost-does-not-exist-" + Date.now());
+    const result = normalizeRealPath(ghost);
+    // Must be a string, must be absolute, must not throw
+    assert.equal(typeof result, "string");
+    assert.ok(result.startsWith("/") || /^[A-Za-z]:/.test(result), "result must be absolute");
+  });
+
+  test("normalizeRealPath of a non-existent path is idempotent", () => {
+    const ghost = join(tmpdir(), "gsd-pathnorm-ghost2-" + Date.now());
+    const first = normalizeRealPath(ghost);
+    const second = normalizeRealPath(first);
+    assert.equal(first, second);
+  });
+});
+
+// ─── Suite 3: idempotency on existing paths ───────────────────────────────────
+
+describe("normalizeRealPath: idempotency on existing paths", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("normalizeRealPath of a normalizeRealPath result is the same", () => {
+    const once = normalizeRealPath(projectDir);
+    const twice = normalizeRealPath(once);
+    assert.equal(once, twice);
+  });
+
+  test("createWorkspace identityKey is idempotent across two calls with same path", () => {
+    const ws1 = createWorkspace(projectDir);
+    const ws2 = createWorkspace(projectDir);
+    assert.equal(ws1.identityKey, ws2.identityKey);
+  });
+});
+
+// ─── Suite 4: case-insensitive filesystem (macOS HFS+/APFS) ──────────────────
+
+describe("normalizeRealPath: case normalization on case-insensitive volumes", () => {
+  let projectDir: string;
+  let caseInsensitive: boolean;
+
+  before(() => {
+    // Detect FS case sensitivity once for the suite
+    const probe = mkdtempSync(join(tmpdir(), "gsd-ci-probe-"));
+    caseInsensitive = isCaseInsensitiveFs(probe);
+    rmSync(probe, { recursive: true, force: true });
+  });
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("upper and lower case paths resolve to the same canonical string on case-insensitive FS", (t) => {
+    if (!caseInsensitive) {
+      t.skip("case-sensitive filesystem — case-normalization check not applicable");
+      return;
+    }
+
+    const lower = projectDir.toLowerCase();
+    const upper = projectDir.toUpperCase();
+
+    const canonicalFromLower = normalizeRealPath(lower);
+    const canonicalFromUpper = normalizeRealPath(upper);
+
+    assert.equal(
+      canonicalFromLower,
+      canonicalFromUpper,
+      "both case variants must resolve to the same canonical path on case-insensitive FS",
+    );
+  });
+
+  test("createWorkspace identityKey is case-stable on case-insensitive FS", (t) => {
+    if (!caseInsensitive) {
+      t.skip("case-sensitive filesystem — case-normalization check not applicable");
+      return;
+    }
+
+    const wsLower = createWorkspace(projectDir.toLowerCase());
+    const wsUpper = createWorkspace(projectDir.toUpperCase());
+
+    assert.equal(
+      wsLower.identityKey,
+      wsUpper.identityKey,
+      "identityKey must be identical regardless of input case on case-insensitive FS",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/paths-cache.test.ts

@@ -0,0 +1,170 @@
+// GSD2 — paths cache normalization and clearPathCache() invalidation tests
+
+import { describe, test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, renameSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { gsdRoot, clearPathCache, _clearGsdRootCache } from '../paths.ts';
+
+describe('gsdRootCache key normalization', () => {
+  let projectDir: string;
+  let fakeHome: string;
+  let savedHome: string | undefined;
+  let savedUserProfile: string | undefined;
+  let savedGsdHome: string | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-cache-norm-')));
+    mkdirSync(join(projectDir, '.gsd'), { recursive: true });
+
+    fakeHome = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-cache-home-')));
+
+    savedHome = process.env.HOME;
+    savedUserProfile = process.env.USERPROFILE;
+    savedGsdHome = process.env.GSD_HOME;
+
+    // Point HOME and GSD_HOME at an unrelated temp dir to prevent ~/.gsd interference.
+    process.env.HOME = fakeHome;
+    process.env.USERPROFILE = fakeHome;
+    process.env.GSD_HOME = join(fakeHome, '.gsd');
+
+    _clearGsdRootCache();
+  });
+
+  afterEach(() => {
+    if (savedHome === undefined) delete process.env.HOME;
+    else process.env.HOME = savedHome;
+    if (savedUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = savedUserProfile;
+    if (savedGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = savedGsdHome;
+
+    clearPathCache();
+    rmSync(projectDir, { recursive: true, force: true });
+    rmSync(fakeHome, { recursive: true, force: true });
+  });
+
+  test('gsdRoot with trailing slash returns same result as without', () => {
+    const withoutSlash = gsdRoot(projectDir);
+    _clearGsdRootCache();
+    const withSlash = gsdRoot(projectDir + '/');
+
+    assert.equal(
+      withoutSlash,
+      withSlash,
+      'gsdRoot must return the same path regardless of trailing slash',
+    );
+    assert.equal(
+      withoutSlash,
+      join(projectDir, '.gsd'),
+      'both calls should resolve to projectDir/.gsd',
+    );
+  });
+
+  test('second call with trailing slash hits cache set by first call without slash', () => {
+    // Prime the cache with the no-slash form.
+    const first = gsdRoot(projectDir);
+    // Now remove .gsd so a fresh probe would return a different path.
+    renameSync(join(projectDir, '.gsd'), join(projectDir, '.gsd-hidden'));
+    // Call with trailing slash — must hit the normalized cache entry (no re-probe).
+    const second = gsdRoot(projectDir + '/');
+    // Restore for cleanup.
+    renameSync(join(projectDir, '.gsd-hidden'), join(projectDir, '.gsd'));
+
+    assert.equal(
+      second,
+      first,
+      'trailing-slash call must return cached result from the no-slash call',
+    );
+  });
+});
+
+describe('clearPathCache() does NOT invalidate gsdRootCache (process-lifetime semantics)', () => {
+  let projectDir: string;
+  let fakeHome: string;
+  let savedHome: string | undefined;
+  let savedUserProfile: string | undefined;
+  let savedGsdHome: string | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-cache-clear-')));
+    mkdirSync(join(projectDir, '.gsd'), { recursive: true });
+
+    fakeHome = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-cache-home2-')));
+
+    savedHome = process.env.HOME;
+    savedUserProfile = process.env.USERPROFILE;
+    savedGsdHome = process.env.GSD_HOME;
+
+    process.env.HOME = fakeHome;
+    process.env.USERPROFILE = fakeHome;
+    process.env.GSD_HOME = join(fakeHome, '.gsd');
+
+    _clearGsdRootCache();
+  });
+
+  afterEach(() => {
+    if (savedHome === undefined) delete process.env.HOME;
+    else process.env.HOME = savedHome;
+    if (savedUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = savedUserProfile;
+    if (savedGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = savedGsdHome;
+
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(projectDir, { recursive: true, force: true });
+    rmSync(fakeHome, { recursive: true, force: true });
+  });
+
+  test('clearPathCache() does NOT evict a cached gsdRoot result', (t) => {
+    // Prime the cache.
+    const firstResult = gsdRoot(projectDir);
+    assert.equal(firstResult, join(projectDir, '.gsd'));
+
+    // Remove .gsd so a fresh probe would return a different (fallback) result.
+    renameSync(join(projectDir, '.gsd'), join(projectDir, '.gsd-hidden'));
+    t.after(() => {
+      try { renameSync(join(projectDir, '.gsd-hidden'), join(projectDir, '.gsd')); } catch { /* ignore */ }
+    });
+
+    // clearPathCache() only clears volatile dir caches — gsdRootCache is untouched.
+    clearPathCache();
+    const afterClearPath = gsdRoot(projectDir);
+    assert.equal(
+      afterClearPath,
+      firstResult,
+      'clearPathCache must NOT evict gsdRootCache — result must still be the cached value',
+    );
+  });
+
+  test('_clearGsdRootCache() DOES evict gsdRootCache, causing re-probe', (t) => {
+    // Prime the cache.
+    const firstResult = gsdRoot(projectDir);
+    assert.equal(firstResult, join(projectDir, '.gsd'));
+
+    // Remove .gsd so a fresh probe returns the creation fallback.
+    renameSync(join(projectDir, '.gsd'), join(projectDir, '.gsd-hidden'));
+    t.after(() => {
+      try { renameSync(join(projectDir, '.gsd-hidden'), join(projectDir, '.gsd')); } catch { /* ignore */ }
+    });
+
+    // _clearGsdRootCache() evicts the entry — next call re-probes.
+    _clearGsdRootCache();
+    const afterClearRoot = gsdRoot(projectDir);
+    assert.equal(
+      afterClearRoot,
+      join(projectDir, '.gsd'),
+      'after _clearGsdRootCache, gsdRoot must re-probe and return creation fallback',
+    );
+    // The two results are equal (same path) but the key point is re-probe occurred;
+    // the cached firstResult also happened to equal the fallback path.
+    // Verify: if we prime again without removing .gsd, clearing root re-probes to gsd.
+    renameSync(join(projectDir, '.gsd-hidden'), join(projectDir, '.gsd'));
+    _clearGsdRootCache();
+    const reprobe = gsdRoot(projectDir);
+    assert.equal(reprobe, join(projectDir, '.gsd'), 're-probe after restore returns .gsd');
+  });
+});

package/src/resources/extensions/gsd/tests/pending-autostart-scope.test.ts

@@ -0,0 +1,120 @@
+// GSD-2 + Tests for MilestoneScope pinning in pendingAutoStartMap (C1 regression guard)
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  setPendingAutoStart,
+  clearPendingAutoStart,
+  _getPendingAutoStart,
+} from "../guided-flow.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pas-scope-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("pendingAutoStart scope pinning (C1)", () => {
+  let base: string;
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    base = makeProjectDir();
+  });
+
+  afterEach(() => {
+    clearPendingAutoStart();
+    if (base) {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test("setPendingAutoStart stores a scope whose paths derive from the basePath at reservation time", () => {
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+
+    const entry = _getPendingAutoStart(base);
+    assert.ok(entry, "entry should exist");
+    assert.ok(entry.scope, "entry.scope should be set");
+    assert.equal(entry.scope.milestoneId, "M001");
+
+    const expectedContext = join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md");
+    const expectedRoadmap = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const expectedState = join(base, ".gsd", "STATE.md");
+
+    assert.equal(entry.scope.contextFile(), expectedContext);
+    assert.equal(entry.scope.roadmapFile(), expectedRoadmap);
+    assert.equal(entry.scope.stateFile(), expectedState);
+  });
+
+  test("scope paths are unaffected by process.chdir after reservation", (t) => {
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M002" });
+
+    const entry = _getPendingAutoStart(base);
+    assert.ok(entry, "entry should exist");
+
+    // Capture paths before cwd change
+    const ctxBefore = entry.scope.contextFile();
+    const roadmapBefore = entry.scope.roadmapFile();
+    const stateBefore = entry.scope.stateFile();
+
+    // Change cwd to a different directory, then check that scope is unchanged
+    const originalCwd = process.cwd();
+    const altDir = mkdtempSync(join(tmpdir(), "gsd-cwd-alt-"));
+    t.after(() => {
+      process.chdir(originalCwd);
+      rmSync(altDir, { recursive: true, force: true });
+    });
+
+    process.chdir(altDir);
+
+    assert.equal(entry.scope.contextFile(), ctxBefore, "contextFile must not change after cwd drift");
+    assert.equal(entry.scope.roadmapFile(), roadmapBefore, "roadmapFile must not change after cwd drift");
+    assert.equal(entry.scope.stateFile(), stateBefore, "stateFile must not change after cwd drift");
+  });
+
+  test("scope identityKey matches the realpath of the original basePath even with trailing slash", () => {
+    const baseWithSlash = base + "/";
+    setPendingAutoStart(base, { basePath: baseWithSlash, milestoneId: "M003" });
+
+    const entry = _getPendingAutoStart(base);
+    assert.ok(entry, "entry should exist");
+
+    const expectedIdentityKey = realpathSync(base);
+    assert.equal(
+      entry.scope.workspace.identityKey,
+      expectedIdentityKey,
+      "identityKey must match realpath of the original (non-canonical) basePath",
+    );
+  });
+
+  test("clearPendingAutoStart removes the entry", () => {
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+
+    const before = _getPendingAutoStart(base);
+    assert.ok(before, "entry should exist before clear");
+
+    clearPendingAutoStart(base);
+
+    const after = _getPendingAutoStart(base);
+    assert.equal(after, null, "entry should be null after clearPendingAutoStart(base)");
+  });
+
+  test("_getPendingAutoStart with no basePath argument returns the sole entry", () => {
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+
+    // No argument — should return the sole entry
+    const entry = _getPendingAutoStart();
+    assert.ok(entry, "sole entry should be returned when no basePath given");
+    assert.equal(entry.milestoneId, "M001");
+    assert.ok(entry.scope, "sole entry must have a scope");
+    assert.equal(entry.scope.milestoneId, "M001");
+  });
+});

package/src/resources/extensions/gsd/tests/progressive-planning.test.ts

@@ -6,6 +6,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { performance } from "node:perf_hooks";
 
 import {
   openDatabase,
@@ -99,21 +100,21 @@ test("ADR-011: sketch slice + progressive_planning ON → phase='refining'", asy
   assert.equal(state.phase, "refining", "sketch slice with flag ON must yield refining phase");
 });
 
-test("ADR-011: sketch slice + progressive_planning OFF → phase='planning' (backwards compat)", async (t) => {
+test("ADR-011: sketch slice + progressive_planning OFF → DB sketch metadata still yields refining", async (t) => {
   const originalCwd = process.cwd();
   const base = makeFixtureBase();
   t.after(() => cleanup(base, originalCwd));
 
   seedMilestoneWithSketchedS02(base);
   writeS01Artifacts(base);
-  // Write a PREFERENCES.md without the flag so loadEffectiveGSDPreferences finds
-  // a valid file but progressive_planning resolves to undefined.
+  // Write a PREFERENCES.md without the flag. DB slice metadata remains
+  // authoritative for whether this slice needs refinement.
   writePreferences(base, "phases:\n  skip_research: false");
   process.chdir(base);
 
   const state = await deriveStateFromDb(base);
   assert.equal(state.activeSlice?.id, "S02");
-  assert.equal(state.phase, "planning", "flag absent → must fall through to planning");
+  assert.equal(state.phase, "refining", "flag absent must not override DB sketch metadata");
 });
 
 test("ADR-011: dispatch rule maps refining → refine-slice unit", async (t) => {
@@ -516,24 +517,32 @@ test("ADR-011 P3 #26: refine-slice dispatch latency is bounded vs plan-slice bas
   await buildPlanSlicePrompt("M001", "Test", "S02", "Feature", base);
   await buildRefineSlicePrompt("M001", "Test", "S02", "Feature", base);
 
-  const planStart = Date.now();
-  await buildPlanSlicePrompt("M001", "Test", "S02", "Feature", base);
-  const planElapsed = Date.now() - planStart;
+  const measure = async (fn: () => Promise<string>): Promise<number> => {
+    const start = performance.now();
+    await fn();
+    return performance.now() - start;
+  };
 
-  const refineStart = Date.now();
-  await buildRefineSlicePrompt("M001", "Test", "S02", "Feature", base);
-  const refineElapsed = Date.now() - refineStart;
+  const planSamples: number[] = [];
+  const refineSamples: number[] = [];
+  for (let i = 0; i < 5; i++) {
+    planSamples.push(await measure(() => buildPlanSlicePrompt("M001", "Test", "S02", "Feature", base)));
+    refineSamples.push(await measure(() => buildRefineSlicePrompt("M001", "Test", "S02", "Feature", base)));
+  }
+  const bestPlan = Math.min(...planSamples);
+  const bestRefine = Math.min(...refineSamples);
 
   assert.ok(
-    refineElapsed < 500,
-    `refine-slice prompt build must complete under 500ms (took ${refineElapsed}ms)`,
+    bestRefine < 500,
+    `refine-slice prompt build must complete under 500ms (best=${bestRefine.toFixed(1)}ms, samples=${refineSamples.map(n => n.toFixed(1)).join(",")})`,
   );
   // Guard the ratio only when the baseline is large enough to be meaningful —
-  // if plan-slice measures 0-2ms the ratio is dominated by timer noise.
-  if (planElapsed >= 5) {
+  // if plan-slice measures in single-digit milliseconds, the ratio is dominated
+  // by scheduler and filesystem noise under the concurrent test runner.
+  if (bestPlan >= 20) {
     assert.ok(
-      refineElapsed < planElapsed * 3,
-      `refine-slice must not exceed 3x plan-slice baseline (refine=${refineElapsed}ms, plan=${planElapsed}ms)`,
+      bestRefine < bestPlan * 3,
+      `refine-slice must not exceed 3x plan-slice baseline (refine=${bestRefine.toFixed(1)}ms, plan=${bestPlan.toFixed(1)}ms)`,
     );
   }
 });

package/src/resources/extensions/gsd/tests/projection-regression.test.ts

@@ -91,6 +91,7 @@ function makeMilestoneRow() {
     definition_of_done: [],
     requirement_coverage: '',
     boundary_map_markdown: '',
+    sequence: 0,
   };
 }