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

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

@@ -57,6 +57,19 @@ test("needsFlatPhaseMigration returns false when no .gsd/milestones/", () => {
   assert.equal(needsFlatPhaseMigration(base), false);
 });
 
+test("needsFlatPhaseMigration ignores legacy anchor runtime scaffolding", () => {
+  const base = mkdtempSync(join(tmpdir(), `gsd-anchor-nomig-${randomUUID()}`));
+  mkdirSync(join(base, ".gsd", "phases"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "anchors"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "anchors", "research-slice.json"),
+    "{}",
+    "utf-8",
+  );
+  tmpDirs.push(base);
+  assert.equal(needsFlatPhaseMigration(base), false);
+});
+
 test("migrateToFlatPhase moves content from milestones/ to phases/", async () => {
   const base = makeTmp();
   await migrateToFlatPhase(base);
@@ -109,6 +122,58 @@ 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 () => {
+  const base = makeTmp();
+  const reviewPath = join(base, ".gsd", "phases", "01-foundation", "PLAN-REVIEW.md");
+  mkdirSync(join(base, ".gsd", "phases", "01-foundation"), { recursive: true });
+  writeFileSync(reviewPath, "# Plan Review\n\nHand-authored review.", "utf-8");
+
+  await migrateToFlatPhase(base);
+
+  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");
+  assert.equal(
+    existsSync(join(backupRoot, backups[0]!, "__phases")),
+    false,
+    "temporary phases/ recovery snapshot should be removed after success",
+  );
+});
+
+test("failed migration restores pre-existing phases projection from backup", async (t) => {
+  const base = makeTmp();
+  const phasesPath = join(base, ".gsd", "phases");
+  const reviewPath = join(phasesPath, "01-foundation", "PLAN-REVIEW.md");
+  mkdirSync(join(phasesPath, "01-foundation"), { recursive: true });
+  writeFileSync(reviewPath, "# Plan Review\n\nHand-authored review.", "utf-8");
+
+  let sabotagedClear = false;
+  const restoreFsOps = _setFlatPhaseMigrationFsOpsForTest({
+    rmSync(target, opts) {
+      rmSync(target, opts as never);
+      if (target === phasesPath && !sabotagedClear) {
+        sabotagedClear = true;
+        writeFileSync(phasesPath, "not a directory", "utf-8");
+      }
+    },
+  });
+  t.after(restoreFsOps);
+
+  await assert.rejects(migrateToFlatPhase(base), /flat-phase migration render failed/);
+
+  assert.equal(sabotagedClear, true, "test should force a post-clear render failure");
+  assert.equal(
+    readFileSync(reviewPath, "utf-8"),
+    "# Plan Review\n\nHand-authored review.",
+    "rollback should restore the pre-existing phases/ files",
+  );
+  const backupRoot = join(base, ".gsd-backups");
+  const leaked = existsSync(backupRoot)
+    ? readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"))
+    : [];
+  assert.equal(leaked.length, 0, "rollback should still clean the backup it created");
+});
+
 test("failed migration rolls back without leaking a .gsd-backups/migrate-* dir", async (t) => {
   const base = makeTmp();
   const milestonesPath = join(base, ".gsd", "milestones");
@@ -136,6 +201,33 @@ 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 () => {
+  const base = makeTmp();
+  const milestonesPath = join(base, ".gsd", "milestones");
+  const migratingPath = join(base, ".gsd", "milestones.migrating");
+  const reviewPath = join(base, ".gsd", "phases", "01-foundation", "PLAN-REVIEW.md");
+  mkdirSync(join(base, ".gsd", "phases", "01-foundation"), { recursive: true });
+  writeFileSync(reviewPath, "# Plan Review\n\nResume recovery copy.", "utf-8");
+  renameSync(milestonesPath, migratingPath);
+
+  await migrateToFlatPhase(base);
+
+  assert.equal(existsSync(migratingPath), false, "resume staging dir should be removed after success");
+  const backupRoot = join(base, ".gsd-backups");
+  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",
+  );
+  assert.equal(
+    existsSync(join(migratingPath, "__phases")),
+    false,
+    "resume should not store the phases snapshot inside the disposable migrating tree",
+  );
+});
+
 test("migrateToFlatPhase preserves milestone/slice/task counts in DB", async () => {
   const base = makeTmp();
   const msBefore = getAllMilestones().length;
@@ -190,6 +282,42 @@ test("migrateToFlatPhase prunes legacy milestones artifact rows after flat rende
   );
 });
 
+test("migrateToFlatPhase prunes stale flat-phase artifact rows that renderAll intentionally skips", async () => {
+  const base = makeTmp();
+  insertArtifact({
+    path: "phases/01-foundation/T01-PLAN.md",
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: "T01",
+    full_content: "# Legacy standalone task plan\n",
+  });
+  insertArtifact({
+    path: "phases/01-foundation/01-01-RESEARCH.md",
+    artifact_type: "RESEARCH",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "",
+  });
+
+  await migrateToFlatPhase(base);
+
+  const rows = _getAdapter()!
+    .prepare("SELECT path FROM artifacts ORDER BY path")
+    .all() as Array<{ path: string }>;
+  assert.equal(
+    rows.some((row) => row.path === "phases/01-foundation/T01-PLAN.md"),
+    false,
+    "standalone task PLAN rows should be pruned when the flat renderer does not recreate the file",
+  );
+  assert.equal(
+    rows.some((row) => row.path === "phases/01-foundation/01-01-RESEARCH.md"),
+    false,
+    "empty-content artifact rows should be pruned when the flat renderer skips the file",
+  );
+});
+
 test("migrateToFlatPhase is idempotent (second run is a no-op)", async () => {
   const base = makeTmp();
   await migrateToFlatPhase(base);
@@ -199,6 +327,79 @@ test("migrateToFlatPhase is idempotent (second run is a no-op)", async () => {
   assert.equal(backups.length, 1, "should only have one backup");
 });
 
+test("re-fired migration reuses the existing backup instead of leaking a new migrate-* dir (#1292)", async () => {
+  const base = makeTmp();
+  await migrateToFlatPhase(base);
+  const backupRoot = join(base, ".gsd-backups");
+  const firstBackups = readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"));
+  assert.equal(firstBackups.length, 1, "first migration snapshots exactly one backup");
+
+  // Simulate the re-fire: the legacy .gsd/milestones/ layout reappears (e.g. a
+  // marker-key mismatch re-imports the whole tree). The DB rows still exist, so
+  // the migration gate proceeds again — it must not snapshot a second backup.
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01"), { recursive: true });
+  assert.equal(needsFlatPhaseMigration(base), true, "reappeared legacy layout re-triggers migration");
+
+  await migrateToFlatPhase(base);
+
+  const afterBackups = readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"));
+  assert.deepEqual(afterBackups, firstBackups, "re-fire must not leak a second migrate-* backup");
+  assert.equal(existsSync(join(base, ".gsd", "milestones")), false, "legacy milestones/ removed again");
+});
+
+test("rollback after a re-fired migration preserves the reused migrate-* backup", async (t) => {
+  const base = makeTmp();
+  await migrateToFlatPhase(base);
+  const backupRoot = join(base, ".gsd-backups");
+  const firstBackups = readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"));
+  assert.equal(firstBackups.length, 1, "first migration snapshots exactly one backup");
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01"), { recursive: true });
+  const milestonesPath = join(base, ".gsd", "milestones");
+  const phasesPath = join(base, ".gsd", "phases");
+
+  const restoreFsOps = _setFlatPhaseMigrationFsOpsForTest({
+    rmSync(target, opts) {
+      if (target === phasesPath) {
+        throw Object.assign(new Error("simulated locked phases/"), { code: "EPERM" });
+      }
+      return rmSync(target, opts as never);
+    },
+  });
+  t.after(restoreFsOps);
+
+  await assert.rejects(migrateToFlatPhase(base), /simulated locked/);
+
+  const afterBackups = readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"));
+  assert.deepEqual(afterBackups, firstBackups, "rollback must preserve the reused backup");
+  assert.ok(existsSync(milestonesPath), "legacy milestones/ should be restored on rollback");
+});
+
+test("migration ignores an empty/partial leftover backup and writes a complete one (#1292)", async () => {
+  const base = makeTmp();
+
+  // Simulate a prior first-time backup that crashed mid-cpSync: an empty
+  // migrate-<ts>/ leftover with no milestones/ content. It is the newest entry,
+  // so mtime-based selection would reuse it as the rollback copy if content were
+  // not validated — silently retaining a recovery copy missing the legacy tree.
+  const backupRoot = join(base, ".gsd-backups");
+  const emptyLeftover = join(backupRoot, "migrate-crashed");
+  mkdirSync(emptyLeftover, { recursive: true });
+
+  await migrateToFlatPhase(base);
+
+  assert.ok(existsSync(join(base, ".gsd", "phases", "01-foundation")), "flat phase should render");
+  // The empty leftover must not have been reused; a fresh, content-bearing
+  // backup that actually captured the legacy milestones/ tree must be created.
+  const contentBackups = readdirSync(backupRoot)
+    .filter((d) => d.startsWith("migrate-"))
+    .filter((d) => existsSync(join(backupRoot, d, "M001")));
+  assert.ok(
+    contentBackups.length >= 1,
+    "a complete backup containing the legacy milestones/ tree must be created, not the empty leftover",
+  );
+});
+
 test("migrateToFlatPhase preserves slice sidecar artifacts and skips recovery placeholder PLAN", async () => {
   const base = makeTmp({ withTask: false });
   const legacySliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");

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

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { normalizeRealPath, relMilestoneFile, relSliceFile, resolveMilestoneFile, targetMilestoneFile } from "../paths.ts";
+import { normalizeRealPath, relMilestoneFile, relSliceFile, resolveMilestoneFile, resolveSliceFile, targetMilestoneFile } from "../paths.ts";
 
 function makeFlatPhaseFixture(): { basePath: string; cleanup: () => void } {
   const basePath = mkdtempSync(join(tmpdir(), "flat-phase-validation-"));
@@ -99,6 +99,25 @@ test("flat-phase: resolveMilestoneFile finds the on-disk file", (t) => {
   assert.equal(existsSync(abs!), true);
 });
 
+test("flat-phase: file resolvers ignore directories with artifact-like names", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "flat-phase-dir-artifacts-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  const phaseDir = join(basePath, ".gsd", "phases", "03-match-capture-manual-entry");
+  mkdirSync(join(phaseDir, "03-VALIDATION.md"), { recursive: true });
+  mkdirSync(join(phaseDir, "03-01-SUMMARY.md"), { recursive: true });
+
+  assert.equal(
+    resolveMilestoneFile(basePath, "M003", "VALIDATION"),
+    null,
+    "milestone resolver must not return a directory as a validation file",
+  );
+  assert.equal(
+    resolveSliceFile(basePath, "M003", "S01", "SUMMARY"),
+    null,
+    "slice resolver must not return a directory as a summary file",
+  );
+});
+
 test("flat-phase: the legacy hardcoded path does NOT resolve (regression for #876)", (t) => {
   const { basePath, cleanup } = makeFlatPhaseFixture();
   t.after(cleanup);

package/src/resources/extensions/gsd/tests/gate-storage.test.ts

@@ -19,6 +19,11 @@ import {
   insertMilestone,
   insertSlice,
 } from "../gsd-db.ts";
+import { getDb } from "../db/engine.ts";
+
+function gateRunCount(gateId: string): number {
+  return (getDb().prepare("SELECT count(*) AS cnt FROM gate_runs WHERE gate_id = :gid").get({ ":gid": gateId }) as { cnt: number }).cnt;
+}
 
 describe("quality_gates CRUD", () => {
   let tmpDir: string;
@@ -83,6 +88,30 @@ describe("quality_gates CRUD", () => {
     assert.ok(results[0].evaluated_at);
   });
 
+  test("saveGateResult commits the verdict and the gate_runs ledger row together", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    saveGateResult({
+      milestoneId: "M001", sliceId: "S01", gateId: "Q3",
+      verdict: "pass", rationale: "OK", findings: "",
+    });
+    assert.equal(getGateResults("M001", "S01")[0].status, "complete");
+    assert.equal(gateRunCount("Q3"), 1, "exactly one ledger row must accompany the verdict");
+  });
+
+  test("saveGateResult rolls back the verdict UPDATE if the ledger INSERT fails", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    // Force the insertGateRun step to throw after the UPDATE by removing the
+    // ledger table. Atomicity means the gate row must stay pending.
+    getDb().exec("DROP TABLE gate_runs");
+    assert.throws(() => saveGateResult({
+      milestoneId: "M001", sliceId: "S01", gateId: "Q3",
+      verdict: "pass", rationale: "OK", findings: "",
+    }));
+    const gate = getGateResults("M001", "S01")[0];
+    assert.equal(gate.status, "pending", "gate verdict UPDATE must roll back when the ledger INSERT fails");
+    assert.equal(gate.verdict ?? "", "", "verdict must not persist after rollback");
+  });
+
   test("saveGateResult throws when the gate row does not exist", () => {
     assert.throws(
       () => saveGateResult({

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

@@ -46,6 +46,9 @@ 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';
@@ -280,6 +283,31 @@ describe('gsd-db', () => {
     }
   });
 
+  test("gsd-db: insertTask stamps completed_at for every complete-alias but not for skipped", () => {
+    openDatabase(":memory:");
+
+    try {
+      insertMilestone({ id: "M001", title: "Completion stamp", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active", sequence: 1 });
+      insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Closed", status: "closed", sequence: 1 });
+      insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Done", status: "done", sequence: 2 });
+      insertTask({ id: "T03", sliceId: "S01", milestoneId: "M001", title: "Skipped", status: "skipped", sequence: 3 });
+
+      assert.ok(
+        getTask("M001", "S01", "T01")?.completed_at,
+        "a task imported as 'closed' is terminal and must carry a completed_at",
+      );
+      assert.ok(getTask("M001", "S01", "T02")?.completed_at, "'done' alias must stamp completed_at");
+      assert.equal(
+        getTask("M001", "S01", "T03")?.completed_at,
+        null,
+        "a skipped task was never completed and must have null completed_at",
+      );
+    } finally {
+      closeDatabase();
+    }
+  });
+
   test('gsd-db: active_decisions view excludes superseded', () => {
     openDatabase(':memory:');
 
@@ -332,6 +360,35 @@ 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/guided-discuss-milestone-prompt-rendering.test.ts

@@ -87,6 +87,28 @@ test("guided milestone prompt builder preloads milestone planning context", asyn
   }
 });
 
+test("guided milestone prompt builder prepends configured response language", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-language-"));
+  const gsdHome = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-language-home-"));
+  const previousGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = gsdHome;
+
+  try {
+    writeFileSync(join(gsdHome, "PREFERENCES.md"), "---\nversion: 1\nlanguage: 中文\n---\n", "utf-8");
+
+    const prompt = await buildDiscussMilestonePrompt("M001", "Language Preference", base, "true", {
+      includeContextMode: false,
+    });
+
+    assert.match(prompt, /^## Response Language\n\nAlways respond in 中文/);
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(gsdHome, { recursive: true, force: true });
+  }
+});
+
 test("guided milestone prompt builder caps prior draft seed before interpolation", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-draft-cap-"));
   const previousGsdHome = process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/import-slice-milestone-completion-preserve.test.ts

@@ -0,0 +1,116 @@
+// Project/App: gsd-pi
+// File Purpose: Regression for #1291 — a full markdown re-import must NOT rewrite
+// the completed_at of an already-complete slice or milestone with the current
+// import time. The task path was fixed for this (#1222/#1228) via
+// preserveCompletionMetadata; the slice and milestone backfills in
+// migrateHierarchyToDb had no such guard, so every re-import re-stamped every
+// complete slice/milestone. The fix threads preserveCompletion through
+// updateSliceStatus/updateMilestoneStatus so an existing completed_at survives.
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  getAllMilestones,
+  getMilestoneSlices,
+  updateSliceStatus,
+  updateMilestoneStatus,
+} from '../gsd-db.ts';
+import { migrateHierarchyToDb } from '../md-importer.ts';
+import { describe, test, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+
+const tmpDirs: string[] = [];
+afterEach(() => {
+  closeDatabase();
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-preserve-completion-'));
+  tmpDirs.push(base);
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, '.gsd', relativePath);
+  mkdirSync(join(full, '..'), { recursive: true });
+  writeFileSync(full, content);
+}
+
+// All slices [x] → milestone imports complete, slices import complete.
+const ROADMAP_ALL_DONE = `# M001: Finished Milestone
+
+**Vision:** Done work.
+
+## Slices
+
+- [x] **S01: First Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+
+- [x] **S02: Second Slice** \`risk:medium\` \`depends:[S01]\`
+  > After this: Also done.
+`;
+
+const REAL_S01 = '2026-07-05T19:52:04.672Z';
+const REAL_S02 = '2026-07-05T20:36:51.313Z';
+const REAL_M001 = '2026-07-05T21:00:00.000Z';
+
+describe('migrateHierarchyToDb: re-import preserves existing completion timestamps (#1291)', () => {
+  test('a re-import does not rewrite already-complete slice completed_at', () => {
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    // Simulate the durable completion timestamps the real run wrote hours apart.
+    updateSliceStatus('M001', 'S01', 'complete', REAL_S01);
+    updateSliceStatus('M001', 'S02', 'complete', REAL_S02);
+
+    // A second full re-import (the class of event that bit the reporter).
+    migrateHierarchyToDb(base);
+
+    const slices = getMilestoneSlices('M001');
+    const s01 = slices.find((s) => s.id === 'S01')!;
+    const s02 = slices.find((s) => s.id === 'S02')!;
+    assert.equal(s01.completed_at, REAL_S01, 'S01 completed_at must survive re-import unchanged');
+    assert.equal(s02.completed_at, REAL_S02, 'S02 completed_at must survive re-import unchanged');
+  });
+
+  test('a re-import does not rewrite an already-complete milestone completed_at', () => {
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    updateMilestoneStatus('M001', 'complete', REAL_M001);
+
+    migrateHierarchyToDb(base);
+
+    const m001 = getAllMilestones().find((m) => m.id === 'M001')!;
+    assert.equal(m001.completed_at, REAL_M001, 'M001 completed_at must survive re-import unchanged');
+  });
+
+  test('an initial import of a complete slice still backfills a completed_at when the row has none', () => {
+    // The guard preserves an existing timestamp but must not suppress the
+    // legitimate first-time backfill for a slice imported as complete.
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    const slices = getMilestoneSlices('M001');
+    for (const s of slices) {
+      assert.ok(s.completed_at, `complete slice ${s.id} should receive a backfilled completed_at on first import`);
+    }
+    const m001 = getAllMilestones().find((m) => m.id === 'M001')!;
+    assert.ok(m001.completed_at, 'complete milestone should receive a backfilled completed_at on first import');
+  });
+});

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

@@ -1428,6 +1428,19 @@ 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/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, symlinkSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -12,6 +12,8 @@ import {
   resolveGsdPathContract,
   resolveSliceFile,
   resolveTaskFile,
+  resolveTaskFiles,
+  taskIdFromTaskFileName,
   _clearGsdRootCache,
 } from "../../paths.ts";
 /** Create a tmp dir and resolve symlinks + 8.3 short names (macOS /var→/private/var, Windows RUNNER~1→runneradmin). */
@@ -171,21 +173,37 @@ describe('paths', () => {
   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
+      // Hybrid flat-phase milestone: phase dir holds flat task summaries, 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");
+      const flatSummary = join(phaseDir, "S01-T01-SUMMARY.md");
+      const legacyFlatSummary = join(phaseDir, "T01-SUMMARY.md");
       writeFileSync(flatSummary, "# task summary\n");
+      writeFileSync(legacyFlatSummary, "# legacy task summary\n");
 
       _clearGsdRootCache();
 
+      assert.deepStrictEqual(resolveTaskFiles(phaseDir, "SUMMARY").sort(), [
+        "S01-T01-SUMMARY.md",
+        "T01-SUMMARY.md",
+      ]);
+      assert.equal(taskIdFromTaskFileName("S01-T01-SUMMARY.md", "SUMMARY"), "T01");
+      assert.equal(taskIdFromTaskFileName("T01-SUMMARY.md", "SUMMARY"), "T01");
+
       assert.deepStrictEqual(
         resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
         flatSummary,
-        "flat-phase TID-SUMMARY.md at phase root is found even when slices/S01/ exists",
+        "flat-phase S01-T01-SUMMARY.md at phase root is preferred even when slices/S01/ exists",
+      );
+
+      unlinkSync(flatSummary);
+      assert.deepStrictEqual(
+        resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
+        legacyFlatSummary,
+        "legacy flat T01-SUMMARY.md is still found as a fallback",
       );
     } finally { cleanup(root); }
   });