gsd-pi 2.82.0-dev.725028083 → 2.82.0-dev.9d5798940

package/src/resources/extensions/gsd/tests/brief-command.test.ts

@@ -0,0 +1,89 @@
+// GSD-2 + /gsd brief command behavior tests
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { GSD_COMMAND_DESCRIPTION, getGsdArgumentCompletions } from "../commands/catalog.ts";
+import { handleCoreCommand, showHelp } from "../commands/handlers/core.ts";
+import { VISUAL_BRIEF_USAGE } from "../../visual-brief/prompts.ts";
+
+function createMockCtx() {
+  const notifications: { message: string; level: string }[] = [];
+  return {
+    notifications,
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+      custom: async () => undefined,
+    },
+  };
+}
+
+function createMockPi() {
+  const sentMessages: string[] = [];
+  return {
+    sentMessages,
+    sendUserMessage(content: string) {
+      sentMessages.push(content);
+    },
+  };
+}
+
+test("/gsd brief appears in the command description and top-level completions", () => {
+  assert.match(GSD_COMMAND_DESCRIPTION, /brief/);
+
+  const completions = getGsdArgumentCompletions("br");
+  const entry = completions.find((completion) => completion.value === "brief");
+
+  assert.ok(entry, "brief should appear in top-level completions");
+  assert.match(entry.description, /visual HTML brief/i);
+});
+
+test("/gsd brief exposes Visual Brief mode completions", () => {
+  const completions = getGsdArgumentCompletions("brief d");
+
+  assert.ok(
+    completions.some((completion) => completion.value === "brief diagram"),
+    "diagram should be suggested as a /gsd brief mode",
+  );
+  assert.ok(
+    getGsdArgumentCompletions("brief ").some((completion) => completion.value === "brief diff"),
+    "diff should be suggested after /gsd brief",
+  );
+});
+
+test("/gsd brief sends a Visual Brief prompt for valid args", async () => {
+  const ctx = createMockCtx();
+  const pi = createMockPi();
+
+  const handled = await handleCoreCommand("brief diagram extension loading lifecycle", ctx as any, pi as any);
+
+  assert.equal(handled, true);
+  assert.equal(ctx.notifications.length, 0);
+  assert.equal(pi.sentMessages.length, 1);
+  assert.match(pi.sentMessages[0], /Mode: diagram/);
+  assert.match(pi.sentMessages[0], /Subject: extension loading lifecycle/);
+  assert.match(pi.sentMessages[0], /Output directory:/);
+});
+
+test("/gsd brief reports usage for empty args instead of sending a prompt", async () => {
+  const ctx = createMockCtx();
+  const pi = createMockPi();
+
+  const handled = await handleCoreCommand("brief", ctx as any, pi as any);
+
+  assert.equal(handled, true);
+  assert.equal(pi.sentMessages.length, 0);
+  assert.deepEqual(ctx.notifications, [{ message: VISUAL_BRIEF_USAGE, level: "info" }]);
+});
+
+test("/gsd help full lists brief separately from visualize", () => {
+  const ctx = createMockCtx();
+
+  showHelp(ctx as any, "full");
+
+  const help = ctx.notifications.at(0)?.message ?? "";
+  assert.match(help, /\/gsd visualize\s+Interactive 10-tab TUI/);
+  assert.match(help, /\/gsd brief <mode>\s+Generate a visual HTML brief/);
+});

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -8,7 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -208,8 +208,8 @@ test("postflightPopStash conflict warning names the exact stash ref", () => {
     assert.match(postflight.message, /failed after merge of milestone M005C/);
 
     const warning = notifications.find((n) => n.level === "warning")?.msg ?? "";
-    assert.match(warning, /git stash pop stash@\{\d+\}/);
     assert.match(warning, /git stash apply stash@\{\d+\}/);
+    assert.match(warning, /git stash drop stash@\{\d+\}/);
   } finally {
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
@@ -279,3 +279,108 @@ test("postflightPopStash falls back to milestone marker prefix when exact marker
     try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
   }
 });
