@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

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

@@ -0,0 +1,41 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for forwarded milestone validation evidence helpers.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyBrowserEvidenceGate,
+  hasRuntimeExecutableUatEvidenceText,
+} from "../milestone-validation-evidence.js";
+
+test("hasRuntimeExecutableUatEvidenceText requires runtime-executable PASS evidence", () => {
+  const evidence = [
+    "---",
+    "uatType: runtime-executable",
+    "verdict: PASS",
+    "---",
+    "| Check | Mode | Result | Evidence |",
+    "| DOM | runtime | PASS | gsd_uat_exec:.gsd/evidence/uat/M001/S01/dom.json |",
+  ].join("\n");
+
+  assert.equal(hasRuntimeExecutableUatEvidenceText(evidence), true);
+  assert.equal(hasRuntimeExecutableUatEvidenceText(evidence.replace("runtime | PASS", "manual | PASS")), false);
+});
+
+test("applyBrowserEvidenceGate records downgrade rationale", () => {
+  const params = applyBrowserEvidenceGate({
+    milestoneId: "M001",
+    verdict: "pass",
+    remediationRound: 0,
+    successCriteriaChecklist: "",
+    sliceDeliveryAudit: "",
+    crossSliceIntegration: "",
+    requirementCoverage: "",
+    verdictRationale: "Initial rationale.",
+  });
+
+  assert.equal(params.verdict, "needs-attention");
+  assert.match(params.verdictRationale, /Initial rationale/);
+  assert.match(params.verdictRationale, /Browser evidence gate/);
+});

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

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolveMilestoneValidationVerdict } from "../milestone-validation-verdict.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+function setup(base: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  process.chdir(base);
+  _clearGsdRootCache();
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  invalidateAllCaches();
+}
+
+test("resolveMilestoneValidationVerdict prefers DB pass over stale worktree needs-attention", async () => {
+  const base = join(tmpdir(), `validation-verdict-${Date.now()}`);
+  mkdirSync(base, { recursive: true });
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), "gitdir: ../.git/worktrees/M001\n", "utf-8");
+  writeFileSync(
+    join(worktree, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+    "---\nverdict: needs-attention\n---\n\n# Validation\nStale worktree copy.\n",
+  );
+
+  try {
+    setup(base);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertAssessment({
+      path: join(worktree, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      milestoneId: "M001",
+      sliceId: null,
+      taskId: null,
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "---\nverdict: pass\n---\n\n# Validation\nManual override.\n",
+    });
+
+    const verdict = await resolveMilestoneValidationVerdict(base, "M001");
+    assert.equal(verdict, "pass");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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/native-merge-regular.test.ts

@@ -0,0 +1,139 @@
+// Regression tests for nativeMergeRegular (#549 — merge_strategy: merge).
+//
+// nativeMergeRegular is the new `git merge --no-ff --no-commit` path called
+// when `git.merge_strategy: merge` is configured. These tests verify:
+//   1. Success path: returns { success: true, conflicts: [] } and leaves MERGE_HEAD
+//      so nativeCommit can supply the commit message and git records two parents.
+//   2. Dirty-tree path: returns __dirty_working_tree__ sentinel (matching
+//      nativeMergeSquash behaviour) when uncommitted changes would be overwritten.
+//   3. Content-conflict path: returns the conflicted file names (not the dirty-tree
+//      sentinel) when both branches modified the same region of a file.
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { nativeMergeRegular } from "../native-git-bridge.ts";
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function makeRepo(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  git(dir, "init");
+  git(dir, "config", "user.email", "test@test.com");
+  git(dir, "config", "user.name", "Test");
+  git(dir, "config", "core.autocrlf", "false");
+  writeFileSync(join(dir, "README.md"), "# init\n");
+  git(dir, "add", "-A");
+  git(dir, "commit", "-m", "init");
+  git(dir, "branch", "-M", "main");
+  return dir;
+}
+
+describe("nativeMergeRegular (#549)", () => {
+  const tempDirs: string[] = [];
+
+  function freshRepo(prefix: string = "nmr-"): string {
+    const d = makeRepo(prefix);
+    tempDirs.push(d);
+    return d;
+  }
+
+  afterEach(() => {
+    for (const d of tempDirs) {
+      try {
+        git(d, "merge", "--abort");
+      } catch {
+        // no merge in progress — that is fine
+      }
+      if (existsSync(d)) rmSync(d, { recursive: true, force: true });
+    }
+    tempDirs.length = 0;
+  });
+
+  test("success: returns { success: true, conflicts: [] } and sets MERGE_HEAD", () => {
+    const repo = freshRepo("nmr-success-");
+    git(repo, "checkout", "-b", "feature");
+    writeFileSync(join(repo, "feature.ts"), "export const a = 1;\n");
+    git(repo, "add", "feature.ts");
+    git(repo, "commit", "-m", "add feature");
+    git(repo, "checkout", "main");
+
+    const result = nativeMergeRegular(repo, "feature");
+
+    assert.equal(result.success, true);
+    assert.deepEqual(result.conflicts, []);
+    // --no-commit leaves MERGE_HEAD; nativeCommit sees it and creates two parents.
+    assert.ok(
+      existsSync(join(repo, ".git", "MERGE_HEAD")),
+      "MERGE_HEAD must exist after --no-ff --no-commit so the caller commits a true merge",
+    );
+  });
+
+  test("dirty working tree: returns __dirty_working_tree__ sentinel", () => {
+    const repo = freshRepo("nmr-dirty-");
+
+    // feature branch introduces feature.ts
+    git(repo, "checkout", "-b", "feature");
+    writeFileSync(join(repo, "feature.ts"), "export const x = 1;\n");
+    git(repo, "add", "feature.ts");
+    git(repo, "commit", "-m", "add feature");
+    git(repo, "checkout", "main");
+
+    // dirty uncommitted local file that the merge would overwrite
+    writeFileSync(join(repo, "feature.ts"), "// local dirty version\n");
+
+    const result = nativeMergeRegular(repo, "feature");
+
+    assert.equal(result.success, false);
+    assert.ok(
+      result.conflicts.includes("__dirty_working_tree__"),
+      `expected __dirty_working_tree__ sentinel, got: ${JSON.stringify(result.conflicts)}`,
+    );
+  });
+
+  test("content conflict: returns conflicted file names, not dirty-tree sentinel", () => {
+    const repo = freshRepo("nmr-conflict-");
+
+    // Diverging history: both main and feature modify the same file region.
+    writeFileSync(join(repo, "shared.ts"), "// base\nexport const v = 0;\n");
+    git(repo, "add", "shared.ts");
+    git(repo, "commit", "-m", "base version");
+
+    git(repo, "checkout", "-b", "feature");
+    writeFileSync(join(repo, "shared.ts"), "// feature version\nexport const v = 2;\n");
+    git(repo, "add", "shared.ts");
+    git(repo, "commit", "-m", "feature changes shared");
+
+    git(repo, "checkout", "main");
+    writeFileSync(join(repo, "shared.ts"), "// main version\nexport const v = 1;\n");
+    git(repo, "add", "shared.ts");
+    git(repo, "commit", "-m", "main changes shared");
+
+    const result = nativeMergeRegular(repo, "feature");
+
+    assert.equal(result.success, false);
+    assert.ok(
+      result.conflicts.includes("shared.ts"),
+      `expected shared.ts in conflicts, got: ${JSON.stringify(result.conflicts)}`,
+    );
+    assert.ok(
+      !result.conflicts.includes("__dirty_working_tree__"),
+      "content conflict must not be misclassified as dirty-tree",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -306,6 +306,38 @@ describe("notification-store", () => {
     rmSync(lockPath, { force: true });
   });
 
+  test("structured meta persists kind and scope on the entry", () => {
+    initNotificationStore(tmp);
+    appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M005" });
+
+    const entries = readNotifications();
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].kind, "auto-stop");
+    assert.equal(entries[0].scope, "M005");
+  });
+
+  test("dedup keys on kind+scope when present, not on prose", () => {
+    initNotificationStore(tmp);
+    appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M005" });
+    // Rephrased message, same structured identity → deduped within the window
+    appendNotification("Auto-mode blocked — gate rejected", "warning", "notify", { kind: "auto-stop", scope: "M005" });
+    // Same kind, different scope → distinct
+    appendNotification("Auto-mode blocked — validation gate", "warning", "notify", { kind: "auto-stop", scope: "M006" });
+
+    assert.equal(readNotifications().length, 2);
+  });
+
+  test("readNotifications filters by kind and scope", () => {
+    initNotificationStore(tmp);
+    appendNotification("a", "info", "notify", { kind: "auto-stop", scope: "M005" });
+    appendNotification("b", "info", "notify", { kind: "provider-error-pause", scope: "M005" });
+    appendNotification("c", "info");
+
+    assert.equal(readNotifications(tmp, { kind: "auto-stop" }).length, 1);
+    assert.equal(readNotifications(tmp, { scope: "M005" }).length, 2);
+    assert.equal(readNotifications(tmp, { kind: "provider-error-pause", scope: "M005" })[0].message, "b");
+  });
+
   test("listeners are notified on append, markAllRead, and clear", () => {
     initNotificationStore(tmp);
     let calls = 0;

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/orchestrator-legacy-parity.test.ts

@@ -0,0 +1,127 @@
+// Project/App: gsd-pi
+// File Purpose: #442 Phase 3.14 — characterization battery proving the
+// Orchestrator's dispatch DECISION matches what the legacy
+// runPreDispatch/runDispatch path would produce, across representative
+// resolveDispatch outcomes. This is the safety net that licenses deleting the
+// dead legacy `else` branch in auto/loop.ts (loop never reaches it because
+// ensureOrchestrationModule runs unconditionally before autoLoop, so
+// s.orchestration is always set).
+//
+// Both paths delegate to the same resolveDispatch rule engine; the only thing
+// that differs is how each TRANSLATES a resolveDispatch action into a loop
+// outcome. We pin that translation equivalence here:
+//   resolveDispatch action  | legacy runDispatch -> loop | orchestrator decision
+//   ------------------------|----------------------------|----------------------
+//   dispatch                | IterationData(unit)        | { unitType, unitId } (advanced)
+//   stop                    | break -> stopped/blocked   | { kind: "blocked", action } | stopped
+//   skip                    | continue -> skipped        | { kind: "skipped" }
+//   (no rule matches)       | stop/no-unit               | null -> stopped(no remaining)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { decideOrchestratorDispatch } from "../auto/orchestrator.ts";
+import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
+import { RuleRegistry, setRegistry, resetRegistry } from "../rule-registry.ts";
+import type { UnifiedRule } from "../rule-types.ts";
+import type { GSDState } from "../types.ts";
+
+function makeState(): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Milestone" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Execute task",
+    registry: [],
+    requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+}
+
+const fakeCtx = {
+  model: { provider: "anthropic", baseUrl: "https://api.anthropic.com", contextWindow: 200_000 },
+  modelRegistry: { getAll: () => [], getProviderAuthMode: (_p: string) => "apiKey" as const },
+} as never;
+const fakePi = { getActiveTools: () => ["read_file", "write_file"] } as never;
+const BASE = "/tmp/orchestrator-legacy-parity";
+
+function installRule(where: UnifiedRule["where"]): void {
+  setRegistry(new RuleRegistry([{
+    name: "parity-rule",
+    when: "dispatch",
+    evaluation: "first-match",
+    where,
+    then: (r: unknown) => r,
+  }]));
+}
+
+function directCtx(state: GSDState): DispatchContext {
+  return {
+    basePath: BASE,
+    mid: state.activeMilestone!.id,
+    midTitle: state.activeMilestone!.title,
+    state,
+    prefs: undefined,
+    structuredQuestionsAvailable: "true",
+    sessionContextWindow: 200_000,
+    sessionProvider: "anthropic",
+    modelRegistry: (fakeCtx as { modelRegistry: unknown }).modelRegistry as never,
+  };
+}
+
+test("#442 characterization: dispatch action → orchestrator picks the same unit the legacy path would", async (t) => {
+  t.after(() => resetRegistry());
+  const state = makeState();
+  installRule(async () => ({ action: "dispatch", unitType: "execute-task", unitId: "T07", prompt: "p" }));
+
+  const legacy = await resolveDispatch(directCtx(state));
+  const decision = await decideOrchestratorDispatch(fakeCtx, fakePi, BASE, undefined, { stateSnapshot: state });
+
+  assert.equal((legacy as { action: string }).action, "dispatch");
+  assert.ok(decision && "unitType" in decision, "orchestrator must produce a unit decision");
+  assert.equal(decision.unitType, (legacy as { unitType: string }).unitType);
+  assert.equal(decision.unitId, (legacy as { unitId: string }).unitId);
+});
+
+test("#442 characterization: stop action → orchestrator blocks with stop, matching legacy break", async (t) => {
+  t.after(() => resetRegistry());
+  const state = makeState();
+  installRule(async () => ({ action: "stop", reason: "milestone blocked" }));
+
+  const legacy = await resolveDispatch(directCtx(state));
+  const decision = await decideOrchestratorDispatch(fakeCtx, fakePi, BASE, undefined, { stateSnapshot: state });
+
+  assert.equal((legacy as { action: string }).action, "stop");
+  assert.ok(decision && "kind" in decision && decision.kind === "blocked", "stop must translate to a blocked decision");
+  assert.equal((decision as { action: string }).action, "stop");
+});
+
+test("#442 characterization: skip action → orchestrator skips, matching legacy continue", async (t) => {
+  t.after(() => resetRegistry());
+  const state = makeState();
+  installRule(async () => ({ action: "skip", reason: "nothing to do this pass" }));
+
+  const legacy = await resolveDispatch(directCtx(state));
+  const decision = await decideOrchestratorDispatch(fakeCtx, fakePi, BASE, undefined, { stateSnapshot: state });
+
+  assert.equal((legacy as { action: string }).action, "skip");
+  assert.ok(decision && "kind" in decision && decision.kind === "skipped", "skip must translate to a skipped decision");
+});
+
+test("#442 characterization: no matching rule → orchestrator yields no unit (legacy 'no remaining units')", async (t) => {
+  t.after(() => resetRegistry());
+  const state = makeState();
+  installRule(async () => null);
+
+  const legacy = await resolveDispatch(directCtx(state));
+  const decision = await decideOrchestratorDispatch(fakeCtx, fakePi, BASE, undefined, { stateSnapshot: state });
+
+  // resolveDispatch with no match yields no dispatch action; the orchestrator
+  // surfaces that as a null decision, which advance() turns into a "stopped:
+  // no remaining units" outcome — the same terminal the legacy path reaches.
+  assert.ok(legacy == null || (legacy as { action?: string }).action !== "dispatch");
+  assert.ok(decision == null || !("unitType" in decision), "no-match must not yield a unit dispatch");
+});

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