@opengsd/gsd-pi 1.9.0-dev.97ef11e3 → 1.9.0-dev.e10b60d4

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

@@ -41,7 +41,6 @@ import { claimMilestoneLease } from "../db/milestone-leases.js";
 import { recordDispatchClaim, markCanceled } from "../db/unit-dispatches.js";
 import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.js";
 import { SourceObservationStore } from "../source-observations.js";
-import { autoCommitCurrentBranch } from "../worktree.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -833,37 +832,6 @@ test("runUnit returns cancelled when session creation fails", async () => {
   assert.equal(pi.calls.length, 0);
 });
 
-test("runUnit returns cancelled when command context lacks newSession", async () => {
-  _resetPendingResolve();
-
-  const ctx = {
-    ...makeMockCtx(),
-    ui: {
-      notify: () => {},
-      setStatus: () => {},
-      setWorkingMessage: () => {},
-    },
-    sessionManager: {
-      getEntries: () => [],
-    },
-    modelRegistry: {
-      getProviderAuthMode: () => undefined,
-      isProviderRequestReady: () => true,
-    },
-  } as any;
-  const pi = makeMockPi();
-  const s = makeMockSession();
-  s.cmdCtx = {} as any;
-
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
-
-  assert.equal(result.status, "cancelled");
-  assert.equal(result.errorContext?.category, "session-failed");
-  assert.equal(result.errorContext?.isTransient, false);
-  assert.match(result.errorContext?.message ?? "", /missing newSession/);
-  assert.equal(pi.calls.length, 0);
-});
-
 test("runUnit: TypeError from newSession is classified as structural (isTransient: false)", async () => {
   // Regression for #572: a TypeError thrown from newSession (e.g. "something is
   // not a function") indicates a programming error, not a transient provider
@@ -1614,130 +1582,6 @@ test("autoLoop exits when s.active is set to false", async (t) => {
   );
 });
 
-test("autoLoop stops before dispatch when command context lacks newSession", async () => {
-  _resetPendingResolve();
-
-  const ctx = makeMockCtx();
-  ctx.ui.setStatus = () => {};
-  const pi = makeMockPi();
-  const s = makeLoopSession({
-    cmdCtx: {
-      getContextUsage: () => ({ percent: 10, tokens: 1000, limit: 10000 }),
-    },
-  });
-  let stopReason: string | undefined;
-  let preserveWorktree: boolean | undefined;
-  let deriveCalled = false;
-
-  try {
-    const deps = makeMockDeps({
-      stopAuto: async (_ctx, _pi, reason, options) => {
-        stopReason = reason;
-        preserveWorktree = options?.preserveWorktree;
-        s.active = false;
-      },
-      deriveState: async () => {
-        deriveCalled = true;
-        throw new Error("deriveState should not run without command session support");
-      },
-    });
-
-    await autoLoop(ctx, pi, s, deps);
-
-    assert.equal(stopReason, "Auto-mode has no command context for dispatch.");
-    assert.equal(preserveWorktree, true);
-    assert.equal(deriveCalled, false);
-    assert.equal(pi.calls.length, 0);
-  } finally {
-    rmSync(s.basePath, { recursive: true, force: true });
-  }
-});
-
-test("autoLoop commits open unit work when command context lacks newSession", async () => {
-  _resetPendingResolve();
-
-  const ctx = makeMockCtx();
-  ctx.ui.setStatus = () => {};
-  const pi = makeMockPi();
-  const s = makeLoopSession({
-    cmdCtx: {
-      getContextUsage: () => ({ percent: 10, tokens: 1000, limit: 10000 }),
-    },
-    currentUnit: { type: "execute-task", id: "T01", startedAt: Date.now() },
-  });
-  const outputPath = join(s.basePath, "executor-output.txt");
-  let autoCommitArgs: { unitType: string; unitId: string } | undefined;
-  let preserveWorktree: boolean | undefined;
-
-  try {
-    const deps = makeMockDeps({
-      autoCommitUnit: async (basePath, unitType, unitId) => {
-        autoCommitArgs = { unitType, unitId };
-        return autoCommitCurrentBranch(basePath, unitType, unitId);
-      },
-      stopAuto: async (_ctx, _pi, _reason, options) => {
-        preserveWorktree = options?.preserveWorktree;
-        s.active = false;
-      },
-      deriveState: async () => {
-        throw new Error("deriveState should not run without command session support");
-      },
-    });
-
-    writeFileSync(outputPath, "open unit work before stop\n", "utf-8");
-
-    await autoLoop(ctx, pi, s, deps);
-
-    assert.deepEqual(autoCommitArgs, { unitType: "execute-task", unitId: "T01" });
-    assert.equal(preserveWorktree, true);
-    const committed = execSync("git show HEAD:executor-output.txt", {
-      cwd: s.basePath,
-      encoding: "utf-8",
-    });
-    assert.equal(committed, "open unit work before stop\n");
-    assert.equal(pi.calls.length, 0);
-  } finally {
-    rmSync(s.basePath, { recursive: true, force: true });
-  }
-});
-
-test("autoLoop snapshots dirty work when unit dispatch crashes", async () => {
-  _resetPendingResolve();
-
-  const ctx = makeMockCtx();
-  ctx.ui.setStatus = () => {};
-  const pi = makeMockPi();
-  const s = makeLoopSession();
-  const outputPath = join(s.basePath, "executor-output.txt");
-  let autoCommitCalls = 0;
-
-  try {
-    const deps = makeMockDeps({
-      ensurePreconditions: () => {
-        writeFileSync(outputPath, "saved before crash\n", "utf-8");
-        throw new Error("dispatch crash after file write");
-      },
-      autoCommitUnit: async (basePath, unitType, unitId) => {
-        autoCommitCalls++;
-        const commitMsg = autoCommitCurrentBranch(basePath, unitType, unitId);
-        s.active = false;
-        return commitMsg;
-      },
-    });
-
-    await autoLoop(ctx, pi, s, deps);
-
-    assert.equal(autoCommitCalls, 1);
-    const committed = execSync("git show HEAD:executor-output.txt", {
-      cwd: s.basePath,
-      encoding: "utf-8",
-    });
-    assert.equal(committed, "saved before crash\n");
-  } finally {
-    rmSync(s.basePath, { recursive: true, force: true });
-  }
-});
-
 test("autoLoop pauses visibly when Auto Orchestration Module is not wired", async () => {
   _resetPendingResolve();
 

package/src/resources/extensions/gsd/tests/auto-start-index-lock.test.ts

@@ -4,7 +4,7 @@ import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { hasGitIndexLockForTest, reconcileFlatPhaseBootstrapLayout } from "../auto-start.ts";
+import { hasGitIndexLockForTest } from "../auto-start.ts";
 
 test("bootstrapAutoSession detects .git/index.lock without deleting it", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-index-lock-"));
@@ -24,23 +24,3 @@ test("bootstrapAutoSession reports no index lock when the lock file is absent",
 
   assert.equal(hasGitIndexLockForTest(base), false);
 });
-
-test("bootstrapAutoSession removes empty legacy milestones dir in flat-phase projects", (t) => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-flat-bootstrap-clean-"));
-  t.after(() => rmSync(base, { recursive: true, force: true }));
-  mkdirSync(join(base, ".gsd", "phases"), { recursive: true });
-  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
-
-  assert.equal(reconcileFlatPhaseBootstrapLayout(base), true);
-  assert.equal(existsSync(join(base, ".gsd", "phases")), true);
-  assert.equal(existsSync(join(base, ".gsd", "milestones")), false);
-});
-
-test("bootstrapAutoSession creates phases instead of milestones for empty GSD state", (t) => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-flat-bootstrap-init-"));
-  t.after(() => rmSync(base, { recursive: true, force: true }));
-
-  assert.equal(reconcileFlatPhaseBootstrapLayout(base), true);
-  assert.equal(existsSync(join(base, ".gsd", "phases")), true);
-  assert.equal(existsSync(join(base, ".gsd", "milestones")), false);
-});

package/src/resources/extensions/gsd/tests/auto-wrapup-inflight-guard.test.ts

@@ -3,8 +3,7 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { execSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -97,78 +96,6 @@ describe("hook dispatch session workspace root", () => {
     assert.equal(dispatched, true);
     assert.deepEqual(newSessionOptions, { workspaceRoot: basePath });
   });
-
-  test("dispatchHookUnit commits in-flight work when command context lacks newSession", async (t) => {
-    const originalCwd = process.cwd();
-    const basePath = realpathSync(mkdtempSync(join(tmpdir(), "gsd-hook-nosnap-")));
-    mkdirSync(join(basePath, ".gsd"), { recursive: true });
-    execSync("git init --initial-branch=main", { cwd: basePath, stdio: "ignore" });
-    execSync("git config user.email test@test.com", { cwd: basePath, stdio: "ignore" });
-    execSync("git config user.name Test", { cwd: basePath, stdio: "ignore" });
-    execSync("git commit --allow-empty -m init", { cwd: basePath, stdio: "ignore" });
-
-    autoSession.reset();
-    autoSession.active = true;
-    autoSession.basePath = basePath;
-    autoSession.originalBasePath = basePath;
-    // Simulate an in-flight unit whose executor already wrote files, then a hook
-    // fires with a command context missing newSession.
-    autoSession.currentUnit = {
-      type: "execute-task",
-      id: "M001/S01/T01",
-      startedAt: Date.now(),
-    };
-    t.after(() => {
-      try {
-        process.chdir(originalCwd);
-      } catch {
-        // best effort cleanup after cwd-sensitive dispatch tests
-      }
-      autoSession.reset();
-      rmSync(basePath, { recursive: true, force: true });
-    });
-
-    const outputPath = join(basePath, "executor-output.txt");
-    writeFileSync(outputPath, "in-flight executor work\n", "utf-8");
-
-    // Command context intentionally lacks newSession — the guard must snapshot
-    // the dirty work before stopping instead of discarding it.
-    const ctx = {
-      ui: {
-        notify: () => {},
-        setStatus: () => {},
-        setWidget: () => {},
-      },
-      modelRegistry: {
-        getAvailable: () => [],
-      },
-      sessionManager: {
-        getSessionFile: () => join(basePath, "session.jsonl"),
-      },
-    };
-    const pi = {
-      sendMessage: () => {},
-      setModel: async () => true,
-    };
-
-    const dispatched = await dispatchHookUnit(
-      ctx as any,
-      pi as any,
-      "review",
-      "execute-task",
-      "M001/S01/T01",
-      "review the completed unit",
-      undefined,
-      basePath,
-    );
-
-    assert.equal(dispatched, false);
-    const committed = execSync("git show HEAD:executor-output.txt", {
-      cwd: basePath,
-      encoding: "utf-8",
-    });
-    assert.equal(committed, "in-flight executor work\n");
-  });
 });
 
 describe("deep setup approval questions pause immediately", () => {

package/src/resources/extensions/gsd/tests/doctor-scope-db-unavailable.test.ts

@@ -167,45 +167,6 @@ test("checkEngineHealth keeps PLAN checkbox divergence after stale projection fl
   assert.match(readFileSync(plan.planPath, "utf-8"), /- \[ \] \*\*T01\*\*:/);
 });
 
-test("checkEngineHealth ignores stale suffixed flat-phase duplicate when bare milestone exists", async (t) => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-checkbox-flat-duplicate-"));
-  t.after(() => rmSync(base, { recursive: true, force: true }));
-
-  const gsdDir = join(base, ".gsd");
-  mkdirSync(gsdDir, { recursive: true });
-
-  openDatabase(join(gsdDir, "gsd.db"));
-  insertMilestone({ id: "M003", title: "M003-vaz73w: New milestone M003-vaz73w", status: "active" });
-  insertSlice({ id: "S01", milestoneId: "M003", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
-  for (const taskId of ["T01", "T02", "T03"]) {
-    insertTask({ id: taskId, milestoneId: "M003", sliceId: "S01", title: taskId, status: "complete", sequence: Number(taskId.slice(1)) });
-  }
-
-  insertMilestone({ id: "M003-vaz73w", title: "New milestone M003-vaz73w", status: "active" });
-  insertSlice({ id: "S01", milestoneId: "M003-vaz73w", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
-  for (const taskId of ["T01", "T02", "T03"]) {
-    insertTask({ id: taskId, milestoneId: "M003-vaz73w", sliceId: "S01", title: taskId, status: "complete", sequence: Number(taskId.slice(1)) });
-  }
-
-  const canonicalPlan = await renderPlanFromDb(base, "M003", "S01");
-  const staleDir = join(gsdDir, "phases", "03-vaz73w-new-milestone-m003-vaz73w");
-  mkdirSync(staleDir, { recursive: true });
-  writeFileSync(
-    join(staleDir, "03-01-PLAN.md"),
-    canonicalPlan.content.replace("- [x] **T03**:", "- [ ] **T03**:"),
-    "utf-8",
-  );
-
-  const issues: any[] = [];
-  await checkEngineHealth(base, issues, []);
-
-  assert.deepEqual(
-    issues.filter((issue) => issue.code === "checkbox_db_status_divergence").map((issue) => issue.unitId),
-    [],
-    "stale suffixed duplicate phase projection must not compete with the bare milestone projection",
-  );
-});
-
 test("checkEngineHealth reads task checkboxes from the <tasks> block, not a stray line above it", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-task-section-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -467,50 +428,6 @@ test("checkEngineHealth repair prunes stale phases artifact rows with present mi
   assert.deepEqual(rows.map((row) => row.path), []);
 });
 
-test("checkEngineHealth repair prunes stale phases artifact rows with renamed flat-phase files", async (t) => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-prune-renamed-flat-phase-artifact-"));
-  t.after(() => rmSync(base, { recursive: true, force: true }));
-
-  const gsdDir = join(base, ".gsd");
-  const stalePath = "phases/01-new-milestone-m001/01-01-PLAN.md";
-  const replacementPath = "phases/01-lokably-brand-foundation-and-welcome-pag/01-01-PLAN.md";
-  mkdirSync(join(gsdDir, "phases", "01-lokably-brand-foundation-and-welcome-pag"), { recursive: true });
-  writeFileSync(join(gsdDir, replacementPath), "# Plan\n", "utf-8");
-
-  openDatabase(join(gsdDir, "gsd.db"));
-  insertArtifact({
-    path: stalePath,
-    artifact_type: "PLAN",
-    milestone_id: "M001",
-    slice_id: "S01",
-    task_id: null,
-    full_content: "# stale plan\n",
-  });
-
-  const beforeIssues: any[] = [];
-  await checkEngineHealth(base, beforeIssues, []);
-
-  const beforeIssue = beforeIssues.find((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath);
-  assert.ok(beforeIssue, "stale renamed phases row should be reported when repair is off");
-  assert.equal(beforeIssue.fixable, true, "renamed phases rows with a flat replacement should be fixable");
-
-  const repairIssues: any[] = [];
-  const fixes: string[] = [];
-  await checkEngineHealth(base, repairIssues, fixes, { repair: true });
-
-  assert.equal(
-    repairIssues.some((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath),
-    false,
-    "repair should not report stale rows it pruned",
-  );
-  assert.ok(fixes.includes(`pruned stale flat-phase artifact row ${stalePath}`));
-
-  const rows = _getAdapter()!
-    .prepare("SELECT path FROM artifacts ORDER BY path")
-    .all() as Array<{ path: string }>;
-  assert.deepEqual(rows.map((row) => row.path), []);
-});
-
 test("checkEngineHealth repair keeps phases rows whose own file is still present", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-keep-present-phase-artifact-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/flat-phase-migration.test.ts

@@ -122,7 +122,7 @@ test("migrateToFlatPhase creates a backup", async () => {
   assert.ok(backups.length >= 1, "at least one migrate-* backup dir should exist");
 });
 
-test("migrateToFlatPhase removes disposable phases snapshot after successful migration", async () => {
+test("migrateToFlatPhase backs up existing phases projection before clearing it", async () => {
   const base = makeTmp();
   const reviewPath = join(base, ".gsd", "phases", "01-foundation", "PLAN-REVIEW.md");
   mkdirSync(join(base, ".gsd", "phases", "01-foundation"), { recursive: true });
@@ -133,10 +133,11 @@ test("migrateToFlatPhase removes disposable phases snapshot after successful mig
   const backupRoot = join(base, ".gsd-backups");
   const backups = readdirSync(backupRoot).filter(d => d.startsWith("migrate-"));
   assert.equal(backups.length, 1, "one migrate backup should exist");
+  const backedUpReview = join(backupRoot, backups[0]!, "__phases", "01-foundation", "PLAN-REVIEW.md");
   assert.equal(
-    existsSync(join(backupRoot, backups[0]!, "__phases")),
-    false,
-    "temporary phases/ recovery snapshot should be removed after success",
+    readFileSync(backedUpReview, "utf-8"),
+    "# Plan Review\n\nHand-authored review.",
+    "pre-existing phases/ files should have a recovery copy",
   );
 });
 
@@ -201,7 +202,7 @@ test("failed migration rolls back without leaking a .gsd-backups/migrate-* dir",
   assert.equal(leaked.length, 0, "rollback must delete the migrate-* backup it created");
 });
 
-test("resumed migration removes disposable phases snapshot after success", async () => {
+test("resumed migration stores phases backup in retained migrate snapshot", async () => {
   const base = makeTmp();
   const milestonesPath = join(base, ".gsd", "milestones");
   const migratingPath = join(base, ".gsd", "milestones.migrating");
@@ -217,9 +218,9 @@ test("resumed migration removes disposable phases snapshot after success", async
   const backups = readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"));
   assert.equal(backups.length, 1, "resumed migration should create one retained migrate backup");
   assert.equal(
-    existsSync(join(backupRoot, backups[0]!, "__phases")),
-    false,
-    "temporary phases/ recovery snapshot should be removed after resumed success",
+    readFileSync(join(backupRoot, backups[0]!, "__phases", "01-foundation", "PLAN-REVIEW.md"), "utf-8"),
+    "# Plan Review\n\nResume recovery copy.",
+    "resume should retain the phases snapshot under .gsd-backups",
   );
   assert.equal(
     existsSync(join(migratingPath, "__phases")),

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

@@ -46,9 +46,6 @@ import {
   tryCreateMemoriesFts,
   _isLikelyWslDrvFsPathForTest,
   _shouldAttemptVacuumRecoveryForTest,
-  insertArtifact,
-  getArtifact,
-  upsertMilestonePlanning,
 } from '../gsd-db.ts';
 import { MigrationBackupError } from '../db-migration-backup.ts';
 import { _resetLogs, peekLogs, setStderrLoggingEnabled } from '../workflow-logger.ts';
@@ -360,35 +357,6 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
-  test("gsd-db: upsertMilestonePlanning rewrites placeholder phase artifact paths to final title slug", () => {
-    openDatabase(":memory:");
-
-    const stalePath = "phases/01-new-milestone-m001/01-ROADMAP.md";
-    const finalPath = "phases/01-lokably-brand-foundation-and-welcome-pag/01-ROADMAP.md";
-    insertMilestone({ id: "M001", title: "New milestone M001", status: "active" });
-    insertArtifact({
-      path: stalePath,
-      artifact_type: "ROADMAP",
-      milestone_id: "M001",
-      slice_id: null,
-      task_id: null,
-      full_content: "# Placeholder roadmap\n",
-    });
-
-    upsertMilestonePlanning("M001", {
-      title: "Lokably brand foundation and welcome page rebuild",
-    });
-
-    assert.equal(getArtifact(stalePath), null, "placeholder-derived artifact row should be removed");
-    assert.equal(
-      getArtifact(finalPath)?.full_content,
-      "# Placeholder roadmap\n",
-      "artifact row should move to the final title-derived phase path",
-    );
-
-    closeDatabase();
-  });
-
   test('gsd-db: active_requirements view excludes superseded', () => {
     openDatabase(':memory:');
 

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

@@ -1428,19 +1428,6 @@ process.exit(result.status ?? 0);
     rmSync(repo, { recursive: true, force: true });
   });
 
-  test('Integration branch: write does not create legacy milestones scaffold', () => {
-    const repo = initBranchTestRepo();
-    mkdirSync(join(repo, ".gsd", "phases"), { recursive: true });
-
-    writeIntegrationBranch(repo, "M001", "f-123-new-thing");
-
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "f-123-new-thing");
-    assert.ok(existsSync(join(repo, ".gsd", "M001-META.json")), "metadata is written at the flat .gsd root");
-    assert.ok(!existsSync(join(repo, ".gsd", "milestones")), "legacy milestones/ root is not created");
-
-    rmSync(repo, { recursive: true, force: true });
-  });
-
   // ─── writeIntegrationBranch: updates when branch changes (#300) ──────
 
   test('Integration branch: updates on branch change', () => {

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

@@ -117,8 +117,8 @@ test("projectRootToWorktree projects flat-phase discuss artifacts before dispatc
     new WorktreeStateProjection().projectRootToWorktree(scope);
 
     assert.ok(
-      !existsSync(join(worktree, ".gsd", "milestones")),
-      "stale metadata-only legacy milestones/ scaffold is not projected into the worktree",
+      existsSync(join(worktree, ".gsd", "milestones", "M001", "M001-META.json")),
+      "milestone metadata is projected into the worktree",
     );
     assert.ok(
       existsSync(join(worktree, ".gsd", "phases", "01-foundation", "01-CONTEXT.md")),

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -246,66 +246,6 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
-  // ─── 7b. flat-phase sync skips empty legacy milestones root ───────────
-  console.log('\n=== 7b. flat-phase sync skips empty legacy milestones root ===');
-  {
-    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-flat-main-'));
-    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-flat-wt-'));
-
-    try {
-      const phaseDir = join(mainBase, '.gsd', 'phases', '01-foundation');
-      mkdirSync(phaseDir, { recursive: true });
-      mkdirSync(join(mainBase, '.gsd', 'milestones'), { recursive: true });
-      mkdirSync(join(wtBase, '.gsd'), { recursive: true });
-      writeFileSync(join(phaseDir, '01-CONTEXT.md'), '# Foundation\n');
-
-      syncGsdStateToWorktree(mainBase, wtBase);
-
-      assert.ok(
-        existsSync(join(wtBase, '.gsd', 'phases', '01-foundation', '01-CONTEXT.md')),
-        'flat-phase artifact is synced to worktree',
-      );
-      assert.ok(
-        !existsSync(join(wtBase, '.gsd', 'milestones')),
-        'empty legacy milestones/ root is not recreated in worktree',
-      );
-    } finally {
-      rmSync(mainBase, { recursive: true, force: true });
-      rmSync(wtBase, { recursive: true, force: true });
-    }
-  }
-
-  // ─── 7c. flat-phase sync skips metadata-only legacy milestone dirs ────
-  console.log('\n=== 7c. flat-phase sync skips metadata-only legacy milestone dirs ===');
-  {
-    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-flat-meta-main-'));
-    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-flat-meta-wt-'));
-
-    try {
-      const phaseDir = join(mainBase, '.gsd', 'phases', '01-foundation');
-      const metaDir = join(mainBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(phaseDir, { recursive: true });
-      mkdirSync(metaDir, { recursive: true });
-      mkdirSync(join(wtBase, '.gsd'), { recursive: true });
-      writeFileSync(join(phaseDir, '01-CONTEXT.md'), '# Foundation\n');
-      writeFileSync(join(metaDir, 'M001-META.json'), '{"integrationBranch":"main"}\n');
-
-      syncGsdStateToWorktree(mainBase, wtBase);
-
-      assert.ok(
-        existsSync(join(wtBase, '.gsd', 'phases', '01-foundation', '01-CONTEXT.md')),
-        'flat-phase artifact is synced to worktree',
-      );
-      assert.ok(
-        !existsSync(join(wtBase, '.gsd', 'milestones')),
-        'metadata-only legacy milestones/ scaffold is not recreated in worktree',
-      );
-    } finally {
-      rmSync(mainBase, { recursive: true, force: true });
-      rmSync(wtBase, { recursive: true, force: true });
-    }
-  }
-
   // ─── 8. syncWorktreeStateBack does not copy task projections ───────────
   console.log('\n=== 8. syncWorktreeStateBack leaves task projections in worktree ===');
   {

package/src/resources/extensions/gsd/worktree-state-projection.ts

@@ -32,7 +32,7 @@ import {
 import { join } from "node:path";
 
 import { reconcileWorktreeDb } from "./gsd-db.js";
-import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
+import { resolveGsdPathContract } from "./paths.js";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import type { MilestoneScope } from "./workspace.js";
 import { logError, logWarning } from "./workflow-logger.js";
@@ -161,7 +161,6 @@ function syncOtherMilestoneArtifacts(
       // additive safeCopyRecursive; skip it here to avoid redundant work.
       if (milestoneEntry.name === currentMilestoneId) continue;
       const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
-      if (!dirIsContentBearingLegacyMilestone(srcMilestoneDir)) continue;
       const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
 
       // Additively project the entire milestone subtree (force:false), not just
@@ -272,32 +271,36 @@ export function _projectRootToWorktreeImpl(
   // Without this, worktree-local files (e.g. VALIDATION.md written
   // by validate-milestone) get clobbered by stale project root copies,
   // causing an infinite re-validation loop (#1886).
-  const prMilestoneDir = join(prGsd, "milestones", milestoneId);
-  const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
-  if (dirIsContentBearingLegacyMilestone(prMilestoneDir)) {
-    safeCopyRecursive(prMilestoneDir, wtMilestoneDir, { force: false });
-
-    // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
-    // The additive-only copy above preserves worktree-local files, but
-    // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
-    // syncs it to the project root, the worktree may retain a stale copy (e.g.
-    // verdict:fail while the project root has verdict:pass from a retry). On
-    // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
-    // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
-    // run-uat indefinitely (stuck-loop ×9).
-    forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
-    forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
-  }
+  safeCopyRecursive(
+    join(prGsd, "milestones", milestoneId),
+    join(wtGsd, "milestones", milestoneId),
+    { force: false },
+  );
 
-  // Additively project the full subtree of every OTHER content-bearing legacy
-  // milestone so worktree-bound units can read prior-milestone context artifacts
-  // without recreating empty/meta-only milestones/ scaffolds in flat-phase projects.
+  // Additively project the full subtree of every OTHER milestone so
+  // worktree-bound units can read prior-milestone context artifacts and so
+  // completed milestones retain their per-slice/per-task SUMMARY.md and
+  // UAT.md on the worktree filesystem (otherwise the stale-render detector
+  // flags them as "complete in DB but missing on disk").
   syncOtherMilestoneArtifacts(
     join(prGsd, "milestones"),
     join(wtGsd, "milestones"),
     milestoneId,
   );
 
+  // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
+  // The additive-only copy above preserves worktree-local files, but
+  // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
+  // syncs it to the project root, the worktree may retain a stale copy (e.g.
+  // verdict:fail while the project root has verdict:pass from a retry). On
+  // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
+  // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
+  // run-uat indefinitely (stuck-loop ×9).
+  const prMilestoneDir = join(prGsd, "milestones", milestoneId);
+  const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
+  forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
+  forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
+
   // Forward-sync completed-units.json from project root to worktree.
   // Project root is authoritative for completion state after crash recovery;
   // without this, the worktree re-dispatches already-completed units (#1886).

package/packages/gsd-cloud/dist/background-cli.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=background-cli.test.d.ts.map

package/packages/gsd-cloud/dist/background-cli.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"background-cli.test.d.ts","sourceRoot":"","sources":["../src/background-cli.test.ts"],"names":[],"mappings":""}