+
+test("postflightPopStash preserves stash when untracked collision differs from merged file", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "local preflight test\n");
+    const preflight = preflightCleanRoot(repo, "M009", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked file");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add merged test"', repo);
+
+    const notifications: Array<{ msg: string; level: string }> = [];
+    const postflight = postflightPopStash(repo, "M009", preflight.stashMarker, (msg, level) => {
+      notifications.push({ msg, level });
+    });
+
+    assert.equal(postflight.needsManualRecovery, false, "different already-present untracked files must not stop auto-mode");
+    assert.equal(postflight.resolution, "already-present-preserved");
+    assert.deepEqual(postflight.collidedPaths, ["tests.txt"]);
+    assert.equal(readFileSync(join(repo, "tests.txt"), "utf-8"), "merged milestone test\n");
+    assert.equal(run("git status --porcelain", repo), "", "merged file must stay clean");
+
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "stash backup must be preserved");
+    assert.ok(
+      notifications.some((n) => n.level === "warning" && n.msg.includes("preserving")),
+      "user must be warned that the stash was preserved as backup",
+    );
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash drops stash when untracked collision is identical to merged file", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "same test content\n");
+    const preflight = preflightCleanRoot(repo, "M010", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked file");
+
+    writeFileSync(join(repo, "tests.txt"), "same test content\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add same test"', repo);
+
+    const postflight = postflightPopStash(repo, "M010", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, false, "identical already-present files must not stop auto-mode");
+    assert.equal(postflight.resolution, "already-present-dropped");
+    assert.equal(readFileSync(join(repo, "tests.txt"), "utf-8"), "same test content\n");
+
+    const stashList = run("git stash list", repo);
+    assert.ok(!stashList.includes(preflight.stashMarker ?? ""), "identical stash must be dropped");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash requires manual recovery for mixed tracked changes and untracked collision", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "README.md"), "# local tracked work\n");
+    writeFileSync(join(repo, "tests.txt"), "local untracked work\n");
+    const preflight = preflightCleanRoot(repo, "M011", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash mixed changes");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add merged test"', repo);
+
+    const postflight = postflightPopStash(repo, "M011", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, true, "tracked stash payload must still require manual recovery");
+    assert.equal(postflight.resolution, "manual-recovery");
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "mixed stash must be preserved");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});
+
+test("postflightPopStash requires manual recovery when an untracked stash path is missing after collision", () => {
+  const repo = createTempRepo();
+  try {
+    writeFileSync(join(repo, "tests.txt"), "local untracked work\n");
+    writeFileSync(join(repo, "other-tests.txt"), "other local untracked work\n");
+    const preflight = preflightCleanRoot(repo, "M012", () => {});
+    assert.equal(preflight.stashPushed, true, "preflight must stash untracked files");
+
+    writeFileSync(join(repo, "tests.txt"), "merged milestone test\n");
+    run("git add tests.txt", repo);
+    run('git commit -m "feat: add one merged test"', repo);
+
+    const postflight = postflightPopStash(repo, "M012", preflight.stashMarker, () => {});
+
+    assert.equal(postflight.needsManualRecovery, true, "partial untracked restores must still require manual recovery");
+    assert.equal(postflight.resolution, "manual-recovery");
+    assert.equal(existsSync(join(repo, "other-tests.txt")), true, "git may partially restore the non-colliding path");
+    assert.match(run("git status --porcelain", repo), /\?\? other-tests\.txt/, "partial restore must leave manual recovery visible");
+    const stashList = run("git stash list", repo);
+    assert.ok(preflight.stashMarker && stashList.includes(preflight.stashMarker), "stash must remain for manual recovery");
+  } finally {
+    try { rmSync(repo, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* ignore */ }
+  }
+});

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

@@ -0,0 +1,16 @@
+// Project/App: GSD-2
+// File Purpose: Tests closeout git action deferral policy for auto-mode units.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { shouldDeferCloseoutGitAction } from "../auto-post-unit.ts";
+
+test("execute-task defers closeout git action until verification passes", () => {
+  assert.equal(shouldDeferCloseoutGitAction("execute-task"), true);
+});
+
+test("non execute-task units keep pre-verification closeout git action", () => {
+  assert.equal(shouldDeferCloseoutGitAction("plan-slice"), false);
+  assert.equal(shouldDeferCloseoutGitAction("complete-slice"), false);
+});

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -10,7 +10,7 @@ import { runDispatch, runPreDispatch } from "../auto/phases.ts";
 import { AutoSession } from "../auto/session.ts";
 import { resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 import { bootstrapAutoSession } from "../auto-start.ts";
-import { postUnitPreVerification } from "../auto-post-unit.ts";
+import { postUnitPostVerification, postUnitPreVerification } from "../auto-post-unit.ts";
 import { resolveDispatch, setResearchProjectPromptBuilderForTest } from "../auto-dispatch.ts";
 import { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { finalizeProjectResearchTimeout } from "../project-research-policy.ts";
@@ -1587,6 +1587,61 @@ test("deep project setup: discuss-milestone question failure pauses instead of a
   }
 });
 
+test("verified task git closeout failure retries and continues auto-mode", async () => {
+  const base = makeBase();
+  try {
+    execFileSync("git", ["init"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "Test User"], { cwd: base, stdio: "ignore" });
+    const hookPath = join(base, ".git", "hooks", "pre-commit");
+    writeFileSync(
+      hookPath,
+      [
+        "#!/bin/sh",
+        "count_file=.git/pre-commit-count",
+        "count=0",
+        "if [ -f \"$count_file\" ]; then count=$(cat \"$count_file\"); fi",
+        "count=$((count + 1))",
+        "printf \"%s\" \"$count\" > \"$count_file\"",
+        "echo blocked by test hook >&2",
+        "exit 1",
+      ].join("\n"),
+    );
+    chmodSync(hookPath, 0o755);
+    writeFileSync(join(base, "work.txt"), "changed\n");
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+
+    let pauseCalled = false;
+    const notifications: Array<{ message: string; severity?: string }> = [];
+    const result = await postUnitPostVerification({
+      s,
+      ctx: { ui: { notify: (message: string, severity?: string) => notifications.push({ message, severity }) } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}) as any,
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => { pauseCalled = true; },
+      updateProgressWidget: () => {},
+    });
+
+    assert.equal(result, "continue");
+    assert.equal(pauseCalled, false);
+    assert.equal(s.lastGitActionStatus, "failed");
+    assert.equal(readFileSync(join(base, ".git", "pre-commit-count"), "utf-8"), "3");
+    assert.ok(
+      notifications.some((entry) => entry.severity === "warning" && entry.message.includes("Git commit failed")),
+      "verified task git closeout failure should warn instead of stopping auto-mode",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("deep project setup: approval wait wins over deterministic write-gate placeholder", async () => {
   const base = makeBase();
   try {

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

@@ -118,3 +118,42 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.reason, "All milestones complete.");
   });
 });
+
+describe("complete milestone context recovery guard (#5831)", () => {
+  let base = "";
+  const executionEntryRule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "execution-entry phase (no context) → discuss-milestone",
+  );
+  const prePlanningRule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "pre-planning (no context) → discuss-milestone",
+  );
+  assert.ok(executionEntryRule, "execution-entry missing-context rule should exist");
+  assert.ok(prePlanningRule, "pre-planning missing-context rule should exist");
+
+  afterEach(() => {
+    if (base) rmSync(base, { recursive: true, force: true });
+    base = "";
+  });
+
+  test("does not discuss a complete execution-entry milestone with no CONTEXT file", async () => {
+    base = makeBase();
+    const ctx = buildDispatchCtx(base);
+    ctx.state.registry = [{ id: "M001", title: "Milestone One", status: "complete" }];
+    ctx.state.phase = "completing-milestone";
+
+    const result = await executionEntryRule.match(ctx);
+
+    assert.equal(result, null);
+  });
+
+  test("does not discuss a complete pre-planning milestone with no CONTEXT file", async () => {
+    base = makeBase();
+    const ctx = buildDispatchCtx(base);
+    ctx.state.registry = [{ id: "M001", title: "Milestone One", status: "complete" }];
+    ctx.state.phase = "pre-planning";
+
+    const result = await prePlanningRule.match(ctx);
+
+    assert.equal(result, null);
+  });
+});

