@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.955e4da0

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

@@ -55,6 +55,31 @@ test("isMilestoneCloseoutSettled requires DB closed and summary artifact", async
   assert.equal(settled, true);
 });
 
+test("isMilestoneCloseoutSettled accepts summary artifacts in a live milestone worktree", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-milestone-closeout-worktree-"));
+  tmpDirs.push(base);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+
+  const worktreeRoot = join(base, ".gsd", "worktrees", "M001");
+  const milestoneDir = join(worktreeRoot, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(worktreeRoot, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M001")}\n`);
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\n");
+
+  const settled = await isMilestoneCloseoutSettled("M001", base);
+  assert.equal(settled, true);
+});
+
 test("isMilestoneCloseoutSettled returns false when summary artifact is missing", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-milestone-closeout-missing-"));
   tmpDirs.push(base);

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

@@ -0,0 +1,46 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for the milestone merge transaction wrapper.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  createMilestoneMergeTransaction,
+  runMilestoneMergeTransaction,
+} from "../milestone-merge-transaction.js";
+
+test("runMilestoneMergeTransaction delegates to the supplied merge runner", () => {
+  const calls: unknown[][] = [];
+  const result = runMilestoneMergeTransaction(
+    {
+      mergeMilestoneToMain: (basePath, milestoneId, roadmapContent) => {
+        calls.push([basePath, milestoneId, roadmapContent]);
+        return { pushed: true, codeFilesChanged: true, commitMessage: "merge M001" };
+      },
+    },
+    {
+      basePath: "/repo",
+      milestoneId: "M001",
+      roadmapContent: "# M001",
+    },
+  );
+
+  assert.deepEqual(calls, [["/repo", "M001", "# M001"]]);
+  assert.deepEqual(result, {
+    pushed: true,
+    codeFilesChanged: true,
+    commitMessage: "merge M001",
+  });
+});
+
+test("createMilestoneMergeTransaction returns a lifecycle-compatible runner", () => {
+  const runner = createMilestoneMergeTransaction(() => ({
+    pushed: false,
+    codeFilesChanged: false,
+  }));
+
+  assert.deepEqual(runner("/repo", "M002", "# M002"), {
+    pushed: false,
+    codeFilesChanged: false,
+  });
+});

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

@@ -0,0 +1,65 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  classifyMilestoneReadiness,
+  describeMilestoneReadinessPhase,
+  formatAcceptedDiscussHandoffMessage,
+  readinessNeedsDiscussion,
+} from "../milestone-readiness.ts";
+
+test("classifyMilestoneReadiness distinguishes queued shells from draft discussion work", () => {
+  const shell = classifyMilestoneReadiness({
+    status: "queued",
+    hasDraftContext: true,
+    sliceCount: 0,
+  });
+
+  assert.equal(shell.kind, "queued-shell");
+  assert.equal(readinessNeedsDiscussion(shell), true);
+});
+
+test("classifyMilestoneReadiness marks context-only milestones as planning pending", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "queued",
+    hasContext: true,
+    sliceCount: 0,
+  });
+
+  assert.equal(readiness.kind, "planning-pending");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 context captured. Continuing the planning pipeline.");
+});
+
+test("classifyMilestoneReadiness marks persisted slices as executable plan", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "active",
+    hasContext: true,
+    sliceCount: 1,
+  });
+
+  assert.equal(readiness.kind, "executable-plan");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 ready.");
+});
+
+test("formatAcceptedDiscussHandoffMessage preserves ready copy for any executable plan", () => {
+  const readiness = classifyMilestoneReadiness({
+    status: "complete",
+    hasContext: true,
+    sliceCount: 1,
+  });
+
+  assert.equal(readiness.kind, "terminal");
+  assert.equal(formatAcceptedDiscussHandoffMessage("M001", readiness), "Milestone M001 ready.");
+});
+
+test("describeMilestoneReadinessPhase keeps dashboard phase copy centralized", () => {
+  assert.deepEqual(describeMilestoneReadinessPhase("needs-discussion"), {
+    label: "Discuss milestone draft",
+    description: "Milestone has a draft context — needs discussion before planning.",
+  });
+  assert.deepEqual(describeMilestoneReadinessPhase("pre-planning"), {
+    label: "Research & plan milestone",
+    description: "Scout the landscape and create the roadmap.",
+  });
+  assert.equal(describeMilestoneReadinessPhase("executing"), null);
+});

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/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

@@ -137,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",
@@ -163,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);
+});

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

@@ -26,6 +26,7 @@ import {
   renderPreferencesForSystemPrompt,
   _resetParseWarningFlag,
 } from "../preferences.ts";
+import { collectPreferenceDiagnostics, formatPreferenceDiagnostic } from "../preferences-diagnostics.ts";
 import { formatConfiguredModel, toPersistedModelId } from "../commands-prefs-wizard.ts";
 import { _resetLogs, peekLogs } from "../workflow-logger.ts";
 import type { GSDPreferences, GSDModelConfigV2, GSDPhaseModelConfig } from "../preferences.ts";
