gsd-pi 2.82.0-dev.725028083 → 2.82.0-dev.ed17d078d

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

@@ -4,9 +4,14 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { createAutoOrchestrator } from "../auto/orchestrator.js";
+import { createAutoOrchestrator, STUCK_WINDOW_SIZE } from "../auto/orchestrator.js";
 import type { AutoOrchestratorDeps } from "../auto/contracts.js";
 import type { GSDState } from "../types.js";
+import { createWiredDispatchAdapter } from "../auto.js";
+import { resolveDispatch, type DispatchContext } from "../auto-dispatch.js";
+import { RuleRegistry, setRegistry, resetRegistry } from "../rule-registry.js";
+import type { UnifiedRule } from "../rule-types.js";
+import { supportsStructuredQuestions } from "../workflow-mcp.js";
 
 function makeState(): GSDState {
   return {
@@ -62,9 +67,13 @@ function makeDeps(overrides: Partial<AutoOrchestratorDeps> = {}): { deps: AutoOr
       async cleanupOnStop() { calls.push("worktree.cleanup"); },
     },
     health: {
+      checkResourcesStale() {
+        calls.push("health.stale");
+        return null;
+      },
       async preAdvanceGate() {
         calls.push("health.pre");
-        return { allow: true };
+        return { kind: "pass" };
       },
       async postAdvanceRecord() { calls.push("health.post"); },
     },
@@ -75,6 +84,9 @@ function makeDeps(overrides: Partial<AutoOrchestratorDeps> = {}): { deps: AutoOr
     notifications: {
       async notifyLifecycle(event) { calls.push(`notify:${event.name}`); },
     },
+    uokGate: {
+      async emit(input) { calls.push(`gate:${input.gateId}:${input.outcome}`); },
+    },
   };
 
   return { deps: { ...deps, ...overrides }, calls };
@@ -87,6 +99,7 @@ test("start() advances and records active unit", async () => {
   const result = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
 
   assert.equal(result.kind, "advanced");
+  assert.deepEqual(result.unit, { unitType: "execute-task", unitId: "T01" });
   const status = orchestrator.getStatus();
   assert.equal(status.phase, "running");
   assert.deepEqual(status.activeUnit, { unitType: "execute-task", unitId: "T01" });
@@ -95,9 +108,10 @@ test("start() advances and records active unit", async () => {
 });
 
 test("advance() returns blocked when health gate denies", async () => {
-  const { deps } = makeDeps({
+  const { deps, calls } = makeDeps({
     health: {
-      async preAdvanceGate() { return { allow: false, reason: "doctor-block" }; },
+      checkResourcesStale: () => null,
+      async preAdvanceGate() { return { kind: "fail", reason: "doctor-block" }; },
       async postAdvanceRecord() {},
     },
   });
@@ -107,6 +121,69 @@ test("advance() returns blocked when health gate denies", async () => {
 
   assert.equal(result.kind, "blocked");
   assert.equal(result.reason, "doctor-block");
+  assert.equal(result.action, "pause");
+  assert.ok(calls.includes("gate:pre-dispatch-health-gate:manual-attention"));
+});
+
+test("advance() returns blocked stop when resources are stale", async () => {
+  const { deps, calls } = makeDeps({
+    health: {
+      checkResourcesStale: () => "resources changed since session start",
+      async preAdvanceGate() { return { kind: "pass" }; },
+      async postAdvanceRecord() {},
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "blocked");
+  assert.equal(result.reason, "resources changed since session start");
+  assert.equal(result.action, "stop");
+  assert.ok(calls.includes("gate:resource-version-guard:fail"));
+  assert.ok(!calls.includes("health.pre"));
+  assert.ok(!calls.includes("state.reconcile"));
+});
+
+test("advance() continues past pre-dispatch health gate when it throws", async () => {
+  const { deps, calls } = makeDeps({
+    health: {
+      checkResourcesStale: () => null,
+      async preAdvanceGate() { return { kind: "threw", error: new Error("boom") }; },
+      async postAdvanceRecord() {},
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "advanced");
+  assert.ok(calls.includes("gate:pre-dispatch-health-gate:manual-attention"));
+  assert.ok(calls.includes("state.reconcile"));
+  assert.ok(calls.includes("dispatch.decide"));
+});
+
+test("advance() forwards fixesApplied into pre-dispatch-health-gate pass findings", async () => {
+  let observed = "";
+  const { deps } = makeDeps({
+    health: {
+      checkResourcesStale: () => null,
+      async preAdvanceGate() { return { kind: "pass", fixesApplied: ["fix-a", "fix-b"] }; },
+      async postAdvanceRecord() {},
+    },
+    uokGate: {
+      async emit(input) {
+        if (input.gateId === "pre-dispatch-health-gate" && input.outcome === "pass") {
+          observed = input.findings ?? "";
+        }
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+
+  assert.equal(observed, "fix-a, fix-b");
 });
 
 test("advance() follows the ADR-015 invariant sequence before journaling advance", async () => {
@@ -116,9 +193,13 @@ test("advance() follows the ADR-015 invariant sequence before journaling advance
   const result = await orchestrator.advance();
 
   assert.equal(result.kind, "advanced");
+  assert.deepEqual(result.unit, { unitType: "execute-task", unitId: "T01" });
   assert.deepEqual(calls, [
     "runtime.lock",
+    "health.stale",
+    "gate:resource-version-guard:pass",
     "health.pre",
+    "gate:pre-dispatch-health-gate:pass",
     "state.reconcile",
     "dispatch.decide",
     "tool.compile",
@@ -144,6 +225,7 @@ test("advance() blocks before dispatch when State Reconciliation blocks", async
 
   assert.equal(result.kind, "blocked");
   assert.equal(result.reason, "state drift blocked");
+  assert.equal(result.action, "pause");
   assert.ok(!calls.includes("dispatch.decide"));
   assert.ok(calls.includes("journal:advance-blocked"));
 });
@@ -163,6 +245,7 @@ test("advance() blocks before Runtime persistence when Tool Contract fails", asy
 
   assert.equal(result.kind, "blocked");
   assert.equal(result.reason, "unknown Unit");
+  assert.equal(result.action, "pause");
   assert.ok(!calls.includes("worktree.prepare"));
   assert.ok(!calls.includes("journal:advance"));
   assert.ok(calls.includes("journal:advance-blocked"));
@@ -185,6 +268,7 @@ test("advance() blocks before Runtime persistence when Worktree Safety fails", a
 
   assert.equal(result.kind, "blocked");
   assert.equal(result.reason, "worktree invalid");
+  assert.equal(result.action, "pause");
   assert.ok(!calls.includes("journal:advance"));
   assert.ok(!calls.includes("worktree.sync"));
   assert.ok(calls.includes("journal:advance-blocked"));
@@ -232,8 +316,10 @@ test("advance() is idempotent for the same active unit", async () => {
   const second = await orchestrator.advance();
 
   assert.equal(first.kind, "advanced");
+  assert.deepEqual(first.unit, { unitType: "execute-task", unitId: "T01" });
   assert.equal(second.kind, "blocked");
   assert.equal(second.reason, "idempotent advance: unit already active");
+  assert.equal(second.action, "stop");
 
   const prepareCalls = calls.filter((c) => c === "worktree.prepare").length;
   assert.equal(prepareCalls, 1);
@@ -468,3 +554,321 @@ test("stop() cleans up worktree and transitions to stopped", async () => {
   assert.ok(calls.includes("journal:stop"));
   assert.ok(calls.includes("notify:stop"));
 });
+
+// ────────────────────────────────────────────────────────────────────────
+// Stuck-loop ring buffer (issue #5787)
+// ────────────────────────────────────────────────────────────────────────
+
+test("STUCK_WINDOW_SIZE matches the legacy auto/phases.ts constant", () => {
+  assert.equal(STUCK_WINDOW_SIZE, 6);
+});
+
+test("stuck-loop: empty ring on a freshly constructed orchestrator advances normally", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "advanced");
+});
+
+test("stuck-loop: partial fill of mixed units does not block", async () => {
+  // Alternate A/B for STUCK_WINDOW_SIZE rounds. No single key saturates the
+  // window, so neither idempotency nor stuck-loop should fire.
+  let i = 0;
+  const sequence = ["A", "B", "A", "B", "A", "B"];
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        const id = sequence[i++ % sequence.length];
+        return { unitType: "execute-task", unitId: id, reason: "ready", preconditions: [] };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  for (let round = 0; round < STUCK_WINDOW_SIZE; round++) {
+    const result = await orchestrator.advance();
+    assert.equal(result.kind, "advanced", `round ${round} should advance, got ${result.kind}`);
+  }
+});
+
+test("stuck-loop: ring saturated with same unit blocks with action 'stop' and stuck-loop reason", async () => {
+  // Dispatch picks the same unit every time. The first advance succeeds.
+  // Calls 2..STUCK_WINDOW_SIZE-1 are idempotency-blocked while the ring fills.
+  // The STUCK_WINDOW_SIZE'th call sees a saturated ring and returns stuck-loop.
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const results: Awaited<ReturnType<typeof orchestrator.advance>>[] = [];
+  for (let i = 0; i < STUCK_WINDOW_SIZE; i++) {
+    results.push(await orchestrator.advance());
+  }
+
+  // First call advances.
+  assert.equal(results[0].kind, "advanced");
+
+  // Intermediate calls are blocked by idempotency (not stuck-loop yet).
+  for (let i = 1; i < STUCK_WINDOW_SIZE - 1; i++) {
+    const r = results[i];
+    assert.equal(r.kind, "blocked", `round ${i} should be blocked`);
+    if (r.kind !== "blocked") return;
+    assert.equal(r.reason, "idempotent advance: unit already active");
+    assert.equal(r.action, "stop");
+  }
+
+  // The final call (ring now holds STUCK_WINDOW_SIZE copies) returns stuck-loop.
+  const last = results[STUCK_WINDOW_SIZE - 1];
+  assert.equal(last.kind, "blocked");
+  if (last.kind !== "blocked") return;
+  assert.equal(last.action, "stop");
+  assert.equal(last.reason, `stuck-loop: execute-task:T01 picked ${STUCK_WINDOW_SIZE} times`);
+});
+
+test("stuck-loop: idempotency block continues to fire with its own reason before saturation", async () => {
+  // Two identical calls should produce idempotent (not stuck-loop). Ensures the
+  // existing idempotency block is not absorbed by the new check.
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(second.kind, "blocked");
+  assert.equal(second.reason, "idempotent advance: unit already active");
+  assert.equal(second.action, "stop");
+});
+
+test("stuck-loop: start() resets the ring so a fresh saturation cycle is required", async () => {
+  // Fill the ring to one short of saturation, then start() — the ring should
+  // be cleared, and the next advance must succeed instead of going stuck.
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  for (let i = 0; i < STUCK_WINDOW_SIZE - 1; i++) {
+    await orchestrator.advance();
+  }
+
+  const restarted = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+  assert.equal(restarted.kind, "advanced");
+
+  // Immediately after start(), the next advance is idempotent (one element in
+  // ring), not stuck-loop, confirming the ring was reset.
+  const next = await orchestrator.advance();
+  assert.equal(next.kind, "blocked");
+  assert.equal(next.reason, "idempotent advance: unit already active");
+});
+
+test("stuck-loop: resume() resets the ring", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  for (let i = 0; i < STUCK_WINDOW_SIZE - 1; i++) {
+    await orchestrator.advance();
+  }
+
+  const resumed = await orchestrator.resume();
+  assert.equal(resumed.kind, "advanced");
+
+  const next = await orchestrator.advance();
+  assert.equal(next.kind, "blocked");
+  assert.equal(next.reason, "idempotent advance: unit already active");
+});
+
+test("stuck-loop: stop() resets the ring", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  for (let i = 0; i < STUCK_WINDOW_SIZE - 1; i++) {
+    await orchestrator.advance();
+  }
+
+  const stopped = await orchestrator.stop("user-request");
+  assert.equal(stopped.kind, "stopped");
+
+  // Ring is cleared by stop(). A subsequent advance is a fresh first-touch.
+  const next = await orchestrator.advance();
+  assert.equal(next.kind, "advanced");
+});
+
+test("stuck-loop: journal records the stuck-loop reason on advance-blocked", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  for (let i = 0; i < STUCK_WINDOW_SIZE; i++) {
+    await orchestrator.advance();
+  }
+
+  assert.ok(calls.includes("journal:advance-blocked"));
+});
+
+// ─── #5789 parity: wired dispatch adapter mirrors runDispatch's resolveDispatch call ───
+
+test("wired DispatchAdapter forwards session-derived dispatch inputs identically to runDispatch", async () => {
+  const stateSnapshot = makeState();
+
+  // Install a capturing registry so we observe the DispatchContext both code paths
+  // build, and force a deterministic dispatch action so the parity assertion is
+  // about *inputs*, not rule evaluation.
+  const captured: DispatchContext[] = [];
+  const captureRule: UnifiedRule = {
+    name: "test-capture",
+    when: "dispatch",
+    evaluation: "first-match",
+    where: async (ctx: DispatchContext) => {
+      captured.push(ctx);
+      return {
+        action: "dispatch" as const,
+        unitType: "execute-task",
+        unitId: "T01",
+        prompt: "parity-fixture",
+      };
+    },
+    then: (r: unknown) => r,
+  };
+  setRegistry(new RuleRegistry([captureRule]));
+
+  try {
+    // Mock ExtensionContext + ExtensionAPI with the surface the wired adapter touches.
+    const fakeModelRegistry = {
+      getAll: () => [],
+      getProviderAuthMode: (_provider: string) => "apiKey" as const,
+    };
+    const ctx = {
+      model: {
+        provider: "anthropic",
+        baseUrl: "https://api.anthropic.com",
+        contextWindow: 200_000,
+      },
+      modelRegistry: fakeModelRegistry,
+    } as any;
+    const pi = {
+      getActiveTools: () => ["read_file", "write_file"],
+    } as any;
+    const basePath = "/tmp/parity-fixture";
+
+    // Path A — wired adapter (what createWiredAutoOrchestrationModule uses).
+    const adapter = createWiredDispatchAdapter(ctx, pi, basePath);
+    const adapterResult = await adapter.decideNextUnit({ stateSnapshot });
+
+    // Path B — direct resolveDispatch call mirroring phases.ts:runDispatch.
+    // Inline the same derivations runDispatch uses so any drift here is a parity break.
+    const prefs = undefined; // loadEffectiveGSDPreferences returns null for /tmp/parity-fixture.
+    const provider = ctx.model?.provider;
+    const authMode = provider && typeof ctx.modelRegistry?.getProviderAuthMode === "function"
+      ? ctx.modelRegistry.getProviderAuthMode(provider)
+      : undefined;
+    const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+    const structuredQuestionsAvailable: "true" | "false" =
+      prefs !== undefined && (prefs as { planning_depth?: string }).planning_depth === "deep"
+        ? "false"
+        : supportsStructuredQuestions(activeTools, {
+            authMode,
+            baseUrl: ctx.model?.baseUrl,
+          })
+          ? "true"
+          : "false";
+
+    const builtDirectCtx: DispatchContext = {
+      basePath,
+      mid: stateSnapshot.activeMilestone!.id,
+      midTitle: stateSnapshot.activeMilestone!.title,
+      state: stateSnapshot,
+      prefs,
+      structuredQuestionsAvailable,
+      sessionContextWindow: ctx.model?.contextWindow,
+      sessionProvider: ctx.model?.provider,
+      modelRegistry: ctx.modelRegistry,
+    };
+    const directAction = await resolveDispatch(builtDirectCtx);
+
+    // Two contexts captured: one per resolveDispatch call.
+    assert.equal(captured.length, 2, "expected two captured dispatch contexts");
+    const [adapterCtx, directCtx] = captured;
+
+    // Parity assertion: session-derived fields are identical.
+    assert.equal(adapterCtx.structuredQuestionsAvailable, directCtx.structuredQuestionsAvailable);
+    assert.equal(adapterCtx.sessionContextWindow, directCtx.sessionContextWindow);
+    assert.equal(adapterCtx.sessionProvider, directCtx.sessionProvider);
+    assert.equal(adapterCtx.modelRegistry, directCtx.modelRegistry);
+    assert.equal(adapterCtx.basePath, directCtx.basePath);
+    assert.equal(adapterCtx.mid, directCtx.mid);
+    assert.equal(adapterCtx.midTitle, directCtx.midTitle);
+
+    // Dispatch action equality: both flows reach the same dispatch decision.
+    assert.ok(adapterResult);
+    assert.equal(adapterResult.unitType, "execute-task");
+    assert.equal(adapterResult.unitId, "T01");
+    assert.equal(adapterResult.reason, "test-capture");
+    assert.equal(directAction.action, "dispatch");
+    if (directAction.action === "dispatch") {
+      assert.equal(directAction.unitType, adapterResult.unitType);
+      assert.equal(directAction.unitId, adapterResult.unitId);
+      assert.equal(directAction.matchedRule, adapterResult.reason);
+    }
+  } finally {
+    resetRegistry();
+  }
+});
+
+test("wired DispatchAdapter prefers caller-supplied dispatch inputs over ctx-derived values", async () => {
+  const stateSnapshot = makeState();
+  const captured: DispatchContext[] = [];
+  const captureRule: UnifiedRule = {
+    name: "test-capture-overrides",
+    when: "dispatch",
+    evaluation: "first-match",
+    where: async (ctx: DispatchContext) => {
+      captured.push(ctx);
+      return {
+        action: "dispatch" as const,
+        unitType: "execute-task",
+        unitId: "T01",
+        prompt: "override-fixture",
+      };
+    },
+    then: (r: unknown) => r,
+  };
+  setRegistry(new RuleRegistry([captureRule]));
+
+  try {
+    const ctxModelRegistry = {
+      getAll: () => [],
+      getProviderAuthMode: (_provider: string) => "apiKey" as const,
+    };
+    const overrideModelRegistry = {
+      getAll: () => [],
+      getProviderAuthMode: (_provider: string) => "oauth" as const,
+    };
+    const ctx = {
+      model: {
+        provider: "anthropic",
+        baseUrl: "https://api.anthropic.com",
+        contextWindow: 200_000,
+      },
+      modelRegistry: ctxModelRegistry,
+    } as any;
+    const pi = {
+      getActiveTools: () => [],
+    } as any;
+    const adapter = createWiredDispatchAdapter(ctx, pi, "/tmp/parity-fixture");
+
+    const result = await adapter.decideNextUnit({
+      stateSnapshot,
+      structuredQuestionsAvailable: "true",
+      sessionContextWindow: 500_000,
+      sessionProvider: "openai",
+      modelRegistry: overrideModelRegistry,
+    });
+
+    assert.ok(result);
+    assert.equal(captured.length, 1, "expected one captured dispatch context");
+    assert.equal(captured[0].structuredQuestionsAvailable, "true");
+    assert.equal(captured[0].sessionContextWindow, 500_000);
+    assert.equal(captured[0].sessionProvider, "openai");
+    assert.equal(captured[0].modelRegistry, overrideModelRegistry);
+  } finally {
+    resetRegistry();
+  }
+});

package/src/resources/extensions/gsd/tests/auto-runtime-state.test.ts

@@ -12,10 +12,10 @@ test("getAutoRuntimeSnapshot includes orchestration phase when available", () =>
   autoSession.active = true;
   autoSession.basePath = "/tmp/project";
   autoSession.orchestration = {
-    async start() { return { kind: "advanced" as const }; },
-    async advance() { return { kind: "advanced" as const }; },
-    async resume() { return { kind: "advanced" as const }; },
-    async stop() { return { kind: "stopped" as const }; },
+    async start() { return { kind: "stopped" as const, reason: "test" }; },
+    async advance() { return { kind: "stopped" as const, reason: "test" }; },
+    async resume() { return { kind: "stopped" as const, reason: "test" }; },
+    async stop() { return { kind: "stopped" as const, reason: "test" }; },
     getStatus() {
       return { phase: "running" as const, transitionCount: 3, lastTransitionAt: 123 };
     },

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 });
     }
 });