@opengsd/gsd-pi 1.5.0 → 1.6.0-dev.aa7f94e8

package/src/resources/extensions/gsd/tests/compat-marker.test.ts

@@ -12,6 +12,7 @@ import {
   writeCompatMarker,
   normalizeForHash,
   computeProjectionSha,
+  pruneOrphanedProjectionEntries,
   EMPTY_MARKER,
   compatMarkerPath,
 } from "../compat/compat-marker.ts";
@@ -103,3 +104,87 @@ test("compatMarkerPath resolves under .gsd", () => {
   const base = makeTmpBase();
   assert.equal(compatMarkerPath(base), join(base, ".gsd", ".compat.json"));
 });
+
+test("pruneOrphanedProjectionEntries drops entries whose backing file is gone (#1257)", () => {
+  const base = makeTmpBase();
+  // Live projection: file exists on disk.
+  const liveRel = "phases/29-frontend-code-debt-cleanup/29-ROADMAP.md";
+  mkdirSync(join(base, ".gsd", "phases", "29-frontend-code-debt-cleanup"), { recursive: true });
+  writeFileSync(join(base, ".gsd", liveRel), "# M029\n", "utf-8");
+  // Phantom projection: directory was renamed, file no longer exists.
+  const ghostRel = "phases/29-new-milestone-m029/29-ROADMAP.md";
+
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-05T05:35:19.379Z",
+    projections: {
+      [liveRel]: { sha: "live000000000000", entities: ["M029"] },
+      [ghostRel]: { sha: "ghost00000000000", entities: ["M029"] },
+    },
+    piVersion: "1.4.0",
+  });
+
+  const removed = pruneOrphanedProjectionEntries(base);
+  assert.equal(removed, 1);
+
+  const marker = readCompatMarker(base);
+  assert.ok(marker.projections[liveRel], "live projection must survive");
+  assert.equal(marker.projections[ghostRel], undefined, "phantom projection must be pruned");
+});
+
+test("pruneOrphanedProjectionEntries also prunes .planning projections/passthrough", () => {
+  const base = makeTmpBase();
+  mkdirSync(join(base, ".planning"), { recursive: true });
+  writeFileSync(join(base, ".planning", "ROADMAP.md"), "# roadmap\n", "utf-8");
+
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-05T05:35:19.379Z",
+    projections: {},
+    planning: {
+      active: true,
+      layout: "flat-phases",
+      projections: {
+        "ROADMAP.md": { sha: "live000000000000", entities: [] },
+        "gone/PLAN.md": { sha: "ghost00000000000", entities: [] },
+      },
+      passthrough: {
+        "gone/PATTERNS.md": { sha: "ghost11111111111", entities: [] },
+      },
+    },
+    piVersion: "1.4.0",
+  });
+
+  const removed = pruneOrphanedProjectionEntries(base);
+  assert.equal(removed, 2);
+
+  const marker = readCompatMarker(base);
+  assert.ok(marker.planning!.projections["ROADMAP.md"], "live planning projection must survive");
+  assert.equal(marker.planning!.projections["gone/PLAN.md"], undefined);
+  assert.equal(marker.planning!.passthrough["gone/PATTERNS.md"], undefined);
+});
+
+test("pruneOrphanedProjectionEntries is a no-op when nothing is orphaned", () => {
+  const base = makeTmpBase();
+  const rel = "phases/01-phase/01-01-PLAN.md";
+  mkdirSync(join(base, ".gsd", "phases", "01-phase"), { recursive: true });
+  writeFileSync(join(base, ".gsd", rel), "# plan\n", "utf-8");
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-07-05T05:35:19.379Z",
+    projections: { [rel]: { sha: "abc000000000000", entities: ["M001"] } },
+    piVersion: "1.4.0",
+  });
+
+  assert.equal(pruneOrphanedProjectionEntries(base), 0);
+});
+
+test("pruneOrphanedProjectionEntries returns 0 and writes nothing when marker is missing", () => {
+  const base = makeTmpBase();
+  assert.equal(pruneOrphanedProjectionEntries(base), 0);
+  const files = readdirSync(join(base, ".gsd"));
+  assert.ok(!files.includes(".compat.json"), "must not create a marker where none existed");
+});

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

