gsd-pi 2.71.0-dev.e17e0ce → 2.72.0-dev.3118184

package/src/resources/extensions/gsd/tests/preferences-formatting.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Tests for formatSkillRef — pure formatting logic for skill references
+ * in the system prompt. Moved from preferences-skills.ts to preferences-types.ts
+ * to break the preferences ↔ preferences-skills circular dependency.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { formatSkillRef } from "../preferences-types.ts";
+import type { SkillResolution } from "../preferences-types.ts";
+
+function makeResolutions(entries: [string, Partial<SkillResolution>][]): Map<string, SkillResolution> {
+  const map = new Map<string, SkillResolution>();
+  for (const [key, partial] of entries) {
+    map.set(key, {
+      original: partial.original ?? key,
+      resolvedPath: partial.resolvedPath ?? null,
+      method: partial.method ?? "unresolved",
+    });
+  }
+  return map;
+}
+
+describe("formatSkillRef", () => {
+  test("marks unresolved references with a warning", () => {
+    const resolutions = makeResolutions([
+      ["my-skill", { method: "unresolved" }],
+    ]);
+    const result = formatSkillRef("my-skill", resolutions);
+    assert.match(result, /my-skill/);
+    assert.match(result, /not found/);
+  });
+
+  test("marks unknown references (not in map) with a warning", () => {
+    const resolutions = new Map<string, SkillResolution>();
+    const result = formatSkillRef("unknown-skill", resolutions);
+    assert.match(result, /unknown-skill/);
+    assert.match(result, /not found/);
+  });
+
+  test("returns bare ref for absolute-path resolution", () => {
+    const resolutions = makeResolutions([
+      ["/home/user/skills/SKILL.md", {
+        method: "absolute-path",
+        resolvedPath: "/home/user/skills/SKILL.md",
+      }],
+    ]);
+    const result = formatSkillRef("/home/user/skills/SKILL.md", resolutions);
+    assert.equal(result, "/home/user/skills/SKILL.md");
+  });
+
+  test("returns bare ref for absolute-dir resolution", () => {
+    const resolutions = makeResolutions([
+      ["/home/user/skills/my-skill", {
+        method: "absolute-dir",
+        resolvedPath: "/home/user/skills/my-skill/SKILL.md",
+      }],
+    ]);
+    const result = formatSkillRef("/home/user/skills/my-skill", resolutions);
+    assert.equal(result, "/home/user/skills/my-skill");
+  });
+
+  test("shows resolved path for user-skill resolution", () => {
+    const resolutions = makeResolutions([
+      ["code-review", {
+        method: "user-skill",
+        resolvedPath: "/home/user/.claude/skills/code-review/SKILL.md",
+      }],
+    ]);
+    const result = formatSkillRef("code-review", resolutions);
+    assert.match(result, /code-review/);
+    assert.match(result, /\.claude\/skills\/code-review\/SKILL\.md/);
+  });
+
+  test("shows resolved path for project-skill resolution", () => {
+    const resolutions = makeResolutions([
+      ["lint-fix", {
+        method: "project-skill",
+        resolvedPath: "/repo/.gsd/skills/lint-fix/SKILL.md",
+      }],
+    ]);
+    const result = formatSkillRef("lint-fix", resolutions);
+    assert.match(result, /lint-fix/);
+    assert.match(result, /\.gsd\/skills\/lint-fix\/SKILL\.md/);
+  });
+});

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -10,10 +10,14 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
   validatePreferences,
   applyModeDefaults,
   getIsolationMode,
+  loadEffectiveGSDPreferences,
   parsePreferencesMarkdown,
   _resetParseWarningFlag,
 } from "../preferences.ts";
@@ -501,6 +505,55 @@ test("experimental.rtk parses correctly from preferences markdown", () => {
   assert.equal(prefs!.experimental?.rtk, true);
 });
 
