@opengsd/gsd-pi 1.4.0-dev.c18009cd → 1.5.0-dev.4fb2d460

package/src/resources/extensions/gsd/tests/import-completion-lost-update.test.ts

@@ -0,0 +1,196 @@
+// Project/App: gsd-pi
+// File Purpose: Regression for #1222 — a re-import must not silently downgrade
+// a completed flat-phase task back to pending when its SUMMARY.md attests the
+// completion. gsd_task_complete succeeds and writes TID-SUMMARY.md, but a stale
+// plan checkbox re-imported into the DB would revert the task to pending,
+// hard-stopping auto-mode on its "state did not advance" guard.
+
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { cpSync, mkdtempSync, rmSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+import { openDatabase, closeDatabase, getAllMilestones, getMilestoneSlices, getSliceTasks, repairTaskCompletionFromSummary } from "../gsd-db.ts";
+import { migrateHierarchyToDb } from "../md-importer.ts";
+import { invalidateStateCache } from "../state.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURE_ROOT = join(__dirname, "__fixtures__", "flat-phase");
+// The flat-phase fixture parses to M001/S01/T01 (phase 01, plan 01, task T01).
+const PHASE_DIR = join(".gsd", "phases", "01-foundation");
+const SUMMARY_REL = join(PHASE_DIR, "T01-SUMMARY.md");
+
+const tmpDirs: string[] = [];
+afterEach(() => {
+  closeDatabase();
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+function copyFixture(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-lostupdate-${randomUUID()}`));
+  cpSync(FIXTURE_ROOT, base, { recursive: true });
+  tmpDirs.push(base);
+  return base;
+}
+
+function taskStatus(base: string): string | undefined {
+  return t01Row()?.status;
+}
+
+function t01Row() {
+  const ms = getAllMilestones();
+  if (ms.length === 0) return undefined;
+  const slices = getMilestoneSlices(ms[0]!.id);
+  if (slices.length === 0) return undefined;
+  const tasks = getSliceTasks(ms[0]!.id, slices[0]!.id);
+  return tasks.find((t) => t.id === "T01");
+}
+
+function t01Ids() {
+  const ms = getAllMilestones();
+  const slices = getMilestoneSlices(ms[0]!.id);
+  return { milestoneId: ms[0]!.id, sliceId: slices[0]!.id };
+}
+
+test("re-import keeps a flat-phase task complete when its SUMMARY.md is present (#1222)", () => {
+  const base = copyFixture();
+  // The fixture plan leaves T01 unchecked ([ ]). Simulate a completed task: the
+  // durable SUMMARY.md exists even though the plan checkbox is stale-unchecked.
+  writeFileSync(join(base, SUMMARY_REL), "# T01 SUMMARY\n\nDone.\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  migrateHierarchyToDb(base);
+  invalidateStateCache();
+
+  assert.equal(
+    taskStatus(base),
+    "complete",
+    "task with SUMMARY.md on disk must import as complete, not revert to pending",
+  );
+});
+
+test("re-import leaves an unchecked flat-phase task pending when no SUMMARY.md exists (#1222)", () => {
+  const base = copyFixture();
+  // No SUMMARY.md — the unchecked checkbox is the authoritative signal.
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  migrateHierarchyToDb(base);
+  invalidateStateCache();
+
+  assert.equal(
+    taskStatus(base),
+    "pending",
+    "unchecked task without a SUMMARY.md must stay pending",
+  );
+});
+
+test("re-import keeps a flat-phase task complete even when an auxiliary tasks/ subdir exists (#1222)", () => {
+  const base = copyFixture();
+  // Flat-phase may keep a tasks/ subdir for gate artifacts (e.g. T01-VERIFY.json)
+  // while gsd_task_complete still writes TID-SUMMARY.md at the phase root. The
+  // tasks/ subdir must NOT shadow that real summary and downgrade the task.
+  mkdirSync(join(base, PHASE_DIR, "tasks"), { recursive: true });
+  writeFileSync(join(base, PHASE_DIR, "tasks", "T01-VERIFY.json"), "{}\n");
+  writeFileSync(join(base, SUMMARY_REL), "# T01 SUMMARY\n\nDone.\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  migrateHierarchyToDb(base);
+  invalidateStateCache();
+
+  assert.equal(
+    taskStatus(base),
+    "complete",
+    "a phase-root SUMMARY.md must win even when a tasks/ subdir exists (no shadowing)",
+  );
+});
+
+test("re-import preserves execution metadata and completed_at of an attested-complete task (#1222)", () => {
+  const base = copyFixture();
+  // T01 is completed on disk (SUMMARY present) but its plan checkbox is stale-unchecked.
+  writeFileSync(join(base, SUMMARY_REL), "# T01 SUMMARY\n\nDone.\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  migrateHierarchyToDb(base);
+  invalidateStateCache();
+
+  // Simulate the row gsd_task_complete leaves behind: real execution prose plus
+  // a completion timestamp from when the task actually finished.
+  const OLD_COMPLETED_AT = "2026-07-01T00:00:00.000Z";
+  const REAL_ONE_LINER = "Implemented the widget frobnicator end-to-end";
+  const REAL_SUMMARY = "# T01 full summary\n\nEverything about how T01 was done.";
+  const REAL_VERIFICATION = "all 12 checks passed";
+  const { milestoneId, sliceId } = t01Ids();
+  repairTaskCompletionFromSummary({
+    milestoneId,
+    sliceId,
+    taskId: "T01",
+    oneLiner: REAL_ONE_LINER,
+    verificationResult: REAL_VERIFICATION,
+    completedAt: OLD_COMPLETED_AT,
+    fullSummaryMd: REAL_SUMMARY,
+  });
+  invalidateStateCache();
+
+  const before = t01Row()!;
+  assert.equal(before.status, "complete", "precondition: T01 is complete");
+  assert.equal(before.one_liner, REAL_ONE_LINER, "precondition: one_liner set");
+  assert.equal(before.completed_at, OLD_COMPLETED_AT, "precondition: completed_at set");
+
+  // The pre-dispatch reconcile re-imports the whole tree (plan checkbox still [ ]).
+  migrateHierarchyToDb(base);
+  invalidateStateCache();
+
+  const after = t01Row()!;
+  assert.equal(after.status, "complete", "status must survive re-import");
+  assert.equal(after.one_liner, REAL_ONE_LINER, "one_liner must survive re-import");
+  assert.equal(after.full_summary_md, REAL_SUMMARY, "full_summary_md must survive re-import");
+  assert.equal(after.verification_result, REAL_VERIFICATION, "verification_result must survive re-import");
+  assert.equal(after.completed_at, OLD_COMPLETED_AT, "completed_at must not be refreshed by re-import");
+});
+
+test("removing the SUMMARY.md (reopen) lets a re-import return the task to pending and clears completion metadata (#1222)", () => {
+  const base = copyFixture();
+  writeFileSync(join(base, SUMMARY_REL), "# T01 SUMMARY\n\nDone.\n");
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  migrateHierarchyToDb(base);
+  invalidateStateCache();
+  assert.equal(taskStatus(base), "complete", "precondition: task imports complete with SUMMARY present");
+
+  // Simulate the durable completion row gsd_task_complete leaves behind.
+  const { milestoneId, sliceId } = t01Ids();
+  repairTaskCompletionFromSummary({
+    milestoneId,
+    sliceId,
+    taskId: "T01",
+    oneLiner: "Implemented the widget frobnicator end-to-end",
+    verificationResult: "all 12 checks passed",
+    completedAt: "2026-07-01T00:00:00.000Z",
+    fullSummaryMd: "# T01 full summary\n\nEverything about how T01 was done.",
+  });
+  invalidateStateCache();
+  const before = t01Row()!;
+  assert.equal(before.status, "complete", "precondition: T01 is complete");
+  assert.equal(before.completed_at, "2026-07-01T00:00:00.000Z", "precondition: completed_at set");
+
+  // reopen-task deletes the flat-phase SUMMARY; the next re-import must respect it.
+  unlinkSync(join(base, SUMMARY_REL));
+  migrateHierarchyToDb(base);
+  invalidateStateCache();
+  const after = t01Row()!;
+  assert.equal(
+    after.status,
+    "pending",
+    "after the SUMMARY is removed, a re-import must return the unchecked task to pending",
+  );
+  // A pending re-import must not preserve stale completion metadata (#1228 thread):
+  // preserveCompletionMetadata only applies to complete/done imports.
+  assert.ok(!after.completed_at, "completed_at must be cleared when the task reverts to pending");
+  assert.ok(!after.one_liner, "one_liner must be cleared when the task reverts to pending");
+  assert.ok(!after.full_summary_md, "full_summary_md must be cleared when the task reverts to pending");
+  assert.ok(!after.verification_result, "verification_result must be cleared when the task reverts to pending");
+});

package/src/resources/extensions/gsd/tests/integration/all-milestones-complete-merge.test.ts

@@ -25,12 +25,10 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import {
-  createAutoWorktree,
-  isInAutoWorktree,
-  getAutoWorktreeOriginalBase,
-  mergeMilestoneToMain,
-} from "../../auto-worktree.ts";
+import { createAutoWorktree } from "../../auto-worktree-creation.ts";
+import { isInAutoWorktree } from "../../auto-worktree-entry.ts";
+import { mergeMilestoneToMain } from "../../auto-worktree-merge.ts";
+import { getAutoWorktreeOriginalBase } from "../../auto-worktree-session-registry.ts";
 
 function run(command: string, cwd: string): string {
   return execSync(command, {

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

@@ -12,7 +12,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree, mergeMilestoneToMain } from "../../auto-worktree.ts";
+import { createAutoWorktree } from "../../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../../auto-worktree-merge.ts";
 import { nativeMergeSquash } from "../../native-git-bridge.ts";
 
 function run(cmd: string, cwd: string): string {

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -19,12 +19,12 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
+import { createAutoWorktree } from "../../auto-worktree-creation.ts";
 import {
-  createAutoWorktree,
   mergeMilestoneToMain,
-  getAutoWorktreeOriginalBase,
   _setRestoreEntryFnForTests,
-} from "../../auto-worktree.ts";
+} from "../../auto-worktree-merge.ts";
+import { getAutoWorktreeOriginalBase } from "../../auto-worktree-session-registry.ts";
 import { getSliceBranchName } from "../../worktree.ts";
 import { nativeMergeSquash } from "../../native-git-bridge.ts";
 import { drainLogs, setStderrLoggingEnabled } from "../../workflow-logger.ts";

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

@@ -17,17 +17,16 @@ import {
   writeGsdMilestoneContext,
 } from "./gsd-integration-fixture.ts";
 
+import { createAutoWorktree } from "../../auto-worktree-creation.ts";
+import { enterAutoWorktree, isInAutoWorktree } from "../../auto-worktree-entry.ts";
+import { getAutoWorktreePath } from "../../auto-worktree-path-resolution.ts";
 import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  isInAutoWorktree,
-  getAutoWorktreePath,
-  enterAutoWorktree,
-  getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
-  syncGsdStateToWorktree,
+  getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-} from "../../auto-worktree.ts";
+} from "../../auto-worktree-session-registry.ts";
+import { syncGsdStateToWorktree } from "../../auto-worktree-sync.ts";
+import { teardownAutoWorktree } from "../../auto-worktree-teardown.ts";
 
 // Note: execSync is used intentionally in tests for git operations with
 // controlled, hardcoded inputs (no user input). This is safe and matches

package/src/resources/extensions/gsd/tests/integration/feature-branch-lifecycle-integration.test.ts

@@ -22,11 +22,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import {
-  createAutoWorktree,
-  mergeMilestoneToMain,
-  autoWorktreeBranch,
-} from "../../auto-worktree.ts";
+import { createAutoWorktree } from "../../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../../auto-worktree-merge.ts";
 import { captureIntegrationBranch, getSliceBranchName } from "../../worktree.ts";
 import { writeIntegrationBranch, readIntegrationBranch } from "../../git-service.ts";
 import { nextMilestoneId, generateMilestoneSuffix } from "../../guided-flow.ts";

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

@@ -15,6 +15,7 @@ import {
   RUNTIME_EXCLUSION_PATHS,
   VALID_BRANCH_NAME,
   runGit,
+  taskBranchArgs,
   readIntegrationBranch,
   resolveMilestoneIntegrationBranch,
   writeIntegrationBranch,
@@ -1119,6 +1120,81 @@ process.exit(result.status ?? 0);
     rmSync(repo, { recursive: true, force: true });
   }
 
+  // ─── taskBranchArgs ───────────────────────────────────────────────────
+
+  test('taskBranchArgs starts new workflow branches from the base branch, not from HEAD', () => {
+    const repo = initBranchTestRepo();
+
+    assert.deepStrictEqual(
+      taskBranchArgs(repo, "gsd/spike/first", "main", "main"),
+      ["checkout", "-b", "gsd/spike/first"],
+      "branching while on the base branch itself needs no explicit start point",
+    );
+
+    // Simulate a finished workflow left checked out with its own commit.
+    run("git checkout -b gsd/spike/first", repo);
+    createFile(repo, "first.txt", "first workflow output");
+    runGit(repo, ["add", "-A"]);
+    runGit(repo, ["commit", "-m", "first workflow work"]);
+    _resetHasChangesCache();
+
+    const args = taskBranchArgs(repo, "gsd/spike/second", "gsd/spike/first", "main");
+    assert.deepStrictEqual(
+      args,
+      ["checkout", "-b", "gsd/spike/second", "main"],
+      "next workflow branch starts from the base so workflows do not stack",
+    );
+
+    runGit(repo, args);
+    assert.deepStrictEqual(
+      run("git rev-parse HEAD", repo),
+      run("git rev-parse main", repo),
+      "second workflow branch points at the base, without the first workflow's commit",
+    );
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test('taskBranchArgs keeps branch-from-HEAD on user branches and unsafe states', () => {
+    const repo = initBranchTestRepo();
+
+    // Manual feature branch: the user chose to stand here — new workflow
+    // branches base on it, never silently jump to main.
+    run("git checkout -b feature/login", repo);
+    createFile(repo, "feature.txt", "feature work");
+    runGit(repo, ["add", "-A"]);
+    runGit(repo, ["commit", "-m", "feature work"]);
+    _resetHasChangesCache();
+    assert.deepStrictEqual(
+      taskBranchArgs(repo, "gsd/spike/from-feature", "feature/login", "main"),
+      ["checkout", "-b", "gsd/spike/from-feature"],
+      "a manual feature branch is a deliberate base — no redirect to main",
+    );
+
+    // Base branch without a local ref (e.g. origin/HEAD names a branch that
+    // was never checked out locally): fall back to HEAD instead of failing.
+    run("git checkout -b gsd/spike/stale", repo);
+    _resetHasChangesCache();
+    assert.deepStrictEqual(
+      taskBranchArgs(repo, "gsd/spike/next", "gsd/spike/stale", "no-such-branch"),
+      ["checkout", "-b", "gsd/spike/next"],
+      "missing local base ref falls back to branch-from-HEAD",
+    );
+
+    // Dirty tree on a task branch: a tree-changing start point would abort
+    // the checkout or strand the changes — fall back to HEAD.
+    createFile(repo, "dirty.txt", "uncommitted");
+    runGit(repo, ["add", "-A"]);
+    _resetHasChangesCache();
+    assert.deepStrictEqual(
+      taskBranchArgs(repo, "gsd/spike/next", "gsd/spike/stale", "main"),
+      ["checkout", "-b", "gsd/spike/next"],
+      "dirty working tree falls back to branch-from-HEAD",
+    );
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ═══════════════════════════════════════════════════════════════════════
   // S05: Enhanced features — snapshots, pre-merge checks
   // ═══════════════════════════════════════════════════════════════════════

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

@@ -28,7 +28,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { mergeMilestoneToMain } from "../../auto-worktree.ts";
+import { mergeMilestoneToMain } from "../../auto-worktree-merge.ts";
 import { MergeConflictError } from "../../git-service.ts";
 
 function run(cmd: string, cwd: string): string {

package/src/resources/extensions/gsd/tests/integration/merge-preserve-worktree-on-preteardown-error.test.ts

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { GSDError } from "../../errors.js";
-import { mergeMilestoneToMain } from "../../auto-worktree.ts";
+import { mergeMilestoneToMain } from "../../auto-worktree-merge.ts";
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, {

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

@@ -29,7 +29,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree, mergeMilestoneToMain } from "../../auto-worktree.ts";
+import { createAutoWorktree } from "../../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../../auto-worktree-merge.ts";
 import { closeDatabase } from "../../gsd-db.ts";
 import { getSliceBranchName } from "../../worktree.ts";
 

package/src/resources/extensions/gsd/tests/integration/milestone-transition-worktree.test.ts

@@ -16,13 +16,11 @@ import { execSync } from "node:child_process";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  isInAutoWorktree,
-  getAutoWorktreeOriginalBase,
-  mergeMilestoneToMain,
-} from "../../auto-worktree.ts";
+import { createAutoWorktree } from "../../auto-worktree-creation.ts";
+import { isInAutoWorktree } from "../../auto-worktree-entry.ts";
+import { mergeMilestoneToMain } from "../../auto-worktree-merge.ts";
+import { getAutoWorktreeOriginalBase } from "../../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../../auto-worktree-teardown.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 

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 {