@@ -422,6 +422,51 @@ console.log('\n=== complete-milestone: existing SUMMARY.md preserved (#4598) ===
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-milestone: flat-phase compatibility SUMMARY.md is not hidden
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-milestone: flat-phase legacy-named SUMMARY.md preserved (#4598) ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+  const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-flat-complete-milestone-'));
+  const phaseDir = path.join(basePath, '.gsd', 'phases', '01-test-milestone');
+  fs.mkdirSync(path.join(phaseDir, 'slices', 'S01', 'tasks'), { recursive: true });
+  seedCompletedMilestone({ basePath, validationVerdict: 'pass' });
+
+  // Flat-phase projects may still contain legacy-named compatibility files.
+  // The no-overwrite guard must preserve those richer summaries instead of
+  // generating a canonical sibling that later readers would prefer.
+  const summaryPath = path.join(phaseDir, 'M001-SUMMARY.md');
+  const canonicalSummaryPath = path.join(phaseDir, '01-SUMMARY.md');
+  const sentinel = '# M001: Pre-existing flat-phase richer summary\n\nDO NOT OVERWRITE ME\n';
+  fs.writeFileSync(summaryPath, sentinel, 'utf-8');
+
+  const result = await handleCompleteMilestone(makeValidParams(), basePath);
+  assertTrue(!('error' in result), 'completion should still succeed when flat-phase compatibility SUMMARY.md exists');
+  if (!('error' in result)) {
+    assertEq(
+      result.summaryPath,
+      fs.realpathSync(summaryPath),
+      'completion should report the preserved existing SUMMARY path',
+    );
+    assertEq(
+      fs.readFileSync(summaryPath, 'utf-8'),
+      sentinel,
+      'flat-phase compatibility SUMMARY.md must be preserved, not hidden by a canonical rewrite',
+    );
+    assertTrue(
+      !fs.existsSync(canonicalSummaryPath),
+      'completion must not create a canonical sibling over an existing compatibility summary',
+    );
+    assertEq(getMilestone('M001')!.status, 'complete', 'milestone should still be marked complete in DB');
+  }
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 
 report();

package/src/resources/extensions/gsd/tests/completed-units-metrics-sync.test.ts

@@ -7,7 +7,7 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, cpSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { syncStateToProjectRoot } from "../auto-worktree.ts";
+import { syncStateToProjectRoot } from "../auto-worktree-sync.ts";
 
 test("#2313: syncStateToProjectRoot copies metrics and completed-units to the project root", () => {
   const root = mkdtempSync(join(tmpdir(), "gsd-sync-metrics-"));

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

@@ -33,6 +33,45 @@ test("normalizeDbRows normalizes every row", () => {
   assert.deepEqual(normalizeDbRows([first, second]), [{ id: "S01" }, { id: "S02" }]);
 });
 
+test("createDbAdapter strips named-parameter key prefixes for provider compatibility", () => {
+  const received: unknown[][] = [];
+  const rawStatement = {
+    run: (...params: unknown[]) => {
+      received.push(params);
+      return { changes: 1 };
+    },
+    get: (...params: unknown[]) => {
+      received.push(params);
+      return undefined;
+    },
+    all: (...params: unknown[]) => {
+      received.push(params);
+      return [];
+    },
+  };
+  const rawDb = {
+    exec: () => {},
+    prepare: () => rawStatement,
+    close: () => {},
+  };
+  const adapter = createDbAdapter(rawDb);
+  const stmt = adapter.prepare("INSERT INTO t (version, applied_at) VALUES (:version, :applied_at)");
+
+  stmt.run({ ":version": 1, "@name": "a", "$flag": true, bare: "kept" });
+  assert.deepEqual(received.pop(), [{ version: 1, name: "a", flag: true, bare: "kept" }]);
+
+  // Non-binding params pass through untouched: positional scalars, arrays,
+  // and binary blobs must not be treated as named-binding objects.
+  const blob = new Uint8Array([1, 2, 3]);
+  stmt.get("T01", blob);
+  const passthrough = received.pop() as unknown[];
+  assert.equal(passthrough[0], "T01");
+  assert.equal(passthrough[1], blob);
+
+  stmt.all({ plain: "unchanged" });
+  assert.deepEqual(received.pop(), [{ plain: "unchanged" }]);
+});
+
 test("createDbAdapter caches prepared statements and clears cache on close", () => {
   const calls: unknown[] = [];
   const rawStatement = {

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

@@ -0,0 +1,66 @@
+// gsd-pi — DB writability probe regression tests (#1234).
+//
+// Auto-start's DB gate only checked that the provider opened, not that the
+// handle can actually write. A schema-current DB does zero writes during open,
+// so a read-only / DBMOVED handle passed the open-only check and failed much
+// later at the first authoritative write with an opaque "readonly database"
+// error. `probeDbWritable` forces a real page write so that failure class is
+// caught at the natural checkpoint.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase, probeDbWritable, _getAdapter } from "../gsd-db.ts";
+import type { DbAdapter } from "../db-adapter.ts";
+
+function makeBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-db-writable-probe-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+test("probeDbWritable succeeds against a freshly opened writable database", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  try {
+    assert.deepEqual(probeDbWritable(), { ok: true });
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("probeDbWritable reports not-ok with detail when no database is open", () => {
+  closeDatabase();
+  const result = probeDbWritable();
+  assert.equal(result.ok, false);
+  assert.match(result.detail ?? "", /No database is open/u);
+});
+
+test("probeDbWritable reports not-ok when the page write fails (simulating a read-only handle)", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  const adapter = _getAdapter() as DbAdapter;
+  assert.ok(adapter);
+
+  // The read (prepare/get) still works; only the page-dirtying write throws,
+  // mirroring SQLITE_READONLY_DBMOVED which fails once a page is dirtied.
+  const origExec = adapter.exec.bind(adapter);
+  adapter.exec = (sql: string): void => {
+    if (sql.includes("user_version =")) throw new Error("attempt to write a readonly database");
+    return origExec(sql);
+  };
+
+  try {
+    const result = probeDbWritable();
+    assert.equal(result.ok, false);
+    assert.match(result.detail ?? "", /readonly database/u);
+  } finally {
+    adapter.exec = origExec;
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -1034,6 +1034,10 @@ describe('derive-state-db', async () => {
 
       assert.deepStrictEqual(dbState.phase, 'replanning-slice', 'replan-db: phase is replanning-slice');
       assert.deepStrictEqual(dbState.phase, fileState.phase, 'replan-db: phase matches filesystem');
+      assert.ok(
+        Object.hasOwn(dbState, 'activeWorkspace'),
+        'replan-db: state preserves explicit activeWorkspace field for auto-loop consumers',
+      );
 
       closeDatabase();
     } finally {

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

@@ -428,6 +428,52 @@ test("checkEngineHealth repair prunes stale phases artifact rows with present mi
   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 }));
+
+  const gsdDir = join(base, ".gsd");
+  const livePath = "phases/01-m001/01-01-PLAN.md";
+  const replacementPath = "milestones/M001/slices/S01/S01-PLAN.md";
+  // Both the active phases/ file AND a legacy milestones/ copy exist on disk.
+  // The row is "fixable" (a milestones replacement is present), but its own
+  // file is present too — repair must not drop the live row.
+  mkdirSync(join(gsdDir, "phases", "01-m001"), { recursive: true });
+  writeFileSync(join(gsdDir, livePath), "# Plan\n", "utf-8");
+  mkdirSync(join(gsdDir, "milestones", "M001", "slices", "S01"), { recursive: true });
+  writeFileSync(join(gsdDir, replacementPath), "# Plan\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: livePath,
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# plan\n",
+  });
+
+  const issues: any[] = [];
+  const fixes: string[] = [];
+  await checkEngineHealth(base, issues, fixes, { repair: true });
+
+  assert.equal(
+    fixes.some((fix) => fix.includes(livePath)),
+    false,
+    "repair must not prune a row whose own file is present on disk",
+  );
+  assert.equal(
+    issues.some((issue) => issue.code === "artifact_file_missing" && issue.file === livePath),
+    false,
+    "a present artifact must not be reported missing",
+  );
+
+  const rows = _getAdapter()!
+    .prepare("SELECT path FROM artifacts ORDER BY path")
+    .all() as Array<{ path: string }>;
+  assert.deepEqual(rows.map((row) => row.path), [livePath]);
+});
+
 test("checkEngineHealth repair prunes stale phases task rows against tasks/<T>-<TYPE>.md replacements", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-prune-stale-task-phase-artifact-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -540,6 +586,134 @@ test("checkEngineHealth marks escaped phases rows fixable when a milestones repl
   assert.equal(issue.fixable, true, "escaped phases rows with a milestones replacement must be marked fixable");
 });
 
+test("checkEngineHealth resolves legacy milestones rows through flat-phase files", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-flat-fallback-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const flatPath = "phases/01-foundation/01-01-PLAN.md";
+  const legacyPath = "milestones/M001/slices/S01/S01-PLAN.md";
+  mkdirSync(join(gsdDir, "phases", "01-foundation"), { recursive: true });
+  writeFileSync(join(gsdDir, flatPath), "# Plan\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: legacyPath,
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# legacy plan row\n",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.equal(
+    issues.some((issue) => issue.code === "artifact_file_missing" && issue.file === legacyPath),
+    false,
+    "legacy milestones rows should not be reported missing when the flat-phase file exists",
+  );
+});
+
+test("checkEngineHealth repair prunes stale milestones rows with present flat-phase files", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-prune-stale-legacy-artifact-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const flatPath = "phases/01-foundation/01-01-PLAN.md";
+  const stalePath = "milestones/M001/slices/S01/S01-PLAN.md";
+  mkdirSync(join(gsdDir, "phases", "01-foundation"), { recursive: true });
+  writeFileSync(join(gsdDir, flatPath), "# 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 row\n",
+  });
+
+  const issues: any[] = [];
+  const fixes: string[] = [];
+  await checkEngineHealth(base, issues, fixes, { repair: true });
+
+  assert.equal(
+    issues.some((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath),
+    false,
+    "repair should not report stale legacy rows it pruned",
+  );
+  assert.ok(fixes.includes(`pruned stale legacy 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 marks stale milestones task rows without flat files fixable", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-fixable-stale-legacy-task-artifact-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const stalePath = "milestones/M001/slices/S01/tasks/T01-PLAN.md";
+  mkdirSync(join(gsdDir, "phases", "01-foundation"), { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: stalePath,
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: "T01",
+    full_content: "# stale task plan row\n",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  const issue = issues.find((candidate) => candidate.code === "artifact_file_missing" && candidate.file === stalePath);
+  assert.ok(issue, "missing stale legacy task row should still be reported when repair is off");
+  assert.equal(issue.fixable, true, "stale legacy task rows without flat files should be fixable");
+});
+
+test("checkEngineHealth repair prunes stale milestones task rows without flat files", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-prune-stale-legacy-task-artifact-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const stalePath = "milestones/M001/slices/S01/tasks/T01-PLAN.md";
+  mkdirSync(join(gsdDir, "phases", "01-foundation"), { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: stalePath,
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: "T01",
+    full_content: "# stale task plan row\n",
+  });
+
+  const issues: any[] = [];
+  const fixes: string[] = [];
+  await checkEngineHealth(base, issues, fixes, { repair: true });
+
+  assert.equal(
+    issues.some((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath),
+    false,
+    "repair should prune stale legacy task rows that have no flat file representation",
+  );
+  assert.ok(fixes.includes(`pruned stale legacy 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), []);
+});
+
 function taskSummary(id: string, verificationResult = "passed"): string {
   return [
     "---",

package/src/resources/extensions/gsd/tests/fast-forward-reused-milestone-branch.test.ts

@@ -13,7 +13,7 @@ import { basename, join } from "node:path";
 import {
   fastForwardReusedMilestoneBranchIfSafe,
   _isBranchCheckedOutElsewhere,
-} from "../auto-worktree.js";
+} from "../auto-worktree-branch-lifecycle.js";
 
 const NO_PROMPT_ENV = {
   ...process.env,

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

@@ -13,7 +13,7 @@ import {
   needsFlatPhaseMigration,
   pruneStaleFlatPhaseBackups,
 } from "../flat-phase-migration.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getAllMilestones, getMilestoneSlices, getSliceTasks } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertArtifact, insertMilestone, insertSlice, insertTask, getAllMilestones, getMilestoneSlices, getSliceTasks, _getAdapter } from "../gsd-db.ts";
 
 const tmpDirs: string[] = [];
 function makeTmp(options: { withTask?: boolean } = {}): string {
@@ -109,6 +109,33 @@ test("migrateToFlatPhase creates a backup", async () => {
   assert.ok(backups.length >= 1, "at least one migrate-* backup dir should exist");
 });
 
+test("failed migration rolls back without leaking a .gsd-backups/migrate-* dir", async (t) => {
+  const base = makeTmp();
+  const milestonesPath = join(base, ".gsd", "milestones");
+  const phasesPath = join(base, ".gsd", "phases");
+
+  // Fail the pre-render clear of phases/ to drive the rollback path, which by
+  // this point has already created the .gsd-backups/migrate-<ts>/ backup.
+  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/);
+
+  assert.ok(existsSync(milestonesPath), "legacy milestones/ should be restored on rollback");
+  const backupRoot = join(base, ".gsd-backups");
+  const leaked = existsSync(backupRoot)
+    ? readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"))
+    : [];
+  assert.equal(leaked.length, 0, "rollback must delete the migrate-* backup it created");
+});
+
 test("migrateToFlatPhase preserves milestone/slice/task counts in DB", async () => {
   const base = makeTmp();
   const msBefore = getAllMilestones().length;
@@ -120,6 +147,49 @@ test("migrateToFlatPhase preserves milestone/slice/task counts in DB", async ()
   assert.equal(getSliceTasks("M001", "S01").length, tasksBefore);
 });
 
+test("migrateToFlatPhase prunes legacy milestones artifact rows after flat render", async () => {
+  const base = makeTmp();
+  insertArtifact({
+    path: "milestones/M001/M001-ROADMAP.md",
+    artifact_type: "ROADMAP",
+    milestone_id: "M001",
+    slice_id: null,
+    task_id: null,
+    full_content: "# M001: Foundation\n",
+  });
+  insertArtifact({
+    path: "milestones/M001/slices/S01/S01-PLAN.md",
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# Plan\n",
+  });
+  insertArtifact({
+    path: "milestones/M001/slices/S01/tasks/T01-PLAN.md",
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: "T01",
+    full_content: "# Task Plan\n",
+  });
+
+  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.startsWith("milestones/")),
+    false,
+    "legacy milestones/ artifact rows should be pruned after successful flat migration",
+  );
+  assert.ok(
+    rows.some((row) => row.path.startsWith("phases/")),
+    "flat-phase render should leave replacement projection rows in the artifacts table",
+  );
+});
+
 test("migrateToFlatPhase is idempotent (second run is a no-op)", async () => {
   const base = makeTmp();
   await migrateToFlatPhase(base);

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

@@ -7,7 +7,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { renderPlanFromDb, renderRoadmapFromDb } from "../markdown-renderer.ts";
+import { renderPlanFromDb, renderRoadmapFromDb, renderAssessmentFromDb, renderReplanFromDb } from "../markdown-renderer.ts";
+import { clearPathCache } from "../paths.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
 
 const tmpDirs: string[] = [];
@@ -81,3 +82,47 @@ test("renderPlanFromDb does NOT write per-task plan files", async () => {
   // taskPlanPaths should be empty — no per-task files written
   assert.equal(result.taskPlanPaths.length, 0);
 });
+
+
+// Replan uses the same slice-level target rules as assessment: flat-phase
+// writes must stay at the phase root even if an old slices/SID/ dir exists.
+test("renderReplanFromDb writes to the phase root even when a stray slices/SID/ dir exists", async () => {
+  const base = makeTmp();
+  const plan = await renderPlanFromDb(base, "M001", "S01");
+  const phaseDir = plan.planPath.slice(0, plan.planPath.lastIndexOf("01-01-PLAN.md"));
+  mkdirSync(join(phaseDir, "slices", "S01"), { recursive: true });
+  clearPathCache();
+
+  const result = await renderReplanFromDb(base, "M001", "S01", {
+    blockerTaskId: "T01",
+    blockerDescription: "Need a better path target.",
+    whatChanged: "Centralized slice writer path resolution.",
+  });
+
+  assert.match(result.replanPath, /phases[/\\]01-[^/\\]+[/\\]01-01-REPLAN\.md$/);
+  assert.ok(!result.replanPath.includes(join("slices", "S01")), "must not write under slices/S01/");
+  assert.ok(existsSync(result.replanPath), "replan file should exist at the phase root");
+});
+
+// Regression for #1190: a stray slices/SID/ subdir inside a flat-phase milestone
+// must not divert the ASSESSMENT write into slices/SID/ (a hybrid path that
+// auto-mode verification cannot find). It must land at the phase root.
+test("renderAssessmentFromDb writes to the phase root even when a stray slices/SID/ dir exists", async () => {
+  const base = makeTmp();
+  const plan = await renderPlanFromDb(base, "M001", "S01");
+  const phaseDir = plan.planPath.slice(0, plan.planPath.lastIndexOf("01-01-PLAN.md"));
+
+  // Simulate the anomaly: an earlier planning step created slices/S01/ inside
+  // the flat-phase dir.
+  mkdirSync(join(phaseDir, "slices", "S01"), { recursive: true });
+  clearPathCache();
+
+  const result = await renderAssessmentFromDb(base, "M001", "S01", {
+    verdict: "on-track",
+    assessment: "Roadmap is on track.",
+  });
+
+  assert.match(result.assessmentPath, /phases[/\\]01-[^/\\]+[/\\]01-01-ASSESSMENT\.md$/);
+  assert.ok(!result.assessmentPath.includes(join("slices", "S01")), "must not write under slices/S01/");
+  assert.ok(existsSync(result.assessmentPath), "assessment file should exist at the phase root");
+});