@opengsd/gsd-pi 1.2.0-dev.84c56d87 → 1.2.0-dev.8e6112e9

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

@@ -3,22 +3,24 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { openDatabase, insertAssessment, insertMilestone, insertSlice, closeDatabase } from "../gsd-db.js";
 import {
   isMilestoneCloseoutSettled,
   evaluateCompleteMilestoneDispatch,
+  isCompletedMilestoneTerminal,
+  repairMissingMilestoneSummaryProjection,
 } from "../milestone-closeout.js";
 import type { DispatchContext } from "../auto-dispatch.js";
 
 /** Build a minimal DispatchContext for the dispatch-policy branches under test. */
-function makeDispatchCtx(base: string, phase: string): DispatchContext {
+function makeDispatchCtx(base: string, phase: string, mid = "M001"): DispatchContext {
   return {
     basePath: base,
-    mid: "M001",
-    midTitle: "M001: Test",
+    mid,
+    midTitle: `${mid}: Test`,
     state: { phase } as DispatchContext["state"],
     prefs: undefined,
   } as DispatchContext;
@@ -119,3 +121,92 @@ test("evaluateCompleteMilestoneDispatch skips when milestone is already closed",
   assert.ok(action, "an already-closed milestone in completing-milestone should yield an action");
   assert.equal(action!.action, "skip", "already-closed milestone should resolve to skip (idempotent)");
 });
+
+test("isCompletedMilestoneTerminal accepts DB complete without SUMMARY artifact", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-terminal-db-complete-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M008", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M008", title: "Slice", status: "complete" });
+
+  assert.equal(await isCompletedMilestoneTerminal(base, "M008"), true);
+});
+
+test("isCompletedMilestoneTerminal accepts validation-pass with all slices closed", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-terminal-validation-pass-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M008", title: "Active", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M008", title: "Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M008/M008-VALIDATION.md",
+    milestoneId: "M008",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+
+  assert.equal(await isCompletedMilestoneTerminal(base, "M008"), true);
+});
+
+test("evaluateCompleteMilestoneDispatch repairs missing SUMMARY when DB is closed", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-dispatch-repair-summary-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd", "milestones", "M008"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M008", title: "Live Text Search", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M008", title: "Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M008/M008-VALIDATION.md",
+    milestoneId: "M008",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+
+  const action = await evaluateCompleteMilestoneDispatch(
+    makeDispatchCtx(base, "completing-milestone", "M008"),
+  );
+  assert.equal(action?.action, "skip");
+  assert.ok(
+    existsSync(join(base, ".gsd", "milestones", "M008", "M008-SUMMARY.md")),
+    "repair should write the missing milestone SUMMARY projection",
+  );
+});
+
+test("repairMissingMilestoneSummaryProjection succeeds when milestone dir does not exist yet", async () => {
+  // Regression: resolveExpectedArtifactPath returns null before the milestone
+  // directory exists. The post-write success check must use the handler's
+  // returned summaryPath (the absolute path it just created), not the
+  // pre-write resolver result, otherwise repair always reports failure and
+  // dispatch falls back to re-dispatching complete-milestone.
+  const base = mkdtempSync(join(tmpdir(), "gsd-repair-summary-new-dir-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M042", title: "Done", status: "complete" });
+
+  const repair = await repairMissingMilestoneSummaryProjection(base, "M042");
+  assert.equal(repair.ok, true, "repair should report success when handler creates the SUMMARY");
+  assert.ok(
+    existsSync(join(base, ".gsd", "milestones", "M042", "M042-SUMMARY.md")),
+    "repair should write the SUMMARY artifact to the canonical projection path",
+  );
+});
+
+test("repairMissingMilestoneSummaryProjection is idempotent when SUMMARY exists", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repair-summary-idempotent-"));
+  tmpDirs.push(base);
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  const summaryPath = join(milestoneDir, "M001-SUMMARY.md");
+  writeFileSync(summaryPath, "# Existing summary\n");
+
+  const repair = await repairMissingMilestoneSummaryProjection(base, "M001");
+  assert.equal(repair.ok, true);
+  assert.equal(readFileSync(summaryPath, "utf-8"), "# Existing summary\n");
+});

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

