@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.4813ead6

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/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/parse-project-milestone-bridge.test.ts

@@ -0,0 +1,77 @@
+// gsd-pi / parseProject MILESTONE_LINE_RE bridging regression
+//
+// Guards against a silent data-integrity bug: MILESTONE_LINE_RE used `\s+`
+// around its separator, and `\s` matches newlines. A milestone line lacking a
+// valid internal separator could therefore "bridge" onto the NEXT bullet's
+// `- `, consuming it as the separator and swallowing the following well-formed
+// milestone. The separator gaps are now horizontal-whitespace-only so a line
+// can never span a newline.
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { parseProject } from "../schemas/parsers.ts";
+
+function milestoneSection(...lines: string[]): string {
+  return ["# Project", "", "## Milestone Sequence", "", ...lines, ""].join("\n");
+}
+
+describe("parseProject milestone bridging", () => {
+  test("a malformed milestone line does not swallow the following well-formed one", () => {
+    // M001 uses an invalid " : " separator; M002 is canonical. Before the fix
+    // this returned a SINGLE match (M001 with oneLiner "[ ] M002: Baz — qux"),
+    // dropping M002 entirely.
+    const content = milestoneSection(
+      "- [ ] M001: Foo : bar",
+      "- [ ] M002: Baz — qux",
+    );
+
+    const { milestones } = parseProject(content);
+
+    // M002 must survive intact — it must NOT be consumed as M001's one-liner.
+    const m002 = milestones.find(m => m.id === "M002");
+    assert.ok(m002, "M002 must be registered, not swallowed by the malformed M001 line");
+    assert.equal(m002!.title, "Baz", "M002 title parsed cleanly");
+    assert.equal(m002!.oneLiner, "qux", "M002 one-liner parsed cleanly");
+
+    // No milestone may have bridged the M002 bullet into its own one-liner.
+    assert.ok(
+      !milestones.some(m => m.oneLiner.includes("M002")),
+      "no milestone may bridge across the newline and consume the M002 bullet",
+    );
+
+    // M001 has no valid separator, so it is skipped — consistent with the
+    // empty-parse hard-fail in execute-summary-save-empty-project.test.ts.
+    // The fixture therefore yields exactly the one well-formed milestone.
+    assert.deepEqual(milestones.map(m => m.id), ["M002"], "only the well-formed milestone parses");
+  });
+
+  test("two well-formed milestones on adjacent lines both parse", () => {
+    const content = milestoneSection(
+      "- [x] M001: Foo — bar",
+      "- [ ] M002: Baz — qux",
+    );
+
+    const { milestones } = parseProject(content);
+    assert.deepEqual(
+      milestones.map(m => ({ id: m.id, title: m.title, oneLiner: m.oneLiner, done: m.done })),
+      [
+        { id: "M001", title: "Foo", oneLiner: "bar", done: true },
+        { id: "M002", title: "Baz", oneLiner: "qux", done: false },
+      ],
+      "adjacent canonical milestone lines are parsed independently",
+    );
+  });
+
+  test("a trailing malformed line cannot bridge onto a following bullet of any kind", () => {
+    // The last milestone is malformed and is followed by a non-milestone list
+    // bullet. The malformed line must be skipped without consuming the bullet.
+    const content = milestoneSection(
+      "- [ ] M001: Foo — bar",
+      "- [ ] M002: Baz : qux",
+      "- some unrelated bullet",
+    );
+
+    const { milestones } = parseProject(content);
+    assert.deepEqual(milestones.map(m => m.id), ["M001"], "malformed M002 is skipped, not bridged onto the unrelated bullet");
+  });
+});

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

@@ -347,3 +347,48 @@ test('handlePlanMilestone updates depends_on when a queued milestone row already
     cleanup(base);
   }
 });
