@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.84c56d87

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { createRequire } from "node:module";
-import { copyFileSync, mkdtempSync, renameSync, rmSync } from "node:fs";
+import { copyFileSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
@@ -287,3 +287,145 @@ test("migration auto-check refreshes a stale open DB handle before comparing", a
     cleanup(base);
   }
 });
+
+function writeScratchMilestoneDir(base: string, milestoneId: string, file?: string): void {
+  const dir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(dir, { recursive: true });
+  if (file) writeFileSync(join(dir, file), `# ${milestoneId} discussion context\n`);
+}
+
+test("migration auto-check ignores discussion-scratch milestone dirs (CONTEXT only, no DB row)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Legacy Slice", status: "pending", risk: "medium", depends: [], demo: "Legacy slice demo", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    // Mid-discussion artifacts: dirs with no ROADMAP and no DB row. The queued
+    // DB row is only inserted at discussion handoff, so these are expected to
+    // be DB-less — not drift, and recover must not be recommended (it would
+    // import them as ghost active milestones).
+    writeScratchMilestoneDir(base, "M002", "M002-CONTEXT.md");
+    writeScratchMilestoneDir(base, "M003", "M003-CONTEXT-DRAFT.md");
+    writeScratchMilestoneDir(base, "M004"); // empty dir
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check stays quiet mid-first-discussion (scratch dir over empty DB)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    writeScratchMilestoneDir(base, "M001", "M001-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "no-markdown");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check still reports real drift with scratch dirs excluded from counts", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01, DB empty
+    assert.equal(await ensureDbOpen(base), true);
+    writeScratchMilestoneDir(base, "M002", "M002-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "recovery-required");
+    assert.equal(result.reason, "db-empty");
+    assert.equal(result.recoveryCommand, "/gsd recover --confirm");
+    // The scratch dir must not inflate the reported markdown count.
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check still compares a roadmapless milestone that HAS a DB row", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    // Post-handoff queued milestone: CONTEXT-only dir WITH a DB row. It must
+    // stay in the comparison (both sides have it → in-sync).
+    insertMilestone({ id: "M001", title: "M001", status: "queued" });
+    writeScratchMilestoneDir(base, "M001", "M001-CONTEXT.md");
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 0, tasks: 0 });
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("rebuildMarkdownProjectionsFromDb realigns markdown when DB holds extra rows", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Legacy Slice",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "Legacy slice demo",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Legacy Task",
+      status: "pending",
+    });
+    insertSlice({
+      id: "S02",
+      milestoneId: "M001",
+      title: "Added in DB",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "d",
+      sequence: 2,
+    });
+    insertTask({
+      id: "T02",
+      sliceId: "S02",
+      milestoneId: "M001",
+      title: "Added task",
+      status: "pending",
+    });
+
+    const before = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(before.recoveryCommand, "/gsd rebuild markdown");
+
+    const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.ts");
+    const rebuild = await rebuildMarkdownProjectionsFromDb(base);
+    assert.ok(rebuild.rendered > 0, "expected markdown projections to render");
+
+    const after = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(after.action, "none");
+    assert.equal(after.reason, "in-sync");
+    assert.deepEqual(after.markdown, { milestones: 1, slices: 2, tasks: 2 });
+    assert.deepEqual(after.beforeDb, { milestones: 1, slices: 2, tasks: 2 });
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -0,0 +1,99 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for the shared milestone closeout proof surface.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.js";
+import { proveMilestoneCloseout } from "../milestone-closeout-proof.js";
+
+const tmpDirs: string[] = [];
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-closeout-proof-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try { closeDatabase(); } catch { /* noop */ }
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function insertValidationPass(): void {
+  insertAssessment({
+    path: "milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+}
+
+function writeSummary(base: string, status = "complete"): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
+    `---\nstatus: ${status}\n---\n\n# Summary\n`,
+    "utf-8",
+  );
+}
+
+test.after(() => {
+  try { closeDatabase(); } catch { /* noop */ }
+  for (const dir of tmpDirs) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("proveMilestoneCloseout accepts closed DB state plus summary artifact", () => {
+  const base = makeBase();
+  insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertValidationPass();
+  writeSummary(base);
+
+  const result = proveMilestoneCloseout("M001", {
+    summaryArtifactBasePath: base,
+  });
+
+  assert.deepEqual(result, { ok: true });
+});
+
+test("proveMilestoneCloseout can prove readiness before DB milestone is closed", () => {
+  const base = makeBase();
+  insertMilestone({ id: "M001", title: "Ready", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertValidationPass();
+  writeSummary(base);
+
+  const result = proveMilestoneCloseout("M001", {
+    allowOpenMilestone: true,
+    summaryArtifactBasePath: base,
+  });
+
+  assert.deepEqual(result, { ok: true });
+});
+
+test("proveMilestoneCloseout rejects explicit failure summaries", () => {
+  const base = makeBase();
+  insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertValidationPass();
+  writeSummary(base, "failed");
+
+  const result = proveMilestoneCloseout("M001", {
+    summaryArtifactBasePath: base,
+  });
+
+  assert.equal(result.ok, false);
+  if (!result.ok) {
+    assert.equal(result.reason, "summary-artifact-failed");
+  }
+});

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

@@ -55,6 +55,31 @@ test("isMilestoneCloseoutSettled requires DB closed and summary artifact", async
   assert.equal(settled, true);
 });
 
+test("isMilestoneCloseoutSettled accepts summary artifacts in a live milestone worktree", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-milestone-closeout-worktree-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+
+  const worktreeRoot = join(base, ".gsd", "worktrees", "M001");
+  const milestoneDir = join(worktreeRoot, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(worktreeRoot, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M001")}\n`);
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\n");
+
+  const settled = await isMilestoneCloseoutSettled("M001", base);
+  assert.equal(settled, true);
+});
+
 test("isMilestoneCloseoutSettled returns false when summary artifact is missing", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-milestone-closeout-missing-"));
   tmpDirs.push(base);

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

@@ -0,0 +1,46 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for the milestone merge transaction wrapper.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  createMilestoneMergeTransaction,
+  runMilestoneMergeTransaction,
+} from "../milestone-merge-transaction.js";
+
+test("runMilestoneMergeTransaction delegates to the supplied merge runner", () => {
+  const calls: unknown[][] = [];
+  const result = runMilestoneMergeTransaction(
+    {
+      mergeMilestoneToMain: (basePath, milestoneId, roadmapContent) => {
+        calls.push([basePath, milestoneId, roadmapContent]);
+        return { pushed: true, codeFilesChanged: true, commitMessage: "merge M001" };
+      },
+    },
+    {
+      basePath: "/repo",
+      milestoneId: "M001",
+      roadmapContent: "# M001",
+    },
+  );
+
+  assert.deepEqual(calls, [["/repo", "M001", "# M001"]]);
+  assert.deepEqual(result, {
+    pushed: true,
+    codeFilesChanged: true,
+    commitMessage: "merge M001",
+  });
+});
+
+test("createMilestoneMergeTransaction returns a lifecycle-compatible runner", () => {
+  const runner = createMilestoneMergeTransaction(() => ({
+    pushed: false,
+    codeFilesChanged: false,
+  }));
+
+  assert.deepEqual(runner("/repo", "M002", "# M002"), {
+    pushed: false,
+    codeFilesChanged: false,
+  });
+});

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

@@ -0,0 +1,65 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  classifyMilestoneReadiness,
+  describeMilestoneReadinessPhase,
+  formatAcceptedDiscussHandoffMessage,
+  readinessNeedsDiscussion,
+} from "../milestone-readiness.ts";
+
+test("classifyMilestoneReadiness distinguishes queued shells from draft discussion work", () => {
+  const shell = classifyMilestoneReadiness({
+    status: "queued",
+    hasDraftContext: true,
+    sliceCount: 0,
+  });
+
+  assert.equal(shell.kind, "queued-shell");
+  assert.equal(readinessNeedsDiscussion(shell), true);
+});
+
+test("classifyMilestoneReadiness marks context-only milestones as planning pending", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "queued",
+    hasContext: true,
+    sliceCount: 0,
+  });
+
+  assert.equal(readiness.kind, "planning-pending");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 context captured. Continuing the planning pipeline.");
+});
+
+test("classifyMilestoneReadiness marks persisted slices as executable plan", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "active",
+    hasContext: true,
+    sliceCount: 1,
+  });
+
+  assert.equal(readiness.kind, "executable-plan");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 ready.");
+});
+
+test("formatAcceptedDiscussHandoffMessage preserves ready copy for any executable plan", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "complete",
+    hasContext: true,
+    sliceCount: 1,
+  });
+
+  assert.equal(readiness.kind, "terminal");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 ready.");
+});
+
+test("describeMilestoneReadinessPhase keeps dashboard phase copy centralized", () => {
+  assert.deepEqual(describeMilestoneReadinessPhase("needs-discussion"), {
+    label: "Discuss milestone draft",
+    description: "Milestone has a draft context — needs discussion before planning.",
+  });
+  assert.deepEqual(describeMilestoneReadinessPhase("pre-planning"), {
+    label: "Research & plan milestone",
+    description: "Scout the landscape and create the roadmap.",
+  });
+  assert.equal(describeMilestoneReadinessPhase("executing"), null);
+});

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

