gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

package/src/resources/extensions/gsd/tests/integration/doctor-git.test.ts

@@ -1,3 +1,4 @@
+// GSD-2 doctor git integration tests
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 /**
@@ -13,7 +14,7 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync, readFileSync, symlinkSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 
 import { runGSDDoctor } from "../../doctor.ts";
 import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../../gsd-db.ts";
@@ -76,6 +77,21 @@ Completed.
   return dir;
 }
 
+function createStashApplyConflict(): string {
+  const dir = createRepoWithCompletedMilestone();
+  writeFileSync(join(dir, "README.md"), "# local stashed work\n");
+  run('git stash push -m "local work"', dir);
+  writeFileSync(join(dir, "README.md"), "# merged milestone work\n");
+  run("git add README.md", dir);
+  run('git commit -m "feat: merged readme"', dir);
+  const apply = spawnSync("git", ["stash", "apply", "stash@{0}"], {
+    cwd: dir,
+    encoding: "utf-8",
+  });
+  if (apply.error) throw apply.error;
+  return dir;
+}
+
 /** Create a repo whose slices are done but milestone closeout is still pending. */
 function createRepoWithSlicesDoneButNoMilestoneSummary(): string {
   const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
@@ -294,6 +310,26 @@ describe('doctor-git', async () => {
       assert.ok(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after fix");
     });
 
+    test('unresolved_git_conflicts is manual-only and preserves conflict state', async () => {
+      const dir = createStashApplyConflict();
+      cleanups.push(dir);
+      assert.equal(existsSync(join(dir, ".git", "MERGE_HEAD")), false, "stash apply conflict should not require MERGE_HEAD");
+
+      const detect = await runGSDDoctor(dir);
+      const conflictIssues = detect.issues.filter(i => i.code === "unresolved_git_conflicts");
+      assert.equal(conflictIssues.length, 1, "detects unresolved Git conflict index");
+      assert.equal(conflictIssues[0]?.severity, "error");
+      assert.equal(conflictIssues[0]?.fixable, false);
+      assert.match(conflictIssues[0]?.message ?? "", /README\.md/);
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assert.ok(
+        !fixed.fixesApplied.some((fix) => fix.includes("cleaned merge state")),
+        "doctor fix must not reset conflict files",
+      );
+      assert.match(run("git diff --name-only --diff-filter=U", dir), /README\.md/, "conflict remains for manual resolution");
+    });
+
     // ─── Test 4: Tracked runtime files detection & fix ─────────────────
     test('tracked_runtime_files', async () => {
       const dir = createRepoWithCompletedMilestone();
@@ -761,6 +797,49 @@ describe('doctor-git', async () => {
       assert.ok(log.includes("gsd snapshot"), "commit is tagged with gsd snapshot");
     });
 
+    test('stale_uncommitted_changes (skips snapshot when tracked changes contain conflict markers)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
+      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
+      execSync(`git commit --amend --no-edit`, {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
+      });
+
+      writeFileSync(join(dir, "README.md"), [
+        "# test",
+        "<<<<<<< Updated upstream",
+        "modified content",
+        "=======",
+        "stashed content",
+        ">>>>>>> Stashed changes",
+        "",
+      ].join("\n"));
+
+      const commitsBefore = run("git rev-list --count HEAD", dir);
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      const conflictIssues = fixed.issues.filter(
+        i => i.code === ("conflict_markers_in_tracked_files" as typeof i.code),
+      );
+
+      assert.equal(conflictIssues.length, 1, "detects conflict markers before snapshotting");
+      assert.equal(conflictIssues[0]?.severity, "error", "conflict marker issue blocks automation");
+      assert.equal(conflictIssues[0]?.fixable, false, "conflict marker issue requires manual resolution");
+      assert.ok(
+        fixed.fixesApplied.some(f => f.includes("gsd snapshot skipped")),
+        "fix reports skipped snapshot",
+      );
+
+      const commitsAfter = run("git rev-list --count HEAD", dir);
+      assert.equal(commitsAfter, commitsBefore, "no snapshot commit is created");
+      assert.equal(run("git diff --cached --name-only", dir), "", "no files are staged");
+      assert.match(run("git status --short", dir), /M README\.md/m, "tracked file remains modified");
+    });
+
     // ─── Test: stale_uncommitted_changes NOT flagged when recent commit ──
     test('stale_uncommitted_changes (no false positive on recent commit)', async () => {
       const dir = createRepoWithActiveMilestone();

package/src/resources/extensions/gsd/tests/integration/doctor-proactive.test.ts

@@ -12,7 +12,7 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
+import { execSync, spawnSync } from "node:child_process";
 
 import {
   preDispatchHealthGate,
@@ -68,6 +68,21 @@ _None_
   return dir;
 }
 
+function createStashApplyConflict(): string {
+  const dir = createGitRepo();
+  writeFileSync(join(dir, "README.md"), "# local stashed work\n");
+  run('git stash push -m "local work"', dir);
+  writeFileSync(join(dir, "README.md"), "# merged milestone work\n");
+  run("git add README.md", dir);
+  run('git commit -m "feat: merged readme"', dir);
+  const apply = spawnSync("git", ["stash", "apply", "stash@{0}"], {
+    cwd: dir,
+    encoding: "utf-8",
+  });
+  if (apply.error) throw apply.error;
+  return dir;
+}
+
 describe('doctor-proactive', async () => {
   const cleanups: string[] = [];
 
@@ -287,6 +302,23 @@ describe('doctor-proactive', async () => {
     }
     });
 
+    test('health gate: unresolved stash-apply conflicts block without reset', async () => {
+      const dir = createStashApplyConflict();
+      cleanups.push(dir);
+      assert.equal(existsSync(join(dir, ".git", "MERGE_HEAD")), false, "stash apply conflict should not require MERGE_HEAD");
+
+      const result = await preDispatchHealthGate(dir);
+
+      assert.equal(result.proceed, false, "gate blocks unresolved conflict state");
+      assert.match(result.reason ?? "", /Unresolved Git conflicts/);
+      assert.match(result.reason ?? "", /README\.md/);
+      assert.ok(
+        !result.fixesApplied.some((fix) => fix.includes("cleaned merge state")),
+        "must not reset or auto-heal user conflict files",
+      );
+      assert.match(run("git diff --name-only --diff-filter=U", dir), /README\.md/, "conflict remains for manual resolution");
+    });
+
     test('health gate: STATE.md missing — auto-healed', async () => {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
       cleanups.push(dir);

package/src/resources/extensions/gsd/tests/integration/doctor-runtime.test.ts

@@ -446,6 +446,26 @@ node_modules/
       const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
       assert.deepStrictEqual(strandedIssues.length, 0, "live lock holder: stranded_lock_directory NOT detected");
     });
+
+    test('stranded_lock_directory still reports when worker lookup fails', async () => {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      const lockDir = join(dir, ".gsd.lock");
+      mkdirSync(lockDir, { recursive: true });
+      const { openDatabase, _getAdapter, closeDatabase } = await import("../../gsd-db.ts");
+      openDatabase(join(dir, ".gsd", "gsd.db"));
+      const db = _getAdapter()!;
+      db.exec("DROP TABLE workers");
+
+      try {
+        const detect = await runGSDDoctor(dir);
+        const strandedIssues = detect.issues.filter(i => i.code === "stranded_lock_directory");
+        assert.ok(strandedIssues.length > 0, "reports stranded lock directory even when active worker lookup fails");
+      } finally {
+        closeDatabase();
+      }
+    });
     } else {
     }
 

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -2,10 +2,10 @@
 // File Purpose: Git service integration and commit-message tests.
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 
 import {
   inferCommitType,
@@ -371,6 +371,18 @@ describe('git-service', async () => {
     return dir;
   }
 
+  function gitRun(args: string[], cwd: string): string {
+    return execFileSync("git", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: {
+        ...process.env,
+        GIT_ALLOW_PROTOCOL: "file",
+      },
+    }).trim();
+  }
+
   // ─── GitServiceImpl: smart staging ─────────────────────────────────────
 
   test('GitServiceImpl: smart staging', () => {
@@ -413,6 +425,96 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('GitServiceImpl: task autoCommit skips keyFiles inside submodules', () => {
+    const repo = initTempRepo();
+    const subSrc = mkdtempSync(join(tmpdir(), "gsd-git-submodule-src-"));
+
+    try {
+      gitRun(["init", "-b", "main"], subSrc);
+      gitRun(["config", "user.name", "Pi Test"], subSrc);
+      gitRun(["config", "user.email", "pi@example.com"], subSrc);
+      createFile(subSrc, "tracked.txt", "initial\n");
+      gitRun(["add", "-A"], subSrc);
+      gitRun(["commit", "-m", "init submodule"], subSrc);
+
+      gitRun(["-c", "protocol.file.allow=always", "submodule", "add", `file://${subSrc}`, "sub"], repo);
+      gitRun(["commit", "-m", "add submodule"], repo);
+
+      createFile(repo, "sub/copied.txt", "copied from source\n");
+      createFile(repo, "src/feature.ts", "export const feature = true;\n");
+      createFile(repo, "src/unrelated.ts", "export const unrelated = true;\n");
+
+      const svc = new GitServiceImpl(repo);
+      const taskContext: TaskCommitContext = {
+        taskId: "S01/T01",
+        taskDisplayId: "T01",
+        taskTitle: "fix submodule staging",
+        milestoneId: "M001",
+        milestoneTitle: "Submodule auto commit",
+        sliceId: "S01",
+        sliceTitle: "Commit scoped files",
+        oneLiner: "Fixed auto commit when key files include submodule paths",
+        keyFiles: ["sub/copied.txt", "src/feature.ts"],
+      };
+
+      const result = svc.autoCommit("execute-task", "M001/S01/T01", [], taskContext);
+
+      assert.ok(result !== null, "autoCommit should commit non-submodule changes");
+      const committed = gitRun(["show", "--name-only", "--format=", "HEAD"], repo);
+      assert.ok(committed.includes("src/feature.ts"), "non-submodule keyFile is committed");
+      assert.ok(!committed.includes("sub/copied.txt"), "submodule inner keyFile is not pathspec-staged");
+      assert.ok(!committed.includes("src/unrelated.ts"), "scoped staging does not fall back to smartStage");
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(subSrc, { recursive: true, force: true });
+    }
+  });
+
+  test('GitServiceImpl: all keyFiles inside submodules falls back to smartStage', () => {
+    const repo = initTempRepo();
+    const subSrc = mkdtempSync(join(tmpdir(), "gsd-git-all-submodule-src-"));
+
+    try {
+      gitRun(["init", "-b", "main"], subSrc);
+      gitRun(["config", "user.name", "Pi Test"], subSrc);
+      gitRun(["config", "user.email", "pi@example.com"], subSrc);
+      createFile(subSrc, "tracked.txt", "initial\n");
+      gitRun(["add", "-A"], subSrc);
+      gitRun(["commit", "-m", "init submodule"], subSrc);
+
+      gitRun(["-c", "protocol.file.allow=always", "submodule", "add", `file://${subSrc}`, "sub"], repo);
+      gitRun(["commit", "-m", "add submodule"], repo);
+
+      createFile(repo, "sub/file1.txt", "inside submodule\n");
+      createFile(repo, "sub/file2.txt", "also inside\n");
+      createFile(repo, "src/real.ts", "export const real = true;\n");
+
+      const svc = new GitServiceImpl(repo);
+      const taskContext: TaskCommitContext = {
+        taskId: "S01/T02",
+        taskDisplayId: "T02",
+        taskTitle: "all keyFiles inside submodule",
+        milestoneId: "M001",
+        milestoneTitle: "Submodule auto commit",
+        sliceId: "S01",
+        sliceTitle: "Commit scoped files",
+        oneLiner: "Fell back when all key files are inside submodules",
+        keyFiles: ["sub", "sub/file1.txt", "sub/file2.txt"],
+      };
+
+      const result = svc.autoCommit("execute-task", "M001/S01/T02", [], taskContext);
+
+      assert.ok(result !== null, "autoCommit falls back to smartStage when all keyFiles are filtered");
+      const committed = gitRun(["show", "--name-only", "--format=", "HEAD"], repo);
+      assert.ok(!committed.includes("sub/file1.txt"), "submodule keyFile is not committed");
+      assert.ok(!committed.includes("sub/file2.txt"), "submodule keyFile is not committed");
+      assert.ok(committed.includes("src/real.ts"), "smartStage fallback commits other dirty files");
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(subSrc, { recursive: true, force: true });
+    }
+  });
+
   // ─── GitServiceImpl: smart staging excludes tracked runtime files ──────
 
   test('GitServiceImpl: smart staging excludes tracked runtime files', () => {
@@ -529,6 +631,92 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('GitServiceImpl: autoCommit retries once when pre-commit rewrites files', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    const hookPath = join(repo, ".git", "hooks", "pre-commit");
+    const countFile = join(repo, ".git", "pre-commit-count");
+    writeFileSync(
+      hookPath,
+      [
+        "#!/bin/sh",
+        `count_file="${countFile}"`,
+        "count=0",
+        "[ -f \"$count_file\" ] && count=$(cat \"$count_file\")",
+        "count=$((count + 1))",
+        "echo \"$count\" > \"$count_file\"",
+        "if [ \"$count\" -eq 1 ]; then",
+        "  printf 'export const fixed = true;\\n' > src/fix-me.ts",
+        "  exit 1",
+        "fi",
+        "exit 0",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    chmodSync(hookPath, 0o755);
+
+    createFile(repo, "src/fix-me.ts", "export const fixed = false;\n");
+    const msg = svc.autoCommit("execute-task", "M001/S01/T04");
+
+    assert.ok(msg !== null, "autoCommit succeeds after one retry for hook rewrites");
+    assert.equal(run("git rev-list --count HEAD", repo), "2", "exactly one new commit created");
+    assert.equal(readFileSync(join(repo, "src/fix-me.ts"), "utf-8"), "export const fixed = true;\n"); // allow-source-grep: verifies pre-commit output inside the temp repo fixture, not product source.
+    assert.equal(readFileSync(countFile, "utf-8").trim(), "2", "pre-commit hook ran twice");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test('GitServiceImpl: autoCommit retry preserves task-scoped staging', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    const hookPath = join(repo, ".git", "hooks", "pre-commit");
+    const countFile = join(repo, ".git", "pre-commit-count");
+    writeFileSync(
+      hookPath,
+      [
+        "#!/bin/sh",
+        `count_file="${countFile}"`,
+        "count=0",
+        "[ -f \"$count_file\" ] && count=$(cat \"$count_file\")",
+        "count=$((count + 1))",
+        "echo \"$count\" > \"$count_file\"",
+        "if [ \"$count\" -eq 1 ]; then",
+        "  printf 'export const fixed = true;\\n' > src/task.ts",
+        "  exit 1",
+        "fi",
+        "exit 0",
+        "",
+      ].join("\n"),
+      "utf-8",
+    );
+    chmodSync(hookPath, 0o755);
+
+    createFile(repo, "src/task.ts", "export const fixed = false;\n");
+    createFile(repo, "src/unrelated.ts", "export const unrelated = true;\n");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T05", [], {
+      taskId: "S01/T05",
+      taskTitle: "update task file",
+      oneLiner: "Updated task file after hook rewrite",
+      keyFiles: ["src/task.ts"],
+    });
+
+    assert.ok(msg !== null, "autoCommit succeeds after retry with task-scoped staging");
+    assert.equal(readFileSync(countFile, "utf-8").trim(), "2", "pre-commit hook ran twice");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(committed.includes("src/task.ts"), "task file is committed after retry");
+    assert.ok(!committed.includes("src/unrelated.ts"), "retry does not widen staging to unrelated dirty files");
+
+    const status = run("git status --porcelain", repo);
+    assert.ok(status.includes("src/unrelated.ts"), "unrelated dirty file remains in working tree");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   test('GitServiceImpl: task context keyFiles scope autoCommit staging', () => {
     const repo = initTempRepo();
     const svc = new GitServiceImpl(repo);
@@ -608,6 +796,33 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  // Regression: #5529. Some executors emit keyFiles relative to a monorepo
+  // subproject root (e.g. `src/...`) instead of the repo root
+  // (`frontend/src/...`). When none of those keyFiles exist at repo root,
+  // scoped staging must fall back to smartStage instead of failing the turn.
+  test('GitServiceImpl: repo-relative keyFiles mismatch falls back to smartStage', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, "frontend/src/lib/onboarding-contract.ts", "export const contract = true;");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T04", [], {
+      taskId: "S01/T04",
+      taskTitle: "fix scoped keyFiles path handling",
+      oneLiner: "Handled repo-relative keyFiles mismatch",
+      keyFiles: ["src/lib/onboarding-contract.ts"],
+    });
+    assert.ok(msg !== null, "autoCommit falls back to smartStage when scoped keyFiles are invalid at repo root");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(
+      committed.includes("frontend/src/lib/onboarding-contract.ts"),
+      "smartStage fallback stages real dirty files when keyFiles are scoped to a subproject root",
+    );
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   test('GitServiceImpl: task context keyFiles ignores gitignored build outputs', () => {
     const repo = initTempRepo();
     const svc = new GitServiceImpl(repo);
@@ -1066,6 +1281,15 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('Integration branch: rejects milestone branches', () => {
+    const repo = initBranchTestRepo();
+
+    writeIntegrationBranch(repo, "M001", "milestone/M001");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null, "milestone branches are not recorded as integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── writeIntegrationBranch: still records legitimate branches ────────
 
   test('Integration branch: records non-ephemeral gsd branches', () => {

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

@@ -17,10 +17,12 @@ import { migrateFromMarkdown, parseDecisionsTable } from '../../md-importer.ts';
 import {
   queryDecisions,
   queryRequirements,
+  getAllDecisionsFromMemories,
   formatDecisionsForPrompt,
   formatRequirementsForPrompt,
 } from '../../context-store.ts';
 import { saveDecisionToDb, generateDecisionsMd } from '../../db-writer.ts';
+import { backfillDecisionsToMemories } from '../../memory-backfill.ts';
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -233,8 +235,8 @@ test('integration-lifecycle: full pipeline', async () => {
       assert.ok(typeof saved.id === 'string', 'lifecycle: saveDecisionToDb returned an id');
       assert.match(saved.id, /^D\d+$/, 'lifecycle: saved ID matches D### pattern');
 
-      // Query back from DB
-      const allAfterSave = queryDecisions();
+      // Query back from DB (memories — Stage 3 of ADR-013 stopped legacy decisions-table writes)
+      const allAfterSave = getAllDecisionsFromMemories();
       const savedDecision = allAfterSave.find(d => d.id === saved.id);
       assert.ok(savedDecision !== null && savedDecision !== undefined, `lifecycle: saved decision ${saved.id} found in DB`);
       assert.deepStrictEqual(savedDecision?.decision, 'integration test write-back decision', 'lifecycle: saved decision text matches');
@@ -253,9 +255,15 @@ test('integration-lifecycle: full pipeline', async () => {
       assert.deepStrictEqual(reparsedSaved?.rationale, 'proves round-trip fidelity', 'lifecycle: round-trip rationale preserved');
 
       // ── Step 8: DB consistency — total count sanity ─────────────────────
-      const finalCount = queryDecisions().length;
-      // Original 14 + 1 re-import + 1 saveDecisionToDb = 16
-      assert.ok(finalCount === DECISIONS_COUNT + 2, `lifecycle: final DB count = ${DECISIONS_COUNT + 2} (got ${finalCount})`);
+      // ADR-013 Stage 3 split the write paths: migrateFromMarkdown still
+      // populates the legacy decisions table, but saveDecisionToDb now writes
+      // only to memories. The unified projection (and the post-#5756 cutover
+      // end-state) lives in memories, so simulate what bootstrap does and
+      // backfill the table rows into memories before counting.
+      backfillDecisionsToMemories();
+      const finalCount = getAllDecisionsFromMemories().length;
+      // Original 14 + 1 re-import (decisions table → memories via backfill) + 1 saveDecisionToDb = 16
+      assert.ok(finalCount === DECISIONS_COUNT + 2, `lifecycle: final memory-store count = ${DECISIONS_COUNT + 2} (got ${finalCount})`);
 
       closeDatabase();
     } finally {

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/integration/state-machine-edge-cases.test.ts

@@ -883,7 +883,7 @@ describe("dispatch failure modes", () => {
     assert.ok(runUatIdx < uatGateIdx, "run-uat should precede uat-verdict-gate");
   });
 
-  test("UAT verdict gate: ASSESSMENT FAIL blocks closed slice progression", async () => {
+  test("UAT verdict gate: ASSESSMENT FAIL does not hard-stop progression", async () => {
     base = createFullFixture();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Active", status: "active" });
@@ -908,11 +908,7 @@ describe("dispatch failure modes", () => {
     ctx.prefs = { uat_dispatch: true } as any;
 
     const result = await getUatVerdictGate().match(ctx);
-    assert.equal(result?.action, "stop", "ASSESSMENT FAIL should block progression");
-    assert.ok(
-      (result as any).reason?.includes('UAT verdict for S01 is "fail"'),
-      "stop reason should report normalized ASSESSMENT verdict",
-    );
+    assert.equal(result, null, "ASSESSMENT FAIL should not hard-stop progression");
   });
 
   test("UAT verdict gate: ROADMAP fallback gates done slices when DB is unavailable", async () => {
@@ -964,15 +960,11 @@ describe("dispatch failure modes", () => {
     ctx.prefs = { uat_dispatch: true } as any;
 
     const result = await getUatVerdictGate().match(ctx);
-    assert.equal(result?.action, "stop", "ROADMAP done slices should be gated without DB");
-    assert.ok(
-      (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
-      "stop reason should report normalized ASSESSMENT verdict from disk fallback",
-    );
+    assert.equal(result, null, "ROADMAP done slices should not hard-stop progression without DB");
   });
 
   for (const status of ["done", "skipped"]) {
-    test(`UAT verdict gate: legacy closed status "${status}" is gated`, async () => {
+    test(`UAT verdict gate: legacy closed status "${status}" does not hard-stop progression`, async () => {
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
@@ -997,15 +989,7 @@ describe("dispatch failure modes", () => {
       ctx.prefs = { uat_dispatch: true } as any;
 
       const result = await getUatVerdictGate().match(ctx);
-      assert.equal(
-        result?.action,
-        "stop",
-        `${status} slices should be treated as closed for UAT verdict gating`,
-      );
-      assert.ok(
-        (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
-        "stop reason should report normalized ASSESSMENT verdict",
-      );
+      assert.equal(result, null, `${status} slices should not hard-stop progression`);
     });
   }
 });