+
+// Regression #566: bracket-wrapped slice ID in depends should be rejected
+test('handlePlanMilestone rejects bracket-wrapped depends like ["[S01]"]', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const params = validParams();
+    // Simulate the LLM sending "[S01]" (the markdown fragment) instead of "S01"
+    const corruptSlices = [
+      params.slices[0],
+      { ...params.slices[1], depends: ['[S01]'] },
+    ];
+    const result = await handlePlanMilestone({ ...params, slices: corruptSlices }, base);
+    assert.ok('error' in result, 'should return an error for bracket-wrapped depends');
+    assert.match(result.error, /slices\[1\]\.depends must be an array of valid slice IDs/,
+      'error should mention invalid slice ID format');
+    assert.equal(getMilestoneSlices('M001').length, 0, 'no slices should persist on validation failure');
+  } finally {
+    cleanup(base);
+  }
+});
+
+// Regression #566: unknown slice ID in depends should be rejected
+test('handlePlanMilestone rejects depends referencing a slice not in the same milestone', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const params = validParams();
+    const corruptSlices = [
+      params.slices[0],
+      { ...params.slices[1], depends: ['S99'] },
+    ];
+    const result = await handlePlanMilestone({ ...params, slices: corruptSlices }, base);
+    assert.ok('error' in result, 'should return an error for unknown depends slice');
+    assert.match(result.error, /references unknown slice "S99"/,
+      'error should name the unknown slice');
+    assert.equal(getMilestoneSlices('M001').length, 0, 'no slices should persist on validation failure');
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/plan-slice-prompt.test.ts

@@ -76,8 +76,10 @@ test("plan-slice prompt: compact planning gates survive template substitution",
   assert.ok(result.includes("Bias toward \"roadmap is fine.\""), "roadmap reassessment brake should remain visible");
   assert.ok(result.includes("Self-audit before finishing"), "self-audit gate should remain visible");
   assert.ok(result.includes("Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable."));
-  assert.ok(result.includes("C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\plan.md"));
-  assert.ok(result.includes("C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-plan.md"));
+  assert.ok(result.includes("Use the inlined Output Template sections already present in this prompt."));
+  assert.ok(result.includes("Do not read template files from disk."));
+  assert.ok(!result.includes("C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\plan.md"));
+  assert.ok(!result.includes("C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-plan.md"));
   assert.ok(!result.includes("{{templatesDir}}/plan.md"));
   assert.ok(!result.includes("{{templatesDir}}/task-plan.md"));
   assert.ok(!result.includes("{{"));
@@ -135,6 +137,7 @@ test("skillActivation default leaves no unresolved placeholder", () => {
     carryForwardSection: "Carry forward",
     resumeSection: "Resume",
     priorTaskLines: "- (no prior tasks)",
+    onDemandContext: "",
     templatesDir: join(fixtureRoot, "templates"),
     taskSummaryPath: join(fixtureRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
     inlinedTemplates: "Template",
@@ -161,6 +164,7 @@ test("custom skillActivation is substituted into execute-task", () => {
     carryForwardSection: "Carry forward",
     resumeSection: "Resume",
     priorTaskLines: "- (no prior tasks)",
+    onDemandContext: "",
     templatesDir: join(fixtureRoot, "templates"),
     taskSummaryPath: join(fixtureRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
     inlinedTemplates: "Template",

package/src/resources/extensions/gsd/tests/planning-crossval.test.ts

@@ -15,6 +15,7 @@ import {
   insertTask,
   getMilestoneSlices,
   getSliceTasks,
+  _getAdapter,
 } from '../gsd-db.ts';
 import {
   renderRoadmapFromDb,
@@ -423,4 +424,48 @@ console.log('\n=== planning-crossval Test 6: ROADMAP descriptor projection dir =
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Test 7: Renderer strips bracket-wrapped depends from corrupt DB rows (#566)
+// ═══════════════════════════════════════════════════════════════════════════
+// Simulates a DB that was corrupted before the insertSlice validation guard
+// was added (issue #566). The renderer must recover "[S01]" → "S01" rather
+// than silently dropping the dependency and rendering depends:[].
+
+console.log('\n=== planning-crossval Test 7: renderer recovers bracket-wrapped depends (#566) ===');
+{
+  const base = realpathSync(createFixtureBase());
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  try {
+    scaffoldDirs(base, 'M001', ['S01', 'S02']);
+
+    insertMilestone({
+      id: 'M001',
+      title: 'Bracket Recovery',
+      status: 'active',
+      planning: { vision: 'Recover bracket-wrapped depends from corrupt DB.' },
+    });
+
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Foundation', status: 'pending', risk: 'low', depends: [], demo: 'Foundation done.', sequence: 1 });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Build', status: 'pending', risk: 'medium', depends: [], demo: 'Build done.', sequence: 2 });
+
+    // Bypass insertSlice validation to simulate pre-fix corrupt DB state
+    // (insertSlice now rejects bracket-wrapped IDs, but old DBs may have them)
+    _getAdapter()?.prepare('UPDATE slices SET depends = ? WHERE id = ? AND milestone_id = ?')
+      .run('["[S01]"]', 'S02', 'M001');
+
+    const rendered = await renderRoadmapFromDb(base, 'M001');
+    const content = readFileSync(rendered.roadmapPath, 'utf-8');
+    const parsed = parseRoadmapSlices(content);
+
+    assertEq(parsed.length, 2, 'T7: 2 slices parsed');
+    assertEq(parsed[1]?.depends.length, 1, 'T7: S02 has 1 dependency after bracket recovery');
+    assertEq(parsed[1]?.depends[0], 'S01', 'T7: recovered dependency is "S01", not "[S01]"');
+    assertTrue(content.includes('`depends:[S01]`'), 'T7: S02 renders with recovered depends:[S01] not empty depends:[]');
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+}
+
 report();

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

@@ -0,0 +1,67 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  _resetPreferenceDiagnosticNotificationsForTests,
+  notifyPreferenceDiagnostics,
+} from "../preferences-diagnostics.ts";
+import { _resetParseWarningFlag } from "../preferences.ts";
+
+test("notifyPreferenceDiagnostics dedupes within a surface but re-surfaces across surfaces", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-notify-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-notify-home-"));
+  t.after(() => {
+    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 });
+    _resetPreferenceDiagnosticNotificationsForTests();
+    _resetParseWarningFlag();
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  _resetPreferenceDiagnosticNotificationsForTests();
+  _resetParseWarningFlag();
+
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    "---\nversion: 3\n---\n",
+    "utf-8",
+  );
+
+  const notifications: Array<{ message: string; type?: string }> = [];
+  const ctx = {
+    ui: {
+      notify(message: string, type?: "info" | "warning" | "error" | "success") {
+        notifications.push({ message, type });
+      },
+    },
+  };
+
+  assert.equal(
+    notifyPreferenceDiagnostics(ctx, tempProject, { surface: "session-start" }),
+    1,
+  );
+  assert.equal(
+    notifyPreferenceDiagnostics(ctx, tempProject, { surface: "session-start" }),
+    0,
+  );
+  assert.equal(
+    notifyPreferenceDiagnostics(ctx, tempProject, { surface: "auto-preflight" }),
+    1,
+  );
+  assert.equal(notifications.length, 2);
+  assert.equal(notifications[0]!.type, "error");
+  assert.match(notifications[0]!.message, /GSD project preferences error/);
+  assert.match(notifications[0]!.message, /unsupported version 3/);
+  assert.match(notifications[0]!.message, /Run \/gsd doctor for details/);
+  assert.equal(notifications[1]!.message, notifications[0]!.message);
+});