@@ -0,0 +1,41 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for forwarded milestone validation evidence helpers.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyBrowserEvidenceGate,
+  hasRuntimeExecutableUatEvidenceText,
+} from "../milestone-validation-evidence.js";
+
+test("hasRuntimeExecutableUatEvidenceText requires runtime-executable PASS evidence", () => {
+  const evidence = [
+    "---",
+    "uatType: runtime-executable",
+    "verdict: PASS",
+    "---",
+    "| Check | Mode | Result | Evidence |",
+    "| DOM | runtime | PASS | gsd_uat_exec:.gsd/evidence/uat/M001/S01/dom.json |",
+  ].join("\n");
+
+  assert.equal(hasRuntimeExecutableUatEvidenceText(evidence), true);
+  assert.equal(hasRuntimeExecutableUatEvidenceText(evidence.replace("runtime | PASS", "manual | PASS")), false);
+});
+
+test("applyBrowserEvidenceGate records downgrade rationale", () => {
+  const params = applyBrowserEvidenceGate({
+    milestoneId: "M001",
+    verdict: "pass",
+    remediationRound: 0,
+    successCriteriaChecklist: "",
+    sliceDeliveryAudit: "",
+    crossSliceIntegration: "",
+    requirementCoverage: "",
+    verdictRationale: "Initial rationale.",
+  });
+
+  assert.equal(params.verdict, "needs-attention");
+  assert.match(params.verdictRationale, /Initial rationale/);
+  assert.match(params.verdictRationale, /Browser evidence gate/);
+});

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

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolveMilestoneValidationVerdict } from "../milestone-validation-verdict.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+function setup(base: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  process.chdir(base);
+  _clearGsdRootCache();
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  invalidateAllCaches();
+}
+
+test("resolveMilestoneValidationVerdict prefers DB pass over stale worktree needs-attention", async () => {
+  const base = join(tmpdir(), `validation-verdict-${Date.now()}`);
+  mkdirSync(base, { recursive: true });
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), "gitdir: ../.git/worktrees/M001\n", "utf-8");
+  writeFileSync(
+    join(worktree, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+    "---\nverdict: needs-attention\n---\n\n# Validation\nStale worktree copy.\n",
+  );
+
+  try {
+    setup(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertAssessment({
+      path: join(worktree, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      milestoneId: "M001",
+      sliceId: null,
+      taskId: null,
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "---\nverdict: pass\n---\n\n# Validation\nManual override.\n",
+    });
+
+    const verdict = await resolveMilestoneValidationVerdict(base, "M001");
+    assert.equal(verdict, "pass");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -306,6 +306,38 @@ describe("notification-store", () => {
     rmSync(lockPath, { force: true });
   });
 
+  test("structured meta persists kind and scope on the entry", () => {
+    initNotificationStore(tmp);
+    appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M005" });
+
+    const entries = readNotifications();
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].kind, "auto-stop");
+    assert.equal(entries[0].scope, "M005");
+  });
+
+  test("dedup keys on kind+scope when present, not on prose", () => {
+    initNotificationStore(tmp);
+    appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M005" });
+    // Rephrased message, same structured identity → deduped within the window
+    appendNotification("Auto-mode blocked — gate rejected", "warning", "notify", { kind: "auto-stop", scope: "M005" });
+    // Same kind, different scope → distinct
+    appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M006" });
+
+    assert.equal(readNotifications().length, 2);
+  });
+
+  test("readNotifications filters by kind and scope", () => {
+    initNotificationStore(tmp);
+    appendNotification("a", "info", "notify", { kind: "auto-stop", scope: "M005" });
+    appendNotification("b", "info", "notify", { kind: "provider-error-pause", scope: "M005" });
+    appendNotification("c", "info");
+
+    assert.equal(readNotifications(tmp, { kind: "auto-stop" }).length, 1);
+    assert.equal(readNotifications(tmp, { scope: "M005" }).length, 2);
+    assert.equal(readNotifications(tmp, { kind: "provider-error-pause", scope: "M005" })[0].message, "b");
+  });
+
   test("listeners are notified on append, markAllRead, and clear", () => {
     initNotificationStore(tmp);
     let calls = 0;

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

@@ -347,3 +347,48 @@ test('handlePlanMilestone updates depends_on when a queued milestone row already
     cleanup(base);
   }
 });
+
+// Regression #566: bracket-wrapped slice ID in depends should be rejected
+test('handlePlanMilestone rejects bracket-wrapped depends like ["[S01]"]', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const params = validParams();
+    // Simulate the LLM sending "[S01]" (the markdown fragment) instead of "S01"
+    const corruptSlices = [
+      params.slices[0],
+      { ...params.slices[1], depends: ['[S01]'] },
+    ];
+    const result = await handlePlanMilestone({ ...params, slices: corruptSlices }, base);
+    assert.ok('error' in result, 'should return an error for bracket-wrapped depends');
+    assert.match(result.error, /slices\[1\]\.depends must be an array of valid slice IDs/,
+      'error should mention invalid slice ID format');
+    assert.equal(getMilestoneSlices('M001').length, 0, 'no slices should persist on validation failure');
+  } finally {
+    cleanup(base);
+  }
+});
+
+// Regression #566: unknown slice ID in depends should be rejected
+test('handlePlanMilestone rejects depends referencing a slice not in the same milestone', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const params = validParams();
+    const corruptSlices = [
+      params.slices[0],
+      { ...params.slices[1], depends: ['S99'] },
+    ];
+    const result = await handlePlanMilestone({ ...params, slices: corruptSlices }, base);
+    assert.ok('error' in result, 'should return an error for unknown depends slice');
+    assert.match(result.error, /references unknown slice "S99"/,
+      'error should name the unknown slice');
+    assert.equal(getMilestoneSlices('M001').length, 0, 'no slices should persist on validation failure');
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/plan-slice-prompt.test.ts

@@ -137,6 +137,7 @@ test("skillActivation default leaves no unresolved placeholder", () => {
     carryForwardSection: "Carry forward",
     resumeSection: "Resume",
     priorTaskLines: "- (no prior tasks)",
+    onDemandContext: "",
     templatesDir: join(fixtureRoot, "templates"),
     taskSummaryPath: join(fixtureRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
     inlinedTemplates: "Template",
@@ -163,6 +164,7 @@ test("custom skillActivation is substituted into execute-task", () => {
     carryForwardSection: "Carry forward",
     resumeSection: "Resume",
     priorTaskLines: "- (no prior tasks)",
+    onDemandContext: "",
     templatesDir: join(fixtureRoot, "templates"),
     taskSummaryPath: join(fixtureRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
     inlinedTemplates: "Template",

package/src/resources/extensions/gsd/tests/planning-crossval.test.ts

@@ -15,6 +15,7 @@ import {
   insertTask,
   getMilestoneSlices,
   getSliceTasks,
+  _getAdapter,
 } from '../gsd-db.ts';
 import {
   renderRoadmapFromDb,
@@ -423,4 +424,48 @@ console.log('\n=== planning-crossval Test 6: ROADMAP descriptor projection dir =
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Test 7: Renderer strips bracket-wrapped depends from corrupt DB rows (#566)
+// ═══════════════════════════════════════════════════════════════════════════
+// Simulates a DB that was corrupted before the insertSlice validation guard
+// was added (issue #566). The renderer must recover "[S01]" → "S01" rather
+// than silently dropping the dependency and rendering depends:[].
+
+console.log('\n=== planning-crossval Test 7: renderer recovers bracket-wrapped depends (#566) ===');
+{
+  const base = realpathSync(createFixtureBase());
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  try {
+    scaffoldDirs(base, 'M001', ['S01', 'S02']);
+
+    insertMilestone({
+      id: 'M001',
+      title: 'Bracket Recovery',
+      status: 'active',
+      planning: { vision: 'Recover bracket-wrapped depends from corrupt DB.' },
+    });
+
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Foundation', status: 'pending', risk: 'low', depends: [], demo: 'Foundation done.', sequence: 1 });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Build', status: 'pending', risk: 'medium', depends: [], demo: 'Build done.', sequence: 2 });
+
+    // Bypass insertSlice validation to simulate pre-fix corrupt DB state
+    // (insertSlice now rejects bracket-wrapped IDs, but old DBs may have them)
+    _getAdapter()?.prepare('UPDATE slices SET depends = ? WHERE id = ? AND milestone_id = ?')
+      .run('["[S01]"]', 'S02', 'M001');
+
+    const rendered = await renderRoadmapFromDb(base, 'M001');
+    const content = readFileSync(rendered.roadmapPath, 'utf-8');
+    const parsed = parseRoadmapSlices(content);
+
+    assertEq(parsed.length, 2, 'T7: 2 slices parsed');
+    assertEq(parsed[1]?.depends.length, 1, 'T7: S02 has 1 dependency after bracket recovery');
+    assertEq(parsed[1]?.depends[0], 'S01', 'T7: recovered dependency is "S01", not "[S01]"');
+    assertTrue(content.includes('`depends:[S01]`'), 'T7: S02 renders with recovered depends:[S01] not empty depends:[]');
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+}
+
 report();