@opengsd/gsd-pi 1.5.0 → 1.6.0

package/src/resources/extensions/gsd/tests/integration/paths.test.ts

@@ -1,6 +1,6 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, realpathSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -9,6 +9,7 @@ import {
   gsdProjectionRoot,
   gsdRoot,
   milestonesDir,
+  resolveGsdPathContract,
   resolveSliceFile,
   resolveTaskFile,
   _clearGsdRootCache,
@@ -166,4 +167,90 @@ describe('paths', () => {
       cleanup(root);
     }
   });
+
+  test('Case 9: flat-phase task SUMMARY resolves at phase root despite a stray slices/SID/ dir', () => {
+    const root = tmp();
+    try {
+      // Hybrid flat-phase milestone: phase dir holds flat TID-SUMMARY.md, but a
+      // stray slices/S01/ folder also exists on disk. resolveSlicePath then points
+      // under slices/, so layout (phases/ vs milestones/) — not slicePath===phaseDir
+      // — must decide the flat-phase task summary location.
+      const phaseDir = join(root, ".gsd", "phases", "01-foo");
+      mkdirSync(join(phaseDir, "slices", "S01"), { recursive: true });
+      const flatSummary = join(phaseDir, "T01-SUMMARY.md");
+      writeFileSync(flatSummary, "# task summary\n");
+
+      _clearGsdRootCache();
+
+      assert.deepStrictEqual(
+        resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
+        flatSummary,
+        "flat-phase TID-SUMMARY.md at phase root is found even when slices/S01/ exists",
+      );
+    } finally { cleanup(root); }
+  });
+
+  test('Case 10: resolveGsdPathContract canonicalizes a symlinked .gsd root (regression #1239)', () => {
+    // WSL / external-state shape: `<projectRoot>/.gsd` is a symlink pointing at a
+    // real directory on another volume. Before #1239 the DB path was built from
+    // the unresolved symlink, so the workflow SQLite handle opened through a
+    // move-prone path and could pick the wrong journal mode / SQLITE_READONLY_DBMOVED.
+    const root = tmp();
+    try {
+      const realState = join(root, "real-state"); // canonical symlink target
+      mkdirSync(join(realState, "milestones"), { recursive: true });
+      const projectRoot = join(root, "project");
+      mkdirSync(projectRoot, { recursive: true });
+      symlinkSync(realState, join(projectRoot, ".gsd"), "dir");
+
+      _clearGsdRootCache();
+      const contract = resolveGsdPathContract(projectRoot);
+
+      const canonicalGsd = realpathSync.native(join(projectRoot, ".gsd"));
+      assert.deepStrictEqual(contract.projectGsd, canonicalGsd,
+        "projectGsd is the realpath'd target, not the unresolved .gsd symlink");
+      assert.deepStrictEqual(contract.projectDb, join(canonicalGsd, "gsd.db"),
+        "projectDb is built from the canonical .gsd root");
+      assert.deepStrictEqual(contract.projectGsd, gsdProjectionRoot(projectRoot),
+        "projectGsd agrees with gsdProjectionRoot on the canonical root");
+      assert.notStrictEqual(contract.projectDb, join(projectRoot, ".gsd", "gsd.db"),
+        "regression #1239: DB must not open through the unresolved .gsd symlink");
+    } finally { cleanup(root); }
+  });
+
+  test('Case 11: resolveGsdPathContract canonicalizes the external-state worktree DB path through a symlinked store (regression #1239)', () => {
+    const root = tmp();
+    const originalStateDir = process.env.GSD_STATE_DIR;
+    try {
+      const stateDir = join(root, "state");
+      process.env.GSD_STATE_DIR = stateDir;
+
+      // The external-state project store `<state>/projects/<hash>` is itself a
+      // symlink to a real directory on another volume (the WSL `.gsd` shape).
+      const realProjectGsd = join(root, "real-projects", "abc123");
+      mkdirSync(realProjectGsd, { recursive: true });
+      mkdirSync(join(stateDir, "projects"), { recursive: true });
+      const storeSymlink = join(stateDir, "projects", "abc123");
+      symlinkSync(realProjectGsd, storeSymlink, "dir");
+
+      const wtRoot = join(storeSymlink, "worktrees", "M002");
+      mkdirSync(join(wtRoot, ".gsd"), { recursive: true });
+
+      _clearGsdRootCache();
+      const contract = resolveGsdPathContract(wtRoot);
+
+      const canonicalStore = realpathSync.native(storeSymlink);
+      assert.ok(contract.isWorktree, "recognized as an external-state worktree layout");
+      assert.deepStrictEqual(contract.projectGsd, canonicalStore,
+        "projectGsd is the realpath'd project store, not the unresolved symlink");
+      assert.deepStrictEqual(contract.projectDb, join(canonicalStore, "gsd.db"),
+        "projectDb is built from the canonical project store");
+      assert.notStrictEqual(contract.projectDb, join(storeSymlink, "gsd.db"),
+        "regression #1239: DB must not open through the unresolved external-state symlink");
+    } finally {
+      if (originalStateDir === undefined) delete process.env.GSD_STATE_DIR;
+      else process.env.GSD_STATE_DIR = originalStateDir;
+      cleanup(root);
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/integration/workspace-collapse-integration.test.ts

@@ -25,10 +25,8 @@ import {
   markDepthVerified,
   clearDiscussionFlowState,
 } from "../../bootstrap/write-gate.ts";
-import {
-  teardownAutoWorktree,
-  _resetAutoWorktreeOriginalBaseForTests,
-} from "../../auto-worktree.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../../auto-worktree-teardown.ts";
 import {
   openDatabaseByWorkspace,
   closeAllDatabases,

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

@@ -40,6 +40,7 @@ import { readUnitRuntimeRecord } from "../unit-runtime.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import {
   closeDatabase,
+  getTask,
   insertMilestone,
   insertSlice,
   insertTask,
@@ -445,7 +446,7 @@ test("runDispatch retries when complete-milestone summary exists on disk and stu
   assert.equal(stopCalls, 0, "artifact-based recovery should not hard-stop the loop");
 });
 
-test("runDispatch pauses when execute-task artifacts exist but DB status is still open", async (t) => {
+test("runDispatch promotes execute-task DB status when artifacts exist but DB status is still open (#1204)", async (t) => {
   const capture = createEventCapture();
   let pauseCalls = 0;
   let stopCalls = 0;
@@ -522,16 +523,16 @@ test("runDispatch pauses when execute-task artifacts exist but DB status is stil
 
   const result = await runDispatch(ic, preData, loopState);
 
-  assert.equal(result.action, "break");
-  assert.equal((result as any).reason, "execute-task-artifact-db-mismatch");
-  assert.equal(pauseCalls, 1, "execute-task disk/db mismatch should pause auto-mode");
-  assert.equal(stopCalls, 0, "execute-task disk/db mismatch should not hard-stop the loop");
-  assert.equal(invalidateCalls, 0, "mismatch should not clear caches and continue toward redispatch");
-  assert.equal(loopState.recentUnits.length, 3, "mismatch should keep the stuck window intact");
-  assert.equal(loopState.stuckRecoveryAttempts, 1, "mismatch should not reset the recovery counter");
+  assert.equal(result.action, "continue");
+  assert.equal(pauseCalls, 0, "disk-verified promotion should not pause auto-mode");
+  assert.equal(stopCalls, 0, "disk-verified promotion should not hard-stop the loop");
+  assert.equal(invalidateCalls, 1, "successful promotion should invalidate caches before retrying");
+  assert.equal(loopState.recentUnits.length, 0, "successful promotion should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 1 recovery increments the attempt counter");
+  assert.equal(getTask("M001", "S01", "T01")?.status, "complete", "the open DB task should be promoted to complete");
 });
 
-test("runDispatch pauses at Level 2 when execute-task artifacts exist but DB status is still open", async (t) => {
+test("runDispatch promotes execute-task DB status at Level 2 when artifacts exist but DB status is still open (#1204)", async (t) => {
   const capture = createEventCapture();
   let pauseCalls = 0;
   let stopCalls = 0;
@@ -601,13 +602,13 @@ test("runDispatch pauses at Level 2 when execute-task artifacts exist but DB sta
 
   const result = await runDispatch(ic, preData, loopState);
 
-  assert.equal(result.action, "break");
-  assert.equal((result as any).reason, "execute-task-artifact-db-mismatch");
-  assert.equal(pauseCalls, 1, "Level 2 execute-task disk/db mismatch should pause auto-mode");
-  assert.equal(stopCalls, 0, "Level 2 execute-task disk/db mismatch should not hard-stop the loop");
+  assert.equal(result.action, "continue");
+  assert.equal(pauseCalls, 0, "Level 2 disk-verified promotion should not pause auto-mode");
+  assert.equal(stopCalls, 0, "Level 2 disk-verified promotion should not hard-stop the loop");
   assert.equal(invalidateCalls, 1, "Level 2 should invalidate caches before the final artifact recheck");
-  assert.equal(loopState.recentUnits.length, 3, "Level 2 mismatch should keep the stuck window intact");
-  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 2 mismatch should not reset the recovery counter");
+  assert.equal(loopState.recentUnits.length, 0, "Level 2 successful promotion should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 1, "Level 2 does not reset the recovery counter");
+  assert.equal(getTask("M001", "S01", "T01")?.status, "complete", "the open DB task should be promoted to complete");
 });
 
 test("runDispatch clears execute-task stuck state when artifacts and DB status are complete", async (t) => {

package/src/resources/extensions/gsd/tests/merge-closeout-consistency-gate.test.ts

@@ -8,7 +8,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { checkCloseoutConsistencyGate } from "../closeout-consistency-gate.ts";
 import {
   closeDatabase,

package/src/resources/extensions/gsd/tests/merge-db-cycle.test.ts

@@ -14,7 +14,7 @@ import { tmpdir } from "node:os";
 import { delimiter, join } from "node:path";
 import { execFileSync } from "node:child_process";
 
-import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { closeDatabase, insertAssessment, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
 import { _clearGsdRootCache } from "../paths.ts";

package/src/resources/extensions/gsd/tests/merge-self-branch-guard.test.ts

@@ -19,7 +19,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { _resetServiceCache } from "../worktree.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 

package/src/resources/extensions/gsd/tests/migration-auto-check.test.ts

@@ -250,6 +250,73 @@ test("migration auto-check canonicalizes a legacy descriptor milestone dir (no f
   }
 });
 
+test("migration auto-check recognizes suffixed flat-phase projection directories", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+
+    insertMilestone({
+      id: "M001-re4q3k",
+      title: "Clean GSD Continuation Readiness",
+      status: "complete",
+      planning: { vision: "Keep continuation state readable." },
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001-re4q3k",
+      title: "Readiness slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+      demo: "Readable continuation state.",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001-re4q3k",
+      title: "Readiness task",
+      status: "complete",
+    });
+    insertMilestone({
+      id: "M002-a1rwmq",
+      title: "Support Command Policy Hardening",
+      status: "complete",
+      planning: { vision: "Harden support command policy." },
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M002-a1rwmq",
+      title: "Policy slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+      demo: "Policy is hardened.",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M002-a1rwmq",
+      title: "Policy task",
+      status: "complete",
+    });
+
+    const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.ts");
+    const rebuild = await rebuildMarkdownProjectionsFromDb(base);
+    assert.ok(rebuild.rendered > 0, "expected flat-phase markdown projections to render");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 2, slices: 2, tasks: 2 });
+    assert.deepEqual(result.beforeDb, { milestones: 2, slices: 2, tasks: 2 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("migration auto-check refreshes a stale open DB handle before comparing", async () => {
   const base = makeBase();
   try {
@@ -372,6 +439,30 @@ test("migration auto-check still compares a roadmapless milestone that HAS a DB
   }
 });
 
+test("migration auto-check aligns a roadmapless milestone dir to its suffixed DB row (no false drift)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    // Team-mode suffixed milestone whose markdown dir has no ROADMAP yet (e.g. a
+    // freshly handed-off / zero-slice milestone). Markdown discovers the bare
+    // "M001"; the DB stores the authoritative suffixed "M001-re4q3k". The
+    // bare-to-suffixed alignment must rewrite EVERY markdown set, including the
+    // roadmapless subset, so the discussion-phase exclusion sees the DB row and
+    // does not decrement the milestone count into false drift.
+    insertMilestone({ id: "M001-re4q3k", title: "Suffixed milestone", status: "queued" });
+    writeScratchMilestoneDir(base, "M001", "M001-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 0, tasks: 0 });
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 0, tasks: 0 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("rebuildMarkdownProjectionsFromDb realigns markdown when DB holds extra rows", async () => {
   const base = makeBase();
   try {

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

@@ -13,6 +13,7 @@ import {
   isCompletedMilestoneTerminal,
   repairMissingMilestoneSummaryProjection,
 } from "../milestone-closeout.js";
+import { targetMilestoneFile } from "../paths.js";
 import type { DispatchContext } from "../auto-dispatch.js";
 
 /** Build a minimal DispatchContext for the dispatch-policy branches under test. */
@@ -196,7 +197,7 @@ test("repairMissingMilestoneSummaryProjection succeeds when milestone dir does n
   const repair = await repairMissingMilestoneSummaryProjection(base, "M042");
   assert.equal(repair.ok, true, "repair should report success when handler creates the SUMMARY");
   assert.ok(
-    existsSync(join(base, ".gsd", "phases", "42-m042", "42-SUMMARY.md")),
+    existsSync(targetMilestoneFile(base, "M042", "SUMMARY", "Done")),
     "repair should write the SUMMARY artifact to the canonical projection path",
   );
 });