@@ -819,6 +820,188 @@ bad: [
   _resetLogs();
 });
 
+test("malformed global preferences load with a structured parse diagnostic", (t) => {
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-diagnostic-home-"));
+  t.after(() => {
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempGsdHome, { recursive: true, force: true });
+    _resetParseWarningFlag();
+    _resetLogs();
+  });
+
+  process.env.GSD_HOME = tempGsdHome;
+  _resetParseWarningFlag();
+  _resetLogs();
+  writeFileSync(
+    join(tempGsdHome, "PREFERENCES.md"),
+    [
+      "---",
+      "version: 1",
+      "models:",
+      "  validation:",
+      "    openrouter/deepseek/deepseek-v4-pro",
+      "    thinking: high",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const loaded = loadGlobalGSDPreferences();
+  assert.notEqual(loaded, null);
+  assert.deepEqual(loaded!.preferences, {});
+  const diagnostic = loaded!.diagnostics?.[0];
+  assert.equal(diagnostic?.kind, "parse");
+  assert.equal(diagnostic?.severity, "error");
+  assert.equal(diagnostic?.line, 5);
+  assert.equal(diagnostic?.column, 5);
+  assert.equal(diagnostic?.ignored, true);
+  assert.match(diagnostic?.message ?? "", /Implicit keys need/);
+
+  const formatted = formatPreferenceDiagnostic(diagnostic!);
+  assert.match(formatted, /GSD global preferences error/);
+  assert.match(formatted, /line 5, column 5/);
+  assert.match(formatted, /Preferences from this file were ignored/);
+});
+
+test("project preference validation errors load with structured diagnostics", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-validation-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-validation-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 });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    "---\nversion: 3\n---\n",
+    "utf-8",
+  );
+
+  const loaded = loadProjectGSDPreferences(tempProject);
+  assert.notEqual(loaded, null);
+  assert.equal(loaded!.preferences.version, undefined);
+  const diagnostic = loaded!.diagnostics?.find((item) => item.kind === "validation");
+  assert.equal(diagnostic?.scope, "project");
+  assert.equal(diagnostic?.severity, "error");
+  assert.equal(diagnostic?.sanitized, true);
+  assert.match(diagnostic?.message ?? "", /unsupported version 3/);
+
+  const collected = collectPreferenceDiagnostics(tempProject);
+  assert.ok(
+    collected.some((item) => item.path === loaded!.path && item.message.includes("unsupported version 3")),
+    "collector should include project validation diagnostics",
+  );
+});
+
+test("malformed project preferences do not override effective global wrapper", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-effective-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-effective-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 });
+    _resetParseWarningFlag();
+    _resetLogs();
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  _resetParseWarningFlag();
+  _resetLogs();
+
+  const globalPath = getGlobalGSDPreferencesPath();
+  const projectPath = getProjectGSDPreferencesPath(tempProject);
+  writeFileSync(globalPath, "---\nlanguage: Spanish\n---\n", "utf-8");
+  writeFileSync(
+    projectPath,
+    [
+      "---",
+      "version: 1",
+      "models:",
+      "  validation:",
+      "    openrouter/deepseek/deepseek-v4-pro",
+      "    thinking: high",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const projectPrefs = loadProjectGSDPreferences(tempProject);
+  assert.equal(projectPrefs?.ignored, true);
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.notEqual(loaded, null);
+  assert.equal(loaded!.path, globalPath);
+  assert.equal(loaded!.scope, "global");
+  assert.equal(loaded!.preferences.language, "Spanish");
+  assert.ok(
+    loaded!.diagnostics?.some((item) => item.path === projectPath && item.kind === "parse"),
+    "effective global preferences should carry malformed project diagnostics",
+  );
+});
+
+test("malformed global preferences: loadEffectiveGSDPreferences returns null without project file", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-effective-malformed-global-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-effective-malformed-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 });
+    _resetParseWarningFlag();
+    _resetLogs();
+  });
+
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  _resetParseWarningFlag();
+  _resetLogs();
+
+  const globalPath = getGlobalGSDPreferencesPath();
+  writeFileSync(
+    globalPath,
+    [
+      "---",
+      "version: 1",
+      "models:",
+      "  validation:",
+      "    openrouter/deepseek/deepseek-v4-pro",
+      "    thinking: high",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const globalPrefs = loadGlobalGSDPreferences();
+  assert.equal(globalPrefs?.ignored, true, "malformed global should be marked ignored");
+
+  // Symmetric with malformed project + no global: effective result should be null,
+  // not an effective object with ignored:true leaking through.
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.equal(loaded, null, "effective preferences should be null when only global file is malformed");
+});
+
 // ── Experimental preferences ─────────────────────────────────────────────────
 
 test("experimental.rtk: true is accepted and stored", () => {