package/src/resources/extensions/gsd/tests/evidence-cross-ref.test.ts

@@ -0,0 +1,38 @@
+// Project/App: GSD-2
+// File Purpose: Tests for verification evidence cross-reference mismatch policy.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { crossReferenceEvidence } from "../safety/evidence-cross-ref.ts";
+import type { EvidenceEntry } from "../safety/evidence-collector.ts";
+
+test("claims of passing verification become errors when recorded bash evidence failed", () => {
+  const mismatches = crossReferenceEvidence(
+    [{ command: "npm test", exitCode: 0, verdict: "passed" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command: "npm test",
+        exitCode: 1,
+        outputSnippet: "failed",
+        timestamp: Date.now(),
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "error");
+  assert.match(mismatches[0].reason, /Claimed exitCode=0/);
+});
+
+test("missing recorded bash evidence remains a warning", () => {
+  const mismatches = crossReferenceEvidence(
+    [{ command: "npm test", exitCode: 0, verdict: "passed" }],
+    [],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "warning");
+});

package/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts

@@ -141,6 +141,14 @@ test("Feature 1: executive summary paragraph is rendered", () => {
   assert.ok(html.includes("$2.50 spent"), "should contain cost");
 });
 
+test("report uses the shared GSD HTML shell", () => {
+  const html = generateHtmlReport(mockData(), mockOpts());
+  assert.ok(html.includes('<span class="logo">GSD</span>'), "should render shared shell logo");
+  assert.ok(html.includes('<span class="kind-chip">Report</span>'), "should render report kind chip");
+  assert.ok(html.includes('<nav class="toc" aria-label="Report sections">'), "should render shared shell TOC");
+  assert.ok(html.includes('<main>'), "should render content inside shared shell main");
+});
+
 test("Feature 1: executive summary includes budget context when set", () => {
   const data = mockData({ health: { ...mockData().health, budgetCeiling: 10.00 } });
   const html = generateHtmlReport(data, mockOpts());

package/src/resources/extensions/gsd/tests/integration/migrate-command.test.ts

@@ -14,7 +14,9 @@ import {
   generatePreview,
   writeGSDDirectory,
 } from '../../migrate/index.ts';
+import { importWrittenMigrationToDb } from '../../migrate/command.ts';
 import { deriveState } from '../../state.ts';
+import { closeDatabase, getDecisionById, getRequirementCounts } from '../../gsd-db.ts';
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -52,6 +54,16 @@ const SAMPLE_REQUIREMENTS = `# Requirements
 - Description: Output matches GSD format.
 `;
 
+const SAMPLE_REQUIREMENTS_LEGACY_IDS = `# Requirements
+
+## Active
+
+- [ ] **CORE-PIPELINE**: Pipeline must work end-to-end.
+- [ ] **OUTPUT-FORMAT**: Output matches GSD format.
+- [ ] **IMPORT-DB**: Migration imports requirements into the DB.
+- [ ] **STATUS-WIDGET**: Status can query migrated requirements.
+`;
+
 const SAMPLE_STATE = `# State
 
 **Current Phase:** 20-features
@@ -166,14 +178,14 @@ Depends on foundation work.
 </context>
 `;
 
-function createCompleteFixture(): string {
+function createCompleteFixture(requirementsContent: string = SAMPLE_REQUIREMENTS): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-cmd-test-'));
   const planning = join(base, '.planning');
   mkdirSync(planning, { recursive: true });
 
   writeFileSync(join(planning, 'PROJECT.md'), SAMPLE_PROJECT);
   writeFileSync(join(planning, 'ROADMAP.md'), SAMPLE_ROADMAP);
-  writeFileSync(join(planning, 'REQUIREMENTS.md'), SAMPLE_REQUIREMENTS);
+  writeFileSync(join(planning, 'REQUIREMENTS.md'), requirementsContent);
   writeFileSync(join(planning, 'STATE.md'), SAMPLE_STATE);
   writeFileSync(join(planning, 'config.json'), SAMPLE_CONFIG);
 
@@ -303,6 +315,7 @@ test('Full pipeline: parse → transform → preview → write → deriveState',
       const expectedTaskPct = totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0;
       assert.deepStrictEqual(preview.sliceCompletionPct, expectedSlicePct, 'pipeline: preview sliceCompletionPct');
       assert.deepStrictEqual(preview.taskCompletionPct, expectedTaskPct, 'pipeline: preview taskCompletionPct');
+      assert.deepStrictEqual(preview.decisions.total, 1, 'pipeline: preview decisions total');
 
       // Requirements in preview
       assert.deepStrictEqual(preview.requirements.active, 1, 'pipeline: preview requirements active');
@@ -342,6 +355,39 @@ test('Full pipeline: parse → transform → preview → write → deriveState',
     }
 });
 
+test('Full pipeline: legacy requirement IDs import into DB with canonical IDs', async () => {
+    const base = createCompleteFixture(SAMPLE_REQUIREMENTS_LEGACY_IDS);
+    const writeTarget = mkdtempSync(join(tmpdir(), 'gsd-cmd-legacy-reqs-'));
+    try {
+      const parsed = await parsePlanningDirectory(join(base, '.planning'));
+      const project = transformToGSD(parsed);
+      const preview = generatePreview(project);
+
+      assert.deepStrictEqual(
+        project.requirements.map((req) => req.id),
+        ['R001', 'R002', 'R003', 'R004'],
+        'legacy-reqs: transform assigns canonical R IDs',
+      );
+      assert.ok(
+        project.requirements[0]?.description.includes('Legacy ID: CORE-PIPELINE'),
+        'legacy-reqs: original ID survives in migrated requirement content',
+      );
+
+      await writeGSDDirectory(project, writeTarget);
+      const imported = await importWrittenMigrationToDb(writeTarget, preview);
+      const counts = getRequirementCounts();
+
+      assert.deepStrictEqual(imported.decisions, 1, 'legacy-reqs: DB import includes migrated decisions');
+      assert.deepStrictEqual(imported.requirements, 4, 'legacy-reqs: DB import count matches preview');
+      assert.ok(getDecisionById('D001') !== null, 'legacy-reqs: migrated decision is queryable');
+      assert.deepStrictEqual(counts.total, 4, 'legacy-reqs: DB stores all migrated requirements');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+      rmSync(writeTarget, { recursive: true, force: true });
+    }
+});
+
   // ─── Test 6: .gsd/ exists detection ────────────────────────────────────
 
 test('.gsd/ exists detection', () => {
@@ -357,4 +403,3 @@ test('.gsd/ exists detection', () => {
       rmSync(base, { recursive: true, force: true });
     }
 });
-

package/src/resources/extensions/gsd/tests/migrate-transformer.test.ts

@@ -497,6 +497,7 @@ test('Scenario 11: Requirements edge cases', () => {
       makeRequirement('', 'Another No ID', 'validated'),
       makeRequirement('R005', 'Has ID', 'something-weird'),
       makeRequirement('R006', 'Deferred One', 'DEFERRED'),
+      makeRequirement('AUTH-7', 'Legacy ID', 'active'),
     ],
     phases: {
       '1-req-edge': makePhase('1-req-edge', 1, 'req-edge'),
@@ -510,6 +511,8 @@ test('Scenario 11: Requirements edge cases', () => {
   assert.deepStrictEqual(result.requirements[2]?.id, 'R005', 'req-edge: existing id preserved');
   assert.deepStrictEqual(result.requirements[2]?.status, 'active', 'req-edge: unknown status normalized to active');
   assert.deepStrictEqual(result.requirements[3]?.status, 'deferred', 'req-edge: uppercase DEFERRED normalized');
+  assert.deepStrictEqual(result.requirements[4]?.id, 'R003', 'req-edge: non-R legacy id gets next canonical id');
+  assert.ok(result.requirements[4]?.description.includes('Legacy ID: AUTH-7'), 'req-edge: original legacy id is preserved in description');
 });
 
 // ─── Scenario 12: Vision derivation ────────────────────────────────────────
@@ -553,6 +556,8 @@ test('Scenario 13: Decisions content', () => {
   const result = transformToGSD(project);
 
   assert.ok(result.decisionsContent.includes('decision-01'), 'decisions: extracts key-decisions from summaries');
+  assert.ok(result.decisionsContent.includes('| D001 |'), 'decisions: writes DB-importable decision ID');
+  assert.ok(result.decisionsContent.includes('| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |'), 'decisions: writes canonical table header');
 });
 
 // ─── Scenario 14: No undefined values in output ───────────────────────────
@@ -616,4 +621,3 @@ test('Scenario 15: Empty research', () => {
 });
 
 // ─── Results ───────────────────────────────────────────────────────────────
-

package/src/resources/extensions/gsd/tests/migrate-writer-integration.test.ts

@@ -14,7 +14,7 @@ import { parseSummary } from '../files.ts';
 import { deriveState } from '../state.ts';
 import { invalidateAllCaches } from '../cache.ts';
 import { ensureDbOpen } from '../bootstrap/dynamic-tools.ts';
-import { closeDatabase, getAllMilestones } from '../gsd-db.ts';
+import { closeDatabase, getAllMilestones, getArtifact } from '../gsd-db.ts';
 import { importWrittenMigrationToDb } from '../migrate/command.ts';
 import type {
   GSDProject,
@@ -336,7 +336,12 @@ test('Scenario 2: Fully complete project — deriveState phase', async () => {
       assert.deepStrictEqual(preview.taskCompletionPct, 100, 'complete: preview taskCompletionPct');
       assert.deepStrictEqual(preview.requirements.total, 0, 'complete: preview requirements total');
 
+      const imported = await importWrittenMigrationToDb(base, preview);
+      assert.ok(imported.artifacts >= 6, 'complete: imports generated milestone artifacts');
+      assert.ok(getArtifact('milestones/M001/M001-VALIDATION.md') !== null, 'complete: M001-VALIDATION.md imported as artifact');
+      assert.ok(getArtifact('milestones/M001/M001-SUMMARY.md') !== null, 'complete: M001-SUMMARY.md imported as artifact');
     } finally {
+      closeDatabase();
       rmSync(base, { recursive: true, force: true });
     }
 });

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

@@ -7,7 +7,7 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -48,6 +48,60 @@ test("parkMilestone updates DB status to 'parked' (#2694)", () => {
   }
 });
 
+test("parkMilestone ignores blocked SUMMARY.md when DB milestone is active (#5828)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
+      [
+        "---",
+        "status: closeout_blocked",
+        "---",
+        "",
+        "# M001 Summary",
+        "",
+        "Completion was not persisted.",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const parked = parkMilestone(base, "M001", "test");
+
+    assert.ok(parked, "active DB row should allow parking despite a blocked SUMMARY.md");
+    assert.ok(
+      existsSync(join(base, ".gsd", "milestones", "M001", "M001-PARKED.md")),
+      "PARKED.md should be written",
+    );
+    assert.equal(getMilestone("M001")!.status, "parked", "DB status should be parked");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("parkMilestone refuses DB-complete milestones (#5828)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const parked = parkMilestone(base, "M001", "test");
+
+    assert.equal(parked, false, "complete DB row should not be parkable");
+    assert.equal(
+      existsSync(join(base, ".gsd", "milestones", "M001", "M001-PARKED.md")),
+      false,
+      "PARKED.md should not be written",
+    );
+    assert.equal(getMilestone("M001")!.status, "complete", "DB status should remain complete");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("unparkMilestone updates DB status to 'active' (#2694)", () => {
   const base = createBase();
   try {

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

@@ -125,6 +125,31 @@ test('handlePlanSlice advances DB-derived state out of planning immediately', as
   }
 });
 
+test('handlePlanSlice clears sketch flag so DB-derived state leaves refining', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.', isSketch: true });
+
+    invalidateStateCache();
+    const before = await deriveState(base);
+    assert.equal(before.phase, 'refining');
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.equal(getSlice('M001', 'S02')?.is_sketch, 0, 'planned slice must no longer be treated as a sketch');
+
+    invalidateStateCache();
+    const after = await deriveState(base);
+    assert.notEqual(after.phase, 'refining');
+    assert.equal(after.progress?.tasks?.total, 2);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice leaves omitted enrichment fields empty instead of rendering placeholders', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));