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

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

@@ -0,0 +1,70 @@
+// gsd-pi — Pre-merge stash characterization tests.
+
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { createPreMergeStash } from "../auto-worktree-merge-stash.ts";
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  });
+}
+
+function createRepo(t: { after: (fn: () => void) => void }): string {
+  const root = mkdtempSync(join(tmpdir(), "gsd-merge-stash-test-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  git(root, ["init"]);
+  git(root, ["config", "user.email", "test@example.com"]);
+  git(root, ["config", "user.name", "Test User"]);
+  writeFileSync(join(root, "tracked.txt"), "base\n");
+  git(root, ["add", "."]);
+  git(root, ["commit", "-m", "init"]);
+  return root;
+}
+
+function status(root: string): string {
+  return git(root, ["status", "--porcelain"]);
+}
+
+test("pre-merge stash moves tracked and untracked local work out of the merge path", (t) => {
+  const root = createRepo(t);
+  writeFileSync(join(root, "tracked.txt"), "local edit\n");
+  writeFileSync(join(root, "untracked.txt"), "local untracked\n");
+
+  const stash = createPreMergeStash(root, "M001", false);
+  stash.stash();
+
+  assert.equal(status(root), "", "stash leaves the worktree clean for merge");
+  assert.ok(!existsSync(join(root, "untracked.txt")), "untracked files are included in the pre-merge stash");
+
+  stash.restoreForMergeFailure();
+
+  assert.equal(readFileSync(join(root, "tracked.txt"), "utf8"), "local edit\n");
+  assert.equal(readFileSync(join(root, "untracked.txt"), "utf8"), "local untracked\n");
+  assert.equal(git(root, ["stash", "list"]).trim(), "", "targeted restore consumes the pre-merge stash");
+});
+
+test("post-commit stash restore brings local work back after merge commit", (t) => {
+  const root = createRepo(t);
+  writeFileSync(join(root, "tracked.txt"), "local edit\n");
+  writeFileSync(join(root, "untracked.txt"), "local untracked\n");
+
+  const stash = createPreMergeStash(root, "M002", false);
+  stash.stash();
+  writeFileSync(join(root, "merged.txt"), "merged\n");
+  git(root, ["add", "merged.txt"]);
+  git(root, ["commit", "-m", "merge result"]);
+
+  stash.restoreAfterCommit();
+
+  assert.equal(readFileSync(join(root, "tracked.txt"), "utf8"), "local edit\n");
+  assert.equal(readFileSync(join(root, "untracked.txt"), "utf8"), "local untracked\n");
+  assert.equal(git(root, ["stash", "list"]).trim(), "", "post-commit restore consumes the pre-merge stash");
+});

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

@@ -0,0 +1,52 @@
+// gsd-pi — Milestone directory shelter characterization tests.
+
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import {
+  createMilestoneDirectoryShelter,
+  _setRestoreEntryFnForTests,
+} from "../auto-worktree-milestone-shelter.ts";
+
+function createWorkspace(t: { after: (fn: () => void) => void }): string {
+  const root = mkdtempSync(join(tmpdir(), "gsd-shelter-test-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  mkdirSync(join(root, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(root, ".gsd", "milestones", "M002"), { recursive: true });
+  writeFileSync(join(root, ".gsd", "milestones", "M001", "CONTEXT.md"), "# target\n");
+  writeFileSync(join(root, ".gsd", "milestones", "M002", "CONTEXT.md"), "# queued\n");
+  return root;
+}
+
+test("milestone directory shelter restores queued milestone dirs and cleans the shelter", (t) => {
+  const root = createWorkspace(t);
+
+  const shelter = createMilestoneDirectoryShelter(root, "M001", "Target milestone");
+
+  assert.ok(existsSync(join(root, ".gsd", "milestones", "M001", "CONTEXT.md")), "target milestone is not sheltered");
+  assert.ok(!existsSync(join(root, ".gsd", "milestones", "M002")), "queued milestone is moved out before stash");
+  assert.ok(existsSync(join(root, ".gsd", ".milestone-shelter", "M002", "CONTEXT.md")), "queued milestone is recoverable from shelter");
+
+  shelter.restore();
+  shelter.restore();
+
+  assert.equal(readFileSync(join(root, ".gsd", "milestones", "M002", "CONTEXT.md"), "utf8"), "# queued\n");
+  assert.ok(!existsSync(join(root, ".gsd", ".milestone-shelter")), "shelter is removed after successful restore");
+});
+
+test("milestone directory shelter retains recoverable copy when restore entry fails", (t) => {
+  const root = createWorkspace(t);
+  const restoreDefault = _setRestoreEntryFnForTests(() => {
+    throw new Error("forced restore failure");
+  });
+  t.after(restoreDefault);
+
+  const shelter = createMilestoneDirectoryShelter(root, "M001", "Target milestone");
+  shelter.restore();
+
+  assert.ok(!existsSync(join(root, ".gsd", "milestones", "M002", "CONTEXT.md")), "failed restore does not pretend queued files were restored");
+  assert.equal(readFileSync(join(root, ".gsd", ".milestone-shelter", "M002", "CONTEXT.md"), "utf8"), "# queued\n");
+});

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

@@ -7,15 +7,15 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { enterAutoWorktree } from "../auto-worktree-entry.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import {
-  getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
+  getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-  createAutoWorktree,
-  enterAutoWorktree,
-  mergeMilestoneToMain,
-  teardownAutoWorktree,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 

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

@@ -0,0 +1,59 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  checkResourcesStale,
+  readResourceVersion,
+} from "../auto-worktree-resource-version.ts";
+
+function withAgentDir<T>(fn: (agentDir: string) => T): T {
+  const oldAgentDir = process.env.GSD_CODING_AGENT_DIR;
+  const agentDir = mkdtempSync(join(tmpdir(), "gsd-resource-version-"));
+  process.env.GSD_CODING_AGENT_DIR = agentDir;
+  try {
+    return fn(agentDir);
+  } finally {
+    if (oldAgentDir === undefined) {
+      delete process.env.GSD_CODING_AGENT_DIR;
+    } else {
+      process.env.GSD_CODING_AGENT_DIR = oldAgentDir;
+    }
+    rmSync(agentDir, { recursive: true, force: true });
+  }
+}
+
+test("readResourceVersion reads gsdVersion from managed-resources manifest", () => {
+  withAgentDir((agentDir) => {
+    mkdirSync(agentDir, { recursive: true });
+    writeFileSync(
+      join(agentDir, "managed-resources.json"),
+      JSON.stringify({ gsdVersion: "1.2.3", syncedAt: "ignored" }),
+    );
+
+    assert.equal(readResourceVersion(), "1.2.3");
+  });
+});
+
+test("checkResourcesStale reports only when resource version changed", () => {
+  withAgentDir((agentDir) => {
+    writeFileSync(
+      join(agentDir, "managed-resources.json"),
+      JSON.stringify({ gsdVersion: "2.0.0" }),
+    );
+
+    assert.equal(checkResourcesStale(null), null);
+    assert.equal(checkResourcesStale("2.0.0"), null);
+    assert.equal(
+      checkResourcesStale("1.9.0"),
+      "GSD resources were updated since this session started. Restart gsd to load the new code.",
+    );
+  });
+});

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

@@ -8,7 +8,9 @@ import { existsSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "no
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { createAutoWorktree, teardownAutoWorktree, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 import { classifyProject } from "../detection.ts";
 
 function runGit(args: string[], cwd: string): string {

package/src/resources/extensions/gsd/tests/codebase-generator.test.ts

@@ -697,6 +697,28 @@ test("ensureCodebaseMapFresh: does not rewrite expired metadata when fingerprint
   }
 });
 
+test("ensureCodebaseMapFresh: stays fresh when stored fileCount exceeds maxFiles", () => {
+  const base = makeTmpRepo();
+  try {
+    for (let i = 0; i < 10; i++) addFile(base, `file${i}.ts`);
+    ensureCodebaseMapFresh(base, { maxFiles: 5 }, { ttlMs: 0, force: true });
+
+    // Simulate a map written by an older version that recorded the full
+    // (untruncated) file count in its metadata rather than the capped count.
+    const original = readCodebaseMap(base);
+    assert.ok(original);
+    const fullCountContent = original.replace(/"fileCount":5\b/, '"fileCount":10');
+    writeCodebaseMap(base, fullCountContent);
+
+    const refreshed = ensureCodebaseMapFresh(base, { maxFiles: 5 }, { ttlMs: 0, force: true });
+    assert.equal(refreshed.status, "fresh");
+    // Timestamp must be preserved so the injected prompt stays byte-identical.
+    assert.equal(readCodebaseMap(base), fullCountContent);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("ensureCodebaseMapFresh: uses TTL cache before enumerating files", () => {
   const base = makeTmpRepo();
   try {

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/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 } 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,26 @@ 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);
 });
+
+// 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");
+});

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

@@ -33,6 +33,10 @@ import {
   getMilestoneSliceSummaries,
   getClosedSliceIds,
   getActiveMilestoneFromDb,
+  getActiveSliceFromDb,
+  getActiveTaskFromDb,
+  getActiveTaskIdFromDb,
+  getSliceTaskCounts,
   deleteMilestone,
   clearEngineHierarchy,
   recordMilestoneCommitAttribution,
@@ -240,6 +244,42 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test("gsd-db: active readers use the shared closed-status vocabulary", () => {
+    openDatabase(":memory:");
+
+    try {
+      insertMilestone({ id: "M001", title: "Status vocabulary", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Closed dep", status: "closed", sequence: 1 });
+      insertSlice({ id: "S02", milestoneId: "M001", title: "Runnable", status: "pending", depends: ["S01"], sequence: 2 });
+      insertTask({ id: "T01", sliceId: "S02", milestoneId: "M001", title: "Skipped", status: "skipped", sequence: 1 });
+      insertTask({ id: "T02", sliceId: "S02", milestoneId: "M001", title: "Closed", status: "closed", sequence: 2 });
+      insertTask({ id: "T03", sliceId: "S02", milestoneId: "M001", title: "Pending", status: "pending", sequence: 3 });
+
+      assert.equal(
+        getActiveSliceFromDb("M001")?.id,
+        "S02",
+        "closed dependency slices must satisfy dependencies and be excluded from active slice selection",
+      );
+      assert.equal(
+        getActiveTaskFromDb("M001", "S02")?.id,
+        "T03",
+        "skipped/closed tasks must be excluded from active task selection",
+      );
+      assert.equal(
+        getActiveTaskIdFromDb("M001", "S02")?.id,
+        "T03",
+        "lightweight active task selection must use the same closed-status vocabulary",
+      );
+      assert.deepEqual(
+        getSliceTaskCounts("M001", "S02"),
+        { total: 3, done: 2, pending: 1 },
+        "slice task counts must derive done/pending from the shared closed-status vocabulary",
+      );
+    } finally {
+      closeDatabase();
+    }
+  });
+
   test('gsd-db: active_decisions view excludes superseded', () => {
     openDatabase(':memory:');