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

package/src/resources/extensions/gsd/tests/gsdroot-worktree-detection.test.ts

@@ -1,9 +1,10 @@
 /**
  * gsdroot-worktree-detection.test.ts — Regression test for #2594.
  *
- * gsdRoot() must return the worktree's own .gsd directory when the basePath
- * is inside a .gsd/worktrees/<name>/ structure, not walk up to the project
- * root's .gsd via the git-root probe.
+ * gsdRoot() must return the canonical project .gsd directory when basePath
+ * is inside a .gsd/worktrees/<name>/ structure. Worktree-local .gsd folders
+ * are legacy projection roots only; runtime state is DB-authoritative at the
+ * project .gsd.
  *
  * The bug: when a git worktree lives at /project/.gsd/worktrees/M008/,
  * probeGsdRoot() runs `git rev-parse --show-toplevel` which can return the
@@ -20,7 +21,7 @@ import { mkdtempSync, realpathSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 
-import { gsdRoot, _clearGsdRootCache } from "../paths.ts";
+import { gsdRoot, resolveGsdPathContract, _clearGsdRootCache } from "../paths.ts";
 
 describe("gsdRoot() worktree detection (#2594)", () => {
   let projectRoot: string;
@@ -61,7 +62,7 @@ describe("gsdRoot() worktree detection (#2594)", () => {
     rmSync(projectRoot, { recursive: true, force: true });
   });
 
-  test("returns worktree .gsd when basePath is a worktree with its own .gsd (fast path)", () => {
+  test("returns project .gsd when basePath is a worktree with its own .gsd", () => {
     // Simulates a worktree that already had copyPlanningArtifacts() run,
     // so it has its own .gsd/ directory.
     const worktreeBase = join(projectGsd, "worktrees", "M008");
@@ -71,41 +72,26 @@ describe("gsdRoot() worktree detection (#2594)", () => {
     const result = gsdRoot(worktreeBase);
     assert.equal(
       result,
-      worktreeGsd,
-      `Expected worktree .gsd (${worktreeGsd}), got ${result}. ` +
-        "gsdRoot() should use the fast path for an existing worktree .gsd.",
+      projectGsd,
+      `Expected canonical project .gsd (${projectGsd}), got ${result}.`,
     );
+    assert.equal(resolveGsdPathContract(worktreeBase).worktreeGsd, worktreeGsd);
   });
 
-  test("returns worktree .gsd path (not project root .gsd) when worktree .gsd does not exist yet", () => {
-    // This is the core #2594 bug: the worktree directory exists but its .gsd
-    // subdirectory hasn't been created yet. Without the fix, probeGsdRoot()
-    // walks up from the worktree path, finds /project/.gsd, and returns it.
-    // With the fix, it detects the .gsd/worktrees/<name>/ pattern and returns
-    // the worktree-local .gsd path as the creation fallback.
+  test("returns project .gsd when worktree .gsd does not exist yet", () => {
     const worktreeBase = join(projectGsd, "worktrees", "M008");
     mkdirSync(worktreeBase, { recursive: true });
     // NOTE: no .gsd/ inside worktreeBase
 
     const result = gsdRoot(worktreeBase);
-    const expected = join(worktreeBase, ".gsd");
-
-    // Without the fix, this returns projectGsd (/project/.gsd) because the
-    // walk-up from worktreeBase finds it. With the fix, it returns the
-    // worktree-local path.
-    assert.notEqual(
-      result,
-      projectGsd,
-      "gsdRoot() must NOT return the project root .gsd when basePath is inside .gsd/worktrees/",
-    );
     assert.equal(
       result,
-      expected,
-      `Expected worktree-local .gsd (${expected}), got ${result}.`,
+      projectGsd,
+      `Expected canonical project .gsd (${projectGsd}), got ${result}.`,
     );
   });
 
-  test("returns worktree .gsd when basePath is a real git worktree inside .gsd/worktrees/", () => {
+  test("returns project .gsd when basePath is a real git worktree inside .gsd/worktrees/", () => {
     // Create a real git worktree at .gsd/worktrees/M010
     const worktreeName = "M010";
     const worktreeBase = join(projectGsd, "worktrees", worktreeName);
@@ -125,17 +111,10 @@ describe("gsdRoot() worktree detection (#2594)", () => {
 
     // The real git worktree exists at worktreeBase but has NO .gsd/ subdir yet
     const gsdResult = gsdRoot(worktreeBase);
-    const expected = join(worktreeBase, ".gsd");
-
-    assert.notEqual(
-      gsdResult,
-      projectGsd,
-      "gsdRoot() must NOT escape to project root .gsd from inside a git worktree",
-    );
     assert.equal(
       gsdResult,
-      expected,
-      `Expected worktree-local .gsd (${expected}), got ${gsdResult}`,
+      projectGsd,
+      `Expected canonical project .gsd (${projectGsd}), got ${gsdResult}`,
     );
 
     // Cleanup worktree

package/src/resources/extensions/gsd/tests/handler-worktree-write-isolation.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Regression: when /gsd handlers run with cwd inside a worktree, writes must
+ * land in the worktree's .gsd/, not the parent project's .gsd/.
+ *
+ * The fix in 01464a97 replaced `process.cwd()` with `projectRoot()` to block
+ * $HOME pollution, but `projectRoot()` walks UP from a worktree path to the
+ * outer project root — breaking the worktree isolation invariant agents rely
+ * on. The corrected pattern: handlers use `currentDirectoryRoot()`, which
+ * preserves the active cwd (worktree or project) and still throws when cwd
+ * is $HOME.
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
+import { tmpdir, homedir } from "node:os";
+import { join } from "node:path";
+
+import { currentDirectoryRoot, projectRoot, withCommandCwd, GSDNoProjectError } from "../commands/context.ts";
+
+describe("handlers preserve worktree cwd via currentDirectoryRoot()", () => {
+  let project: string;
+  let worktree: string;
+
+  beforeEach(() => {
+    project = realpathSync(mkdtempSync(join(tmpdir(), "gsd-wt-iso-")));
+    mkdirSync(join(project, ".gsd"), { recursive: true });
+    mkdirSync(join(project, ".git"), { recursive: true });
+    worktree = join(project, ".gsd", "worktrees", "M001");
+    mkdirSync(join(worktree, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(project, { recursive: true, force: true });
+  });
+
+  test("currentDirectoryRoot() returns the worktree path when cwd is the worktree", async () => {
+    const resolved = await withCommandCwd(worktree, async () => currentDirectoryRoot());
+    assert.equal(resolved, worktree, "must keep worktree path so writes isolate");
+  });
+
+  test("projectRoot() walks UP from worktree to the project root (legacy semantics)", async () => {
+    const resolved = await withCommandCwd(worktree, async () => projectRoot());
+    assert.equal(resolved, project, "projectRoot intentionally returns project, not worktree");
+  });
+
+  test("currentDirectoryRoot() throws GSDNoProjectError when cwd is $HOME", async () => {
+    await assert.rejects(
+      withCommandCwd(homedir(), async () => currentDirectoryRoot()),
+      (err: unknown) => err instanceof GSDNoProjectError,
+    );
+  });
+
+  test("currentDirectoryRoot() returns project root when cwd is project root", async () => {
+    const resolved = await withCommandCwd(project, async () => currentDirectoryRoot());
+    assert.equal(resolved, project);
+  });
+});

package/src/resources/extensions/gsd/tests/integration/parallel-merge.test.ts

@@ -473,26 +473,26 @@ test("mergeAllCompleted — by-completion order respects startedAt", async () =>
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// Bug #2812 — determineMergeOrder should use worktree DB as source of truth
+// Bug #2812 — determineMergeOrder should use DB state as source of truth
 // ═══════════════════════════════════════════════════════════════════════════════
 
-/** Set up a worktree DB with a milestone marked complete */
-function setupWorktreeDb(basePath: string, mid: string): void {
-  const wtGsdDir = join(basePath, ".gsd", "worktrees", mid, ".gsd");
-  mkdirSync(wtGsdDir, { recursive: true });
-  const dbPath = join(wtGsdDir, "gsd.db");
+/** Set up canonical DB with a milestone marked complete and a worktree marker dir */
+function setupCanonicalDbWithWorktree(basePath: string, mid: string): void {
+  mkdirSync(join(basePath, ".gsd", "worktrees", mid), { recursive: true });
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+  const dbPath = join(basePath, ".gsd", "gsd.db");
   openDatabase(dbPath);
   insertMilestone({ id: mid, title: `Milestone ${mid}`, status: "complete" });
   updateMilestoneStatus(mid, "complete", new Date().toISOString());
   closeDatabase();
 }
 
-test("determineMergeOrder — finds milestones completed in worktree DB even when worker state is 'error' (#2812)", () => {
+test("determineMergeOrder — finds milestones completed in canonical DB even when worker state is 'error' (#2812)", () => {
   const base = realpathSync(mkdtempSync(join(tmpdir(), "merge-db-bug-")));
   try {
     // Simulate the bug scenario: orchestrator has stale "error" state
-    // but the worktree DB shows milestone is actually complete.
-    setupWorktreeDb(base, "M011");
+    // but the canonical DB shows milestone is actually complete.
+    setupCanonicalDbWithWorktree(base, "M011");
 
     const workers = [
       makeWorker({ milestoneId: "M010", state: "error" }),
@@ -502,12 +502,12 @@ test("determineMergeOrder — finds milestones completed in worktree DB even whe
 
     const order = determineMergeOrder(workers, "sequential", base);
 
-    // M011 should be included because its worktree DB says status='complete'
+    // M011 should be included because the canonical DB says status='complete'
     assert.ok(
       order.includes("M011"),
-      `Expected M011 in merge order (worktree DB says complete), got: [${order}]`,
+      `Expected M011 in merge order (canonical DB says complete), got: [${order}]`,
     );
-    // M010 and M012 should NOT be included (no worktree DB with complete status)
+    // M010 and M012 should NOT be included (no canonical complete status)
     assert.ok(!order.includes("M010"), "M010 should not be in merge order (error, no DB)");
     assert.ok(!order.includes("M012"), "M012 should not be in merge order (running, no DB)");
   } finally {
@@ -529,7 +529,7 @@ test("determineMergeOrder — combines stopped workers and DB-complete milestone
   const base = realpathSync(mkdtempSync(join(tmpdir(), "merge-dedup-")));
   try {
     // M001 is stopped in orchestrator AND complete in worktree DB
-    setupWorktreeDb(base, "M001");
+    setupCanonicalDbWithWorktree(base, "M001");
 
     const workers = [
       makeWorker({ milestoneId: "M001", state: "stopped" }),
@@ -555,8 +555,8 @@ test("mergeAllCompleted — discovers DB-complete milestones when workers show e
     ]);
     setupRoadmap(repo, "M011", "Feature System", ["S01: Feature module"]);
 
-    // Set up worktree DB showing M011 is complete
-    setupWorktreeDb(repo, "M011");
+    // Set up canonical DB showing M011 is complete
+    setupCanonicalDbWithWorktree(repo, "M011");
 
     // Orchestrator thinks M011 is in error (stale state)
     const workers = [

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -46,6 +46,7 @@ import {
   updateTaskStatus,
   updateSliceStatus,
   updateMilestoneStatus,
+  insertAssessment,
   insertReplanHistory,
   getReplanHistory,
   insertGateRow,
@@ -363,13 +364,13 @@ describe("state derivation failures", () => {
     const state2 = await deriveState(base);
     assert.equal(state2.phase, "executing", "cached result should still show executing");
 
-    // After explicit invalidation, should reflect the DB mutation and reconcile
-    // missing plan tasks instead of prematurely summarizing a partial DB row set.
+    // After explicit invalidation, DB rows remain authoritative; PLAN.md is a
+    // projection and must not import missing task rows.
     invalidateStateCache();
     const state3 = await deriveState(base);
-    assert.equal(state3.phase, "executing", "after cache invalidation should continue with the missing plan task");
-    assert.equal(state3.activeTask?.id, "T02", "missing plan task T02 should be imported and selected");
-    assert.deepEqual(state3.progress?.tasks, { done: 1, total: 2 });
+    assert.equal(state3.phase, "summarizing", "after cache invalidation should follow DB tasks only");
+    assert.equal(state3.activeTask, null, "disk-only plan task T02 should not be imported");
+    assert.deepEqual(state3.progress?.tasks, { done: 1, total: 1 });
   });
 
   test("corrupt ROADMAP: binary content does not crash deriveState", async () => {
@@ -486,12 +487,14 @@ describe("transition boundary failures", () => {
     writeFileSync(join(mDir, "M001-CONTEXT-DRAFT.md"), "# Draft\nSome draft.\n");
 
     openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Draft", status: "needs-discussion" });
     invalidateAllCaches();
     const state1 = await deriveState(base);
     assert.equal(state1.phase, "needs-discussion");
 
     // Now write the full CONTEXT (simulates discussion completion)
     writeFileSync(join(mDir, "M001-CONTEXT.md"), "# M001: Resolved\n\n## Purpose\nDone.\n");
+    updateMilestoneStatus("M001", "active");
 
     invalidateAllCaches();
     const state2 = await deriveState(base);
@@ -1148,6 +1151,13 @@ describe("completion and verification failures", () => {
     insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "complete" });
     insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", status: "complete" });
     insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", status: "complete" });
+    insertAssessment({
+      path: "milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     invalidateAllCaches();
     const state = await deriveStateFromDb(base);

package/src/resources/extensions/gsd/tests/markdown-renderer.test.ts

@@ -856,10 +856,10 @@ test('── markdown-renderer: renderAllFromDb produces all files ──', asyn
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
-// Graceful Degradation (Disk Fallback)
+// DB-authoritative regeneration
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: graceful fallback reads from disk when artifact not in DB ──', async () => {
+test('── markdown-renderer: missing artifact regenerates from DB without importing disk projection ──', async () => {
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -874,7 +874,7 @@ test('── markdown-renderer: graceful fallback reads from disk when artifact
     // Write roadmap to disk but NOT in artifacts DB
     const roadmapContent = makeRoadmapContent([
       { id: 'S01', title: 'Core', done: false },
-    ]);
+    ]) + '\n\nDISK_ONLY_SENTINEL';
     const roadmapPath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
     fs.writeFileSync(roadmapPath, roadmapContent);
     clearAllCaches();
@@ -883,14 +883,20 @@ test('── markdown-renderer: graceful fallback reads from disk when artifact
     const before = getArtifact('milestones/M001/M001-ROADMAP.md');
     assert.deepStrictEqual(before, null, 'artifact not in DB before render');
 
-    // Render — should read from disk, store in DB
+    // Render — should regenerate from DB rows, not import/patch disk content.
     const ok = await renderRoadmapCheckboxes(tmpDir, 'M001');
-    assert.ok(ok, 'render succeeds with disk fallback');
+    assert.ok(ok, 'render succeeds by regenerating from DB');
 
-    // Verify artifact now in DB (stored after reading from disk)
+    // Verify artifact now exists in DB but does not contain disk-only content.
     const after = getArtifact('milestones/M001/M001-ROADMAP.md');
-    assert.ok(after !== null, 'artifact stored in DB after disk fallback render');
-    assert.ok(after!.full_content.includes('[x] **S01:'), 'DB artifact reflects rendered state');
+    assert.ok(after !== null, 'artifact regenerated in DB');
+    assert.ok(!after!.full_content.includes('DISK_ONLY_SENTINEL'), 'disk projection content was not imported');
+    assert.ok(after!.full_content.includes('S01'), 'DB artifact reflects DB slice state');
+
+    assert.ok(fs.existsSync(roadmapPath), 'roadmap projection regenerated on disk');
+    const diskAfter = fs.readFileSync(roadmapPath, 'utf-8');
+    assert.ok(!diskAfter.includes('DISK_ONLY_SENTINEL'), 'disk projection was rewritten from DB');
+    assert.ok(diskAfter.includes('S01'), 'disk projection reflects DB slice state');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -9,6 +9,7 @@ import {
   getRequirementById,
   getActiveRequirements,
   insertArtifact,
+  SCHEMA_VERSION,
   _getAdapter,
 } from '../gsd-db.ts';
 import {
@@ -363,7 +364,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 22, 'new DB should be at schema version 22');
+  assert.deepStrictEqual(version?.v, SCHEMA_VERSION, `new DB should be at schema version ${SCHEMA_VERSION}`);
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -2,6 +2,7 @@ import {
   openDatabase,
   closeDatabase,
   isDbAvailable,
+  SCHEMA_VERSION,
   _getAdapter,
 } from '../gsd-db.ts';
 import {
@@ -328,9 +329,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 22 (v22 quality_gates DDL fix included)
+  // Verify schema version is current (includes quality_gates DDL fix and later migrations)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.["v"], 22, 'schema version should be 22');
+  assert.deepStrictEqual(version?.["v"], SCHEMA_VERSION, `schema version should be ${SCHEMA_VERSION}`);
 
   closeDatabase();
 });

package/src/resources/extensions/gsd/tests/park-milestone.test.ts

@@ -20,6 +20,8 @@ import {
 } from "../gsd-db.ts";
 import { createWorktree } from "../worktree-manager.ts";
 
+// This suite exercises the explicit legacy markdown derivation path.
+process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK = '1';
 
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────

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,
   };
 }