@@ -4,7 +4,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { _runMilestoneMergeWithStashRestore } from "../auto/phases.js";
+import { _runMilestoneMergeWithStashRestore } from "../auto/closeout.js";
 import type { IterationContext } from "../auto/types.js";
 import { MergeConflictError } from "../git-service.js";
 import type {

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

@@ -10,7 +10,7 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { _resolveDispatchGuardBasePath, _resolveReportBasePath } from "../auto/phases.ts";
+import { _resolveDispatchGuardBasePath, _resolveReportBasePath } from "../auto/phase-helpers.ts";
 
 describe("_resolveReportBasePath", () => {
   test("uses originalBasePath when set (worktree scenario)", () => {

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

@@ -0,0 +1,92 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for milestone closeout settlement guidance.
+
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { evaluateAllCompleteSettlement } from "../milestone-settlement.ts";
+import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+
+let base = "";
+
+function runGit(cwd: string, args: string[]): void {
+  execFileSync("git", args, { cwd, stdio: "ignore" });
+}
+
+function initRepo(root: string): void {
+  runGit(root, ["init", "-b", "main"]);
+  runGit(root, ["config", "user.email", "test@example.com"]);
+  runGit(root, ["config", "user.name", "Test User"]);
+  writeFileSync(join(root, "README.md"), "# fixture\n");
+  runGit(root, ["add", "."]);
+  runGit(root, ["commit", "-m", "chore: init"]);
+}
+
+function seedClosedMilestone(root: string, worktree: string): void {
+  mkdirSync(join(root, ".gsd"), { recursive: true });
+  openDatabase(join(root, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice One", status: "complete" });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task One",
+    status: "complete",
+    verificationResult: "passed",
+  });
+  insertAssessment({
+    path: ".gsd/milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass\n",
+  });
+
+  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  const summaryPath = resolveExpectedArtifactPath("complete-milestone", "M001", worktree);
+  assert.ok(summaryPath, "complete-milestone summary path should resolve");
+  mkdirSync(dirname(summaryPath), { recursive: true });
+  writeFileSync(summaryPath, "# Milestone One\n\nComplete.\n");
+}
+
+afterEach(() => {
+  try { closeDatabase(); } catch { /* ignore */ }
+  if (base) rmSync(base, { recursive: true, force: true });
+  base = "";
+});
+
+test("merge-pending settlement routes back to complete-milestone dispatch without manual merge guidance", () => {
+  base = mkdtempSync(join(tmpdir(), "gsd-milestone-settlement-"));
+  initRepo(base);
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(dirname(worktree), { recursive: true });
+  runGit(base, ["worktree", "add", "-b", "milestone/M001", worktree, "HEAD"]);
+  seedClosedMilestone(base, worktree);
+
+  const result = evaluateAllCompleteSettlement({
+    milestoneId: "M001",
+    statePhase: "complete",
+    basePath: worktree,
+    originalBasePath: base,
+    milestoneMerged: false,
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.reason, "merge-pending");
+  assert.equal(result.nextAction, "Retry `/gsd dispatch complete-milestone M001`.");
+  assert.doesNotMatch(result.message, /merge manually/i);
+  assert.doesNotMatch(result.nextAction, /merge manually/i);
+});

package/src/resources/extensions/gsd/tests/milestone-transition-state-rebuild.test.ts

@@ -14,7 +14,7 @@ import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { AutoSession } from "../auto/session.ts";
-import { runPreDispatch } from "../auto/phases.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
 
 test("milestone transition archives completed units and rebuilds state", async () => {
   const tempDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-cu-reset-")));

package/src/resources/extensions/gsd/tests/model-unittype-mapping.test.ts

@@ -14,7 +14,7 @@ import { tmpdir } from "node:os";
 import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
 import { unitPhaseLabel, unitVerb } from "../auto-dashboard.ts";
 import { classifyUnitPhase } from "../metrics.ts";
-import { resolveModelWithFallbacksForUnit } from "../preferences-models.ts";
+import { resolveDefaultSessionModel, resolveModelWithFallbacksForUnit } from "../preferences-models.ts";
 import { KNOWN_UNIT_LABELS } from "../preferences-types.ts";
 
 function withModelPreferences<T>(fn: () => T): T {
@@ -92,6 +92,37 @@ test("run-uat falls back to completion when uat bucket is not configured", () =>
   }
 });
 
+test("default session model resolves from the explicit project base path", () => {
+  const oldHome = process.env.GSD_HOME;
+  const originalCwd = process.cwd();
+  const home = mkdtempSync(join(tmpdir(), "gsd-model-map-home-"));
+  const base = mkdtempSync(join(tmpdir(), "gsd-model-map-project-"));
+
+  try {
+    process.env.GSD_HOME = home;
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "PREFERENCES.md"), [
+      "---",
+      "models:",
+      "  execution: gpt-5.5",
+      "---",
+      "",
+    ].join("\n"));
+    process.chdir(home);
+
+    assert.deepEqual(resolveDefaultSessionModel("openai-codex", base), {
+      provider: "openai-codex",
+      id: "gpt-5.5",
+    });
+  } finally {
+    process.chdir(originalCwd);
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("every known unit label with a dispatch phase resolves when all model buckets are configured", () => {
   withModelPreferences(() => {
     const missing = KNOWN_UNIT_LABELS.filter((unitType) => !resolveModelWithFallbacksForUnit(unitType));

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

@@ -1,7 +1,12 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
+import { playQuestionBell } from "../../ask-user-questions.js";
+import { stopAuto } from "../auto.js";
+import { autoSession } from "../auto-runtime-state.js";
 import {
   buildDesktopNotificationCommand,
   shouldSendDesktopNotification,
@@ -58,18 +63,68 @@ test("playNotificationBell is silent when disabled", () => {
   assert.equal(output, "");
 });
 
-test("ask_user_questions plays local bell before waiting for an answer", () => {
-  const source = readFileSync(new URL("../../ask-user-questions.ts", import.meta.url), "utf-8");
+test("playQuestionBell writes a terminal bell when local bell is enabled", async () => {
+  let output = "";
+  const stream = { write: (chunk: string) => { output += chunk; } };
 
-  assert.match(source, /playNotificationBell\("question"\)/);
-  assert.match(source, /await playQuestionBell\(\)/);
+  await playQuestionBell({ enabled: true, local_bell: true }, stream);
+
+  assert.equal(output, "\u0007");
 });
 
-test("stopAuto plays local bell for auto-mode stop notifications", () => {
-  const source = readFileSync(new URL("../auto.ts", import.meta.url), "utf-8");
+test("playQuestionBell is silent when local bell is disabled", async () => {
+  let output = "";
+  const stream = { write: (chunk: string) => { output += chunk; } };
 
-  assert.match(source, /import \{[^}]*playNotificationBell[^}]*\} from "\.\/notifications\.js"/);
-  assert.match(source, /playNotificationBell\("stop", loadedPreferences\?\.notifications\)/);
+  await playQuestionBell({ enabled: true, local_bell: false }, stream);
+
+  assert.equal(output, "");
+});
+
+test("stopAuto plays local bell for auto-mode stop notifications", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stop-bell-"));
+  const previousCwd = process.cwd();
+  const previousStderrWrite = process.stderr.write;
+  const previousStderrIsTTY = process.stderr.isTTY;
+  let bellOutput = "";
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = base;
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\nnotifications:\n  enabled: true\n  local_bell: true\n---\n",
+    "utf-8",
+  );
+
+  process.stderr.isTTY = true;
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    if (typeof chunk === "string") {
+      bellOutput += chunk;
+    }
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    await stopAuto(
+      { hasUI: false, ui: { notify: () => {}, setStatus: () => {}, setWidget: () => {}, setHeader: () => {} } } as any,
+      undefined,
+      "test stop",
+    );
+
+    assert.ok(
+      bellOutput.includes("\u0007"),
+      "stopAuto must write a terminal bell to stderr when the local bell preference is enabled",
+    );
+  } finally {
+    process.stderr.write = previousStderrWrite;
+    process.stderr.isTTY = previousStderrIsTTY;
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
 });
 
 test("buildDesktopNotificationCommand falls back to osascript on macOS when terminal-notifier is absent", () => {

package/src/resources/extensions/gsd/tests/oauth-api-model-routing.test.ts

@@ -0,0 +1,167 @@
+/**
+ * OAuth/subscription vs pay-per-token API routing for bare model IDs.
+ *
+ * When the same model ID (e.g. gpt-5.5) exists on multiple providers, resolveModelId
+ * must prefer subscription/OAuth routes over platform API keys.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { MODELS } from "../../../../../packages/pi-ai/dist/models.generated.js";
+import {
+  BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE,
+  resolveModelId,
+} from "../auto-model-selection.js";
+
+type ModelRef = { id: string; provider: string };
+
+function modelsForProviders(modelId: string, providers: string[]): ModelRef[] {
+  return providers.map((provider) => ({ id: modelId, provider }));
+}
+
+/** Table-driven precedence cases — one row per conflict shape, not per model ID. */
+const PRECEDENCE_CASES: Array<{
+  label: string;
+  modelId: string;
+  providers: string[];
+  expected: string;
+  currentProvider?: string;
+}> = [
+  {
+    label: "ChatGPT OAuth beats OpenAI API (gpt-5.5)",
+    modelId: "gpt-5.5",
+    providers: ["openai", "openai-codex"],
+    expected: "openai-codex",
+  },
+  {
+    label: "Codex beats Copilot beats OpenAI API (gpt-5.5 triple)",
+    modelId: "gpt-5.5",
+    providers: ["openai", "github-copilot", "openai-codex"],
+    expected: "openai-codex",
+  },
+  {
+    label: "Copilot OAuth beats OpenAI API when no Codex (gpt-5.5)",
+    modelId: "gpt-5.5",
+    providers: ["openai", "github-copilot"],
+    expected: "github-copilot",
+  },
+  {
+    label: "Copilot OAuth beats OpenAI API (gpt-5-mini)",
+    modelId: "gpt-5-mini",
+    providers: ["openai", "github-copilot"],
+    expected: "github-copilot",
+  },
+  {
+    label: "Anthropic beats Copilot for Claude (claude-sonnet-4-6)",
+    modelId: "claude-sonnet-4-6",
+    providers: ["anthropic", "github-copilot"],
+    expected: "anthropic",
+  },
+  {
+    label: "Copilot beats Google API for Gemini (gemini-2.5-pro)",
+    modelId: "gemini-2.5-pro",
+    providers: ["google", "github-copilot"],
+    expected: "github-copilot",
+  },
+  {
+    label: "Gemini CLI beats Google API (gemini-2.5-pro)",
+    modelId: "gemini-2.5-pro",
+    providers: ["google", "google-gemini-cli"],
+    expected: "google-gemini-cli",
+  },
+  {
+    label: "Gemini CLI beats Copilot beats Google API",
+    modelId: "gemini-2.5-pro",
+    providers: ["google", "github-copilot", "google-gemini-cli"],
+    expected: "google-gemini-cli",
+  },
+  {
+    label: "Session provider still wins (openai-codex explicit)",
+    modelId: "gpt-5.5",
+    providers: ["openai", "openai-codex", "github-copilot"],
+    expected: "github-copilot",
+    currentProvider: "github-copilot",
+  },
+  {
+    label: "claude-code session beats anthropic (#3772)",
+    modelId: "claude-sonnet-4-6",
+    providers: ["anthropic", "claude-code"],
+    expected: "claude-code",
+    currentProvider: "claude-code",
+  },
+];
+
+for (const row of PRECEDENCE_CASES) {
+  test(`resolveModelId precedence: ${row.label}`, () => {
+    const available = modelsForProviders(row.modelId, row.providers);
+    const result = resolveModelId(row.modelId, available, row.currentProvider);
+    assert.ok(result, `expected a match for ${row.modelId}`);
+    assert.equal(result.provider, row.expected);
+  });
+}
+
+test("BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE covers known OAuth/subscription providers", () => {
+  const expected = [
+    "openai-codex",
+    "google-gemini-cli",
+    "anthropic",
+    "github-copilot",
+    "google-antigravity",
+  ];
+  assert.deepEqual([...BARE_ID_SUBSCRIPTION_PROVIDER_PRECEDENCE], expected);
+});
+
+test("every catalog overlap with OAuth/subscription + API resolves to subscription route", () => {
+  const oauthProviders = new Set(["anthropic", "github-copilot", "openai-codex"]);
+  const subscriptionCli = new Set(["google-gemini-cli", "google-antigravity", "claude-code"]);
+  const apiPayPerToken = new Set(["openai", "google", "azure-openai-responses"]);
+
+  const byId = new Map<string, Set<string>>();
+  for (const [provider, models] of Object.entries(MODELS)) {
+    for (const id of Object.keys(models)) {
+      if (!byId.has(id)) byId.set(id, new Set());
+      byId.get(id)!.add(provider);
+    }
+  }
+
+  const failures: string[] = [];
+
+  for (const [modelId, providers] of byId) {
+    if (providers.size < 2) continue;
+
+    const hasApi = [...providers].some((p) => apiPayPerToken.has(p));
+    const subscriptionCandidates = [...providers].filter(
+      (p) => oauthProviders.has(p) || subscriptionCli.has(p),
+    );
+    if (!hasApi || subscriptionCandidates.length === 0) continue;
+
+    const testProviders = new Set<string>(subscriptionCandidates);
+    for (const p of providers) {
+      if (apiPayPerToken.has(p)) testProviders.add(p);
+    }
+
+    const available = modelsForProviders(modelId, [...testProviders]);
+    const result = resolveModelId(modelId, available, undefined);
+    if (!result) {
+      failures.push(`${modelId}: no resolution among ${[...testProviders].join(", ")}`);
+      continue;
+    }
+
+    const winnerIsSubscription =
+      oauthProviders.has(result.provider) ||
+      subscriptionCli.has(result.provider) ||
+      result.provider === "anthropic";
+
+    if (!winnerIsSubscription) {
+      failures.push(
+        `${modelId}: got ${result.provider}, expected subscription route among ${[...testProviders].join(", ")}`,
+      );
+    }
+  }
+
+  assert.equal(
+    failures.length,
+    0,
+    `catalog overlap routing failures:\n${failures.join("\n")}`,
+  );
+});

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -41,6 +41,7 @@ after(() => {
 
 const { resolveDispatch } = await import("../auto-dispatch.ts");
 const { buildParallelResearchSlicesPrompt } = await import("../auto-prompts.ts");
+const { openDatabase, closeDatabase, insertMilestone, insertSlice } = await import("../gsd-db.ts");
 
 type DispatchState = Parameters<typeof resolveDispatch>[0]["state"];
 
@@ -51,6 +52,20 @@ function writeRoadmap(
 ): void {
   const milestoneDir = join(base, ".gsd", "milestones", mid);
   mkdirSync(milestoneDir, { recursive: true });
+  // The dispatch rule reads slices from the DB (ADR-017), not the ROADMAP
+  // projection — seed both so disk-based artifact checks still resolve.
+  insertMilestone({ id: mid, title: "Parallel Research Milestone" });
+  let sequence = 1;
+  for (const s of slices) {
+    insertSlice({
+      id: s.id,
+      milestoneId: mid,
+      title: s.title,
+      status: s.done ? "complete" : "pending",
+      depends: s.depends ?? [],
+      sequence: sequence++,
+    });
+  }
   const lines = [
     `# ${mid}: Parallel Research Milestone`,
     "",
@@ -100,9 +115,12 @@ describe("parallel-research-slices dispatch rule", () => {
 
   beforeEach(() => {
     base = mkdtempSync(join(tmpdir(), "parallel-research-"));
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
   });
 
   afterEach(() => {
+    closeDatabase();
     rmSync(base, { recursive: true, force: true });
   });
 

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -29,8 +29,8 @@ import {
 
 const SKILL_NAME = "testskill";
 const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
-const SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${SKILL_NAME}' })`;
-const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${COMPLETE_SLICE_SKILL_NAME}' })`;
+const SKILL_ACTIVATION_SUBSTRING = `Read the installed '${SKILL_NAME}' skill file from <available_skills>`;
+const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Read the installed '${COMPLETE_SLICE_SKILL_NAME}' skill file from <available_skills>`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;