+test("loadEffectiveGSDPreferences preserves experimental prefs across global+project merge", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempGsdHome, "preferences.md"),
+      [
+        "---",
+        "version: 1",
+        "experimental:",
+        "  rtk: true",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "git:",
+        "  isolation: none",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.experimental?.rtk, true);
+    assert.equal(loaded!.preferences.git?.isolation, "none");
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("experimental.rtk defaults to off in new project preferences", () => {
   // No experimental key → feature is disabled
   const content = "---\nversion: 1\n---\n";

package/src/resources/extensions/gsd/tests/projection-regression.test.ts

@@ -5,7 +5,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 
-import { renderPlanContent, renderRoadmapContent } from '../workflow-projections.ts';
+import { renderPlanContent, renderRoadmapContent, renderSummaryContent } from '../workflow-projections.ts';
 import type { SliceRow, TaskRow } from '../gsd-db.ts';
 
 // ─── Helpers ─────────────────────────────────────────────────────────────
@@ -172,3 +172,98 @@ test('renderRoadmapContent: slice with status "pending" shows ⬜', () => {
 
   assert.ok(content.includes('⬜'), 'pending slice should show ⬜');
 });
+
+// ─── renderSummaryContent: double-frontmatter regression ─────────────────
+
+test('renderSummaryContent: uses full_summary_md as-is when it contains frontmatter', () => {
+  const existingSummary = [
+    '---',
+    'id: T01',
+    'parent: S01',
+    'milestone: M001',
+    'key_files:',
+    '  - src/thing.ts',
+    'verification_result: passed',
+    'completed_at: 2026-01-01T00:00:00Z',
+    'blocker_discovered: false',
+    '---',
+    '',
+    '# T01: Did the thing',
+    '',
+    '**One-liner summary**',
+    '',
+    '## What Happened',
+    '',
+    'Narrative content here.',
+    '',
+    '## Deviations',
+    '',
+    'None.',
+    '',
+  ].join('\n');
+
+  const task = makeTaskRow({
+    id: 'T01',
+    status: 'complete',
+    title: 'Did the thing',
+    one_liner: 'One-liner summary',
+    narrative: 'Narrative content here.',
+    full_summary_md: existingSummary,
+  });
+
+  const result = renderSummaryContent(task, 'S01', 'M001');
+
+  // Must NOT produce double frontmatter
+  const frontmatterCount = (result.match(/^---$/gm) || []).length;
+  assert.equal(frontmatterCount, 2, `Expected exactly 2 frontmatter delimiters (one block), got ${frontmatterCount}`);
+
+  // Must NOT produce double H1 heading
+  const h1Count = (result.match(/^# T01:/gm) || []).length;
+  assert.equal(h1Count, 1, `Expected exactly 1 H1 heading, got ${h1Count}`);
+
+  // Content should match the full_summary_md exactly
+  assert.equal(result, existingSummary);
+});
+
+test('renderSummaryContent: synthesizes from DB columns when full_summary_md is empty', () => {
+  const task = makeTaskRow({
+    id: 'T01',
+    status: 'complete',
+    title: 'Did the thing',
+    one_liner: 'One-liner summary',
+    narrative: 'Built the feature.',
+    full_summary_md: '',
+    deviations: 'Deviated slightly.',
+    known_issues: 'None.',
+  });
+
+  const result = renderSummaryContent(task, 'S01', 'M001');
+
+  // Should have exactly one frontmatter block
+  const frontmatterCount = (result.match(/^---$/gm) || []).length;
+  assert.equal(frontmatterCount, 2, 'Should have one frontmatter block (2 delimiters)');
+
+  // Should contain synthesized sections
+  assert.ok(result.includes('## What Happened'), 'Should have What Happened section');
+  assert.ok(result.includes('Built the feature.'), 'Should use narrative for content');
+  assert.ok(result.includes('## Deviations'), 'Should have Deviations section');
+  assert.ok(result.includes('Deviated slightly.'), 'Should include deviation text');
+});
+
+test('renderSummaryContent: synthesizes when full_summary_md has no frontmatter', () => {
+  const task = makeTaskRow({
+    id: 'T02',
+    status: 'complete',
+    title: 'Partial summary',
+    narrative: 'Did some work.',
+    full_summary_md: 'Just a plain text summary with no frontmatter.',
+  });
+
+  const result = renderSummaryContent(task, 'S01', 'M001');
+
+  // Should synthesize with proper frontmatter since the stored md lacks it
+  assert.ok(result.startsWith('---'), 'Should start with frontmatter');
+  assert.ok(result.includes('id: T02'), 'Should have task ID in frontmatter');
+  assert.ok(result.includes('## What Happened'), 'Should have What Happened section');
+  assert.ok(result.includes('Did some work.'), 'Should use narrative');
+});

package/src/resources/extensions/gsd/tests/prompt-loader-working-directory.test.ts

@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { loadPrompt } from "../prompt-loader.ts";
+
+test("loadPrompt normalizes workingDirectory backslashes for bash-friendly prompts (#4048)", () => {
+  const prompt = loadPrompt("research-milestone", {
+    milestoneId: "M001",
+    milestoneTitle: "Windows path fix",
+    workingDirectory: "C:\\Dev\\NB\\TR",
+    inlinedContext: "context",
+    skillActivation: "skill activation",
+    skillDiscoveryMode: "off",
+    skillDiscoveryInstructions: " disabled",
+  });
+
+  assert.match(prompt, /Your working directory is `C:\/Dev\/NB\/TR`/);
+  assert.doesNotMatch(prompt, /C:\\Dev\\NB\\TR/);
+});

package/src/resources/extensions/gsd/tests/prompt-system-gate-coverage.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Prompt-system gate coverage tests.
+ *
+ * These tests pin the invariants the plan file documents:
+ *   1. Every pending slice-scoped gate is routed to exactly one owner turn.
+ *      Q8 (owned by complete-slice) MUST NOT leak into gate-evaluate and
+ *      get silently dropped the way it used to before the registry landed.
+ *   2. getPendingGatesForTurn filters by the registry's owner turn, not
+ *      just the DB scope column.
+ *   3. Output validators recognize artifacts that contain the required
+ *      gate section headings, and flag ones that don't.
+ *   4. Prompt output produced by the validators reflects MV01-MV04.
+ *
+ * They also assert the VALIDATION.md renderer still produces headings
+ * matching the registry's promptSection strings, so future renderer
+ * edits that drift from the registry fail the suite loudly.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  insertGateRow,
+  getPendingGates,
+  getPendingGatesForTurn,
+} from "../gsd-db.ts";
+import {
+  GATE_REGISTRY,
+  getGatesForTurn,
+  type OwnerTurn,
+} from "../gate-registry.ts";
+import {
+  validateSliceSummaryOutput,
+  validateTaskSummaryOutput,
+  validateMilestoneValidationOutput,
+  validateGateSections,
+} from "../prompt-validation.ts";
+
+function setupTestDb(): string {
+  const tmpDir = mkdtempSync(join(tmpdir(), "prompt-gate-coverage-"));
+  const dbPath = join(tmpDir, "gsd.db");
+  openDatabase(dbPath);
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({
+    milestoneId: "M001",
+    id: "S01",
+    title: "Test Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Test Task",
+    status: "pending",
+  });
+  return tmpDir;
+}
+
+describe("getPendingGatesForTurn routes by owner turn, not scope column", () => {
+  let tmpDir: string;
+  beforeEach(() => {
+    tmpDir = setupTestDb();
+  });
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("Q8 stored as scope:'slice' is owned by complete-slice, not gate-evaluate", () => {
+    // Seed the three slice-scoped gates plan-slice writes today.
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q8", scope: "slice" });
+
+    // getPendingGates(..., "slice") returns all three (unchanged).
+    const allSlicePending = getPendingGates("M001", "S01", "slice");
+    assert.equal(allSlicePending.length, 3);
+
+    // But the turn-aware helper routes them correctly.
+    const gateEval = getPendingGatesForTurn("M001", "S01", "gate-evaluate");
+    assert.deepEqual(gateEval.map((g) => g.gate_id).sort(), ["Q3", "Q4"]);
+
+    const completeSlice = getPendingGatesForTurn("M001", "S01", "complete-slice");
+    assert.deepEqual(completeSlice.map((g) => g.gate_id), ["Q8"]);
+  });
+
+  test("task-scoped gates are scoped to the requested task id", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T01" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q6", scope: "task", taskId: "T01" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q5", scope: "task", taskId: "T02" });
+
+    const t1 = getPendingGatesForTurn("M001", "S01", "execute-task", "T01");
+    assert.equal(t1.length, 2);
+    assert.ok(t1.every((g) => g.gate_id === "Q5" || g.gate_id === "Q6"));
+
+    const t2 = getPendingGatesForTurn("M001", "S01", "execute-task", "T02");
+    assert.equal(t2.length, 1);
+    assert.equal(t2[0].gate_id, "Q5");
+  });
+});
+
+describe("per-turn output validators", () => {
+  test("validateSliceSummaryOutput flags missing Operational Readiness", () => {
+    const md = `# S01: Test Slice\n\n## What Happened\nstuff\n\n## Verification\nstuff\n`;
+    const result = validateSliceSummaryOutput(md);
+    assert.equal(result.valid, false);
+    assert.ok(result.missing.some((m) => m.includes("Q8")));
+    assert.ok(result.missing.some((m) => m.includes("Operational Readiness")));
+  });
+
+  test("validateSliceSummaryOutput passes when Operational Readiness heading is present", () => {
+    const md = `# S01\n\n## Operational Readiness\n- Health: /health\n- Failure: alert\n`;
+    const result = validateSliceSummaryOutput(md);
+    assert.equal(result.valid, true);
+    assert.equal(result.missing.length, 0);
+  });
+
+  test("validateMilestoneValidationOutput requires all four MV headings", () => {
+    // Missing Requirement Coverage.
+    const md = [
+      "# Milestone Validation: M001",
+      "## Success Criteria Checklist",
+      "ok",
+      "## Slice Delivery Audit",
+      "ok",
+      "## Cross-Slice Integration",
+      "ok",
+    ].join("\n\n");
+    const result = validateMilestoneValidationOutput(md);
+    assert.equal(result.valid, false);
+    assert.ok(result.missing.some((m) => m.includes("MV04")));
+  });
+
+  test("validateMilestoneValidationOutput passes for a complete VALIDATION.md", () => {
+    const md = [
+      "# Milestone Validation: M001",
+      "## Success Criteria Checklist",
+      "ok",
+      "## Slice Delivery Audit",
+      "ok",
+      "## Cross-Slice Integration",
+      "ok",
+      "## Requirement Coverage",
+      "ok",
+    ].join("\n\n");
+    const result = validateMilestoneValidationOutput(md);
+    assert.equal(result.valid, true, `unexpected missing: ${result.missing.join(", ")}`);
+  });
+
+  test("validateTaskSummaryOutput flags missing task-gate sections", () => {
+    const md = `# T01\n\n## What Happened\nstuff\n\n## Verification\nstuff\n`;
+    const result = validateTaskSummaryOutput(md);
+    assert.equal(result.valid, false);
+    const idsInMissing = result.missing.join(" ");
+    assert.ok(idsInMissing.includes("Q5"));
+    assert.ok(idsInMissing.includes("Q6"));
+    assert.ok(idsInMissing.includes("Q7"));
+  });
+
+  test("validateGateSections returns empty missing when gate bucket is empty", () => {
+    // Build a phoney owner turn that owns nothing (simulate by validating
+    // against a real turn against an artifact containing every section).
+    const fullMd = getGatesForTurn("validate-milestone")
+      .map((g) => `## ${g.promptSection}\n\nstuff`)
+      .join("\n\n");
+    const result = validateGateSections(fullMd, "validate-milestone");
+    assert.equal(result.valid, true);
+  });
+});
+
+describe("registry / renderer parity", () => {
+  test("MV promptSections match the validate-milestone renderer H2 headings", () => {
+    // Mirror the string literals from tools/validate-milestone.ts
+    // renderValidationMarkdown() so a rename there flips this test red.
+    const expectedHeadings = [
+      "Success Criteria Checklist",
+      "Slice Delivery Audit",
+      "Cross-Slice Integration",
+      "Requirement Coverage",
+    ];
+    const registryHeadings = getGatesForTurn("validate-milestone").map((g) => g.promptSection);
+    assert.deepEqual(registryHeadings.sort(), [...expectedHeadings].sort());
+  });
+
+  test("Q8 promptSection matches the complete-slice renderer H2 heading", () => {
+    // Mirror the slice-summary H2 introduced in tools/complete-slice.ts.
+    assert.equal(GATE_REGISTRY.Q8.promptSection, "Operational Readiness");
+  });
+
+  test("registry owner turns cover every turn gate-registry.ts declares", () => {
+    const ownerTurns = new Set<OwnerTurn>(Object.values(GATE_REGISTRY).map((g) => g.ownerTurn));
+    assert.ok(ownerTurns.has("gate-evaluate"));
+    assert.ok(ownerTurns.has("execute-task"));
+    assert.ok(ownerTurns.has("complete-slice"));
+    assert.ok(ownerTurns.has("validate-milestone"));
+  });
+});

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -32,6 +32,15 @@ test("classifyError detects rate limit from message", () => {
   assert.equal(result.kind, "rate-limit");
 });
 
+test("classifyError treats OpenRouter affordability errors as transient rate-limit class", () => {
+  const result = classifyError(
+    "402 This request requires more credits, or fewer max_tokens. You requested up to 32000 tokens, but can only afford 329.",
+  );
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0);
+});
+
 test("classifyError extracts reset delay from message", () => {
   const result = classifyError("rate limit exceeded, reset in 45s");
   assert.equal(result.kind, "rate-limit");

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -0,0 +1,97 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  getPendingGate,
+  resetWriteGateState,
+  shouldBlockContextArtifactSave,
+} from "../bootstrap/write-gate.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-depth-gate-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+test("register-hooks unlocks milestone depth verification from question id without guided-flow state (#4047)", async (t) => {
+  const dir = makeTempDir("manual");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<void> | void) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi);
+
+  const questionId = "depth_verification_M001_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Do you agree?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  const toolCallHandlers = handlers.get("tool_call");
+  const toolResultHandlers = handlers.get("tool_result");
+  assert.ok(toolCallHandlers?.length, "tool_call handler should be registered");
+  assert.ok(toolResultHandlers?.length, "tool_result handler should be registered");
+
+  for (const handler of toolCallHandlers ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+    });
+  }
+
+  assert.equal(getPendingGate(), questionId, "gate should be set even without guided-flow state");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M001").block,
+    true,
+    "milestone context should still be blocked before confirmation",
+  );
+
+  for (const handler of toolResultHandlers ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: {
+        response: {
+          answers: {
+            [questionId]: { selected: "Yes, you got it (Recommended)" },
+          },
+        },
+      },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "confirming the depth question should clear the pending gate");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M001").block,
+    false,
+    "question-id milestone inference should unlock the matching milestone context write",
+  );
+});

package/src/resources/extensions/gsd/tests/register-shortcuts.test.ts

@@ -69,14 +69,15 @@ test("dashboard shortcut resolves the project root instead of the current worktr
 
   assert.ok(customCalls > 0, "shortcut opens the dashboard overlay when project root is resolved");
   assert.equal(notices.length, 0, "shortcut does not fall back to the missing-.gsd warning");
-  assert.equal(shortcuts.length, 6, "all GSD shortcuts are still registered");
+  assert.equal(shortcuts.length, 5, "all GSD shortcuts are still registered");
   const keys = shortcuts.map((shortcut) => shortcut.key);
   assert.ok(keys.includes("ctrl+alt+g"), "primary dashboard shortcut is registered");
   assert.ok(keys.includes("ctrl+shift+g"), "fallback dashboard shortcut is registered");
   assert.ok(keys.includes("ctrl+alt+n"), "primary notifications shortcut is registered");
   assert.ok(keys.includes("ctrl+shift+n"), "fallback notifications shortcut is registered");
   assert.ok(keys.includes("ctrl+alt+p"), "primary parallel shortcut is registered");
-  assert.ok(keys.includes("ctrl+shift+p"), "fallback parallel shortcut is registered");
+  // No Ctrl+Shift+P fallback — conflicts with cycleModelBackward (shift+ctrl+p)
+  assert.ok(!keys.includes("ctrl+shift+p"), "parallel fallback must not be registered (conflicts with cycleModelBackward)");
 });
 
 test("parallel shortcut passes resolved project root into overlay", async (t) => {

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

@@ -0,0 +1,41 @@
+/**
+ * stale-slice-rows.test.ts — #3658
+ *
+ * Verify that state.ts contains slice-level status reconciliation that
+ * updates stale DB rows (status "pending") when disk artifacts (SUMMARY)
+ * prove the slice is complete. Without this, the dependency resolver builds
+ * doneSliceIds from stale DB rows and downstream slices stay blocked.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const sourceFile = join(__dirname, "..", "state.ts");
+
+describe("stale slice row reconciliation (#3658)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("imports updateSliceStatus from gsd-db", () => {
+    assert.match(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
+  });
+
+  test("checks isStatusDone before reconciling slice rows", () => {
+    assert.match(source, /isStatusDone\(dbSlice\.status\)/);
+  });
+
+  test("resolves SUMMARY file to detect completed slices on disk", () => {
+    assert.match(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
+  });
+
+  test("calls updateSliceStatus to reconcile stale rows", () => {
+    assert.match(source, /updateSliceStatus\(mid,\s*dbSlice\.id,\s*["']complete["']\)/);
+  });
+
+  test("references issue #3599 in reconciliation comment", () => {
+    assert.match(source, /#3599/);
+  });
+});