gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

package/dist/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -0,0 +1,337 @@
+// GSD Extension — Hook Engine Tests (Post-Unit, Pre-Dispatch, State Persistence)
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createTestContext } from "./test-helpers.ts";
+import {
+  checkPostUnitHooks,
+  getActiveHook,
+  resetHookState,
+  isRetryPending,
+  consumeRetryTrigger,
+  resolveHookArtifactPath,
+  runPreDispatchHooks,
+  persistHookState,
+  restoreHookState,
+  clearPersistedHookState,
+  getHookStatus,
+  formatHookStatus,
+  triggerHookManually,
+} from "../post-unit-hooks.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-hook-test-"));
+  mkdirSync(join(base, ".gsd", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 1: Post-Unit Hook Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+// ─── resolveHookArtifactPath ───────────────────────────────────────────────
+
+console.log("\n=== resolveHookArtifactPath ===");
+
+{
+  const base = "/project";
+
+  // Task-level
+  const taskPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-PASS.md");
+  assertEq(
+    taskPath,
+    join(base, ".gsd", "M001", "slices", "S01", "tasks", "T01-REVIEW-PASS.md"),
+    "task-level artifact path",
+  );
+
+  // Slice-level
+  const slicePath = resolveHookArtifactPath(base, "M001/S01", "REVIEW-PASS.md");
+  assertEq(
+    slicePath,
+    join(base, ".gsd", "M001", "slices", "S01", "REVIEW-PASS.md"),
+    "slice-level artifact path",
+  );
+
+  // Milestone-level
+  const milestonePath = resolveHookArtifactPath(base, "M001", "REVIEW-PASS.md");
+  assertEq(
+    milestonePath,
+    join(base, ".gsd", "M001", "REVIEW-PASS.md"),
+    "milestone-level artifact path",
+  );
+}
+
+// ─── resetHookState ────────────────────────────────────────────────────────
+
+console.log("\n=== resetHookState ===");
+
+{
+  resetHookState();
+  assertEq(getActiveHook(), null, "no active hook after reset");
+  assertTrue(!isRetryPending(), "no retry pending after reset");
+  assertEq(consumeRetryTrigger(), null, "no retry trigger after reset");
+}
+
+// ─── checkPostUnitHooks with no hooks configured ───────────────────────────
+
+console.log("\n=== No hooks configured ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assertEq(result, null, "returns null when no hooks configured");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ─── Hook units don't trigger hooks (no hook-on-hook) ──────────────────────
+
+console.log("\n=== Hook-on-hook prevention ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = checkPostUnitHooks("hook/code-review", "M001/S01/T01", base);
+    assertEq(result, null, "hook units don't trigger other hooks");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ─── consumeRetryTrigger clears state ──────────────────────────────────────
+
+console.log("\n=== consumeRetryTrigger clears state ===");
+
+{
+  resetHookState();
+  assertEq(consumeRetryTrigger(), null, "no trigger initially");
+  assertTrue(!isRetryPending(), "no retry initially");
+}
+
+// ─── Variable substitution in prompts ──────────────────────────────────────
+
+console.log("\n=== Variable substitution ===");
+
+{
+  const base = "/project";
+
+  // 3-part ID
+  const path3 = resolveHookArtifactPath(base, "M002/S03/T05", "result.md");
+  assertTrue(path3.includes("M002"), "3-part ID extracts milestoneId");
+  assertTrue(path3.includes("S03"), "3-part ID extracts sliceId");
+  assertTrue(path3.includes("T05"), "3-part ID extracts taskId");
+
+  // 2-part ID
+  const path2 = resolveHookArtifactPath(base, "M002/S03", "result.md");
+  assertTrue(path2.includes("M002"), "2-part ID extracts milestoneId");
+  assertTrue(path2.includes("S03"), "2-part ID extracts sliceId");
+
+  // 1-part ID
+  const path1 = resolveHookArtifactPath(base, "M002", "result.md");
+  assertTrue(path1.includes("M002"), "1-part ID extracts milestoneId");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 2: Pre-Dispatch Hook Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Pre-dispatch: no hooks configured ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    const result = runPreDispatchHooks("execute-task", "M001/S01/T01", "original prompt", base);
+    assertEq(result.action, "proceed", "proceeds when no hooks");
+    assertEq(result.prompt, "original prompt", "prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== Pre-dispatch: hook units bypass ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    const result = runPreDispatchHooks("hook/review", "M001/S01/T01", "hook prompt", base);
+    assertEq(result.action, "proceed", "hook units always proceed");
+    assertEq(result.prompt, "hook prompt", "hook prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired for hook units");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 3: State Persistence Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== State persistence: persist and restore ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Persist empty state
+    persistHookState(base);
+    const filePath = join(base, ".gsd", "hook-state.json");
+    assertTrue(existsSync(filePath), "hook-state.json created");
+
+    const content = JSON.parse(readFileSync(filePath, "utf-8"));
+    assertEq(typeof content.savedAt, "string", "savedAt is a string");
+    assertEq(Object.keys(content.cycleCounts).length, 0, "empty cycle counts");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore from disk ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Write a state file with some cycle counts
+    const stateFile = join(base, ".gsd", "hook-state.json");
+    writeFileSync(stateFile, JSON.stringify({
+      cycleCounts: {
+        "review/execute-task/M001/S01/T01": 2,
+        "simplify/execute-task/M001/S01/T02": 1,
+      },
+      savedAt: new Date().toISOString(),
+    }), "utf-8");
+
+    // Restore
+    restoreHookState(base);
+
+    // Verify by persisting and reading back
+    persistHookState(base);
+    const restored = JSON.parse(readFileSync(stateFile, "utf-8"));
+    assertEq(restored.cycleCounts["review/execute-task/M001/S01/T01"], 2, "cycle count restored for review");
+    assertEq(restored.cycleCounts["simplify/execute-task/M001/S01/T02"], 1, "cycle count restored for simplify");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: clear ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Write then clear
+    const stateFile = join(base, ".gsd", "hook-state.json");
+    writeFileSync(stateFile, JSON.stringify({
+      cycleCounts: { "review/execute-task/M001/S01/T01": 3 },
+      savedAt: new Date().toISOString(),
+    }), "utf-8");
+
+    clearPersistedHookState(base);
+
+    const cleared = JSON.parse(readFileSync(stateFile, "utf-8"));
+    assertEq(Object.keys(cleared.cycleCounts).length, 0, "cycle counts cleared");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore handles missing file ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+    // Should not throw
+    restoreHookState(base);
+    assertEq(getActiveHook(), null, "no active hook after restore from missing file");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore handles corrupt file ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+    writeFileSync(join(base, ".gsd", "hook-state.json"), "not json", "utf-8");
+    // Should not throw
+    restoreHookState(base);
+    assertEq(getActiveHook(), null, "no active hook after corrupt restore");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 3: Hook Status Reporting Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Hook status: no hooks ===");
+
+{
+  resetHookState();
+  const entries = getHookStatus();
+  // No preferences file = no hooks
+  assertEq(entries.length, 0, "no entries when no hooks configured");
+
+  const formatted = formatHookStatus();
+  assertMatch(formatted, /No hooks configured/, "status message says no hooks");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 4: Manual Hook Trigger Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== triggerHookManually: hook not found ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = triggerHookManually("nonexistent-hook", "execute-task", "M001/S01/T01", base);
+    assertEq(result, null, "returns null when hook not found");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== triggerHookManually: with configured hook ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    // This test will work when preferences are configured
+    // For now, just verify the function exists and handles missing hooks
+    const result = triggerHookManually("code-review", "execute-task", "M001/S01/T01", base);
+    // Result depends on whether code-review hook is configured in preferences
+    // The function should either return null or a valid HookDispatchResult
+    assertTrue(result === null || typeof result === "object", "returns null or object");
+    if (result) {
+      assertEq(result.hookName, "code-review", "hook name in result");
+      assertEq(result.unitType, "hook/code-review", "unit type is hook-prefixed");
+      assertEq(result.unitId, "M001/S01/T01", "unit ID preserved");
+      assertTrue(typeof result.prompt === "string", "prompt is a string");
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+report();

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

@@ -0,0 +1,276 @@
+/**
+ * Preferences tests — consolidated from:
+ *   - preferences-git.test.ts (git.isolation, git.merge_to_main)
+ *   - preferences-hooks.test.ts (post-unit + pre-dispatch hook config)
+ *   - preferences-mode.test.ts (solo/team mode defaults, overrides)
+ *   - preferences-models.test.ts (model config parsing, OpenRouter, CRLF)
+ *   - preferences-schema-validation.test.ts (unknown keys, invalid types)
+ *   - preferences-wizard-fields.test.ts (budget, notifications, git, uat)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  validatePreferences,
+  applyModeDefaults,
+  getIsolationMode,
+  parsePreferencesMarkdown,
+} from "../preferences.ts";
+import type { GSDPreferences, GSDModelConfigV2, GSDPhaseModelConfig } from "../preferences.ts";
+
+// ── Git preferences ──────────────────────────────────────────────────────────
+
+test("git.isolation accepts valid values and rejects invalid", () => {
+  for (const val of ["worktree", "branch", "none"] as const) {
+    const { errors, preferences } = validatePreferences({ git: { isolation: val } });
+    assert.equal(errors.length, 0, `isolation ${val}: no errors`);
+    assert.equal(preferences.git?.isolation, val);
+  }
+  const { errors } = validatePreferences({ git: { isolation: "invalid" as any } });
+  assert.ok(errors.length > 0);
+  assert.ok(errors[0].includes("worktree, branch, none"));
+});
+
+test("git.merge_to_main produces deprecation warning", () => {
+  for (const val of ["milestone", "slice"]) {
+    const { warnings } = validatePreferences({ git: { merge_to_main: val } } as any);
+    assert.ok(warnings.length > 0);
+    assert.ok(warnings[0].includes("deprecated"));
+  }
+});
+
+
+test("getIsolationMode defaults to worktree when no prefs file", { skip: "requires no global ~/.gsd/preferences.md" }, () => {
+  assert.equal(getIsolationMode(), "worktree");
+});
+
+// ── Mode defaults ────────────────────────────────────────────────────────────
+
+test("solo mode applies correct defaults", () => {
+  const result = applyModeDefaults("solo", { mode: "solo" });
+  assert.equal(result.git?.auto_push, true);
+  assert.equal(result.git?.push_branches, false);
+  assert.equal(result.git?.pre_merge_check, false);
+  assert.equal(result.git?.merge_strategy, "squash");
+  assert.equal(result.git?.isolation, "worktree");
+  assert.equal(result.unique_milestone_ids, false);
+});
+
+test("team mode applies correct defaults", () => {
+  const result = applyModeDefaults("team", { mode: "team" });
+  assert.equal(result.git?.auto_push, false);
+  assert.equal(result.git?.push_branches, true);
+  assert.equal(result.git?.pre_merge_check, true);
+  assert.equal(result.unique_milestone_ids, true);
+});
+
+test("explicit override wins over mode default", () => {
+  const result = applyModeDefaults("solo", { mode: "solo", git: { auto_push: false } });
+  assert.equal(result.git?.auto_push, false);
+  assert.equal(result.git?.push_branches, false); // default still applies
+});
+
+test("mode: team + explicit unique_milestone_ids override", () => {
+  const result = applyModeDefaults("team", { mode: "team", unique_milestone_ids: false });
+  assert.equal(result.unique_milestone_ids, false);
+  assert.equal(result.git?.push_branches, true); // other defaults still apply
+});
+
+test("invalid mode value produces error", () => {
+  const { errors } = validatePreferences({ mode: "invalid" as any });
+  assert.ok(errors.length > 0);
+  assert.ok(errors[0].includes("solo, team"));
+});
+
+test("valid mode values pass validation", () => {
+  for (const m of ["solo", "team"] as const) {
+    const { errors, preferences } = validatePreferences({ mode: m });
+    assert.equal(errors.length, 0);
+    assert.equal(preferences.mode, m);
+  }
+});
+
+// ── Schema validation ────────────────────────────────────────────────────────
+
+test("unknown keys produce warnings", () => {
+  const { warnings } = validatePreferences({ typo_key: "value" } as any);
+  assert.ok(warnings.some(w => w.includes("typo_key")));
+  assert.ok(warnings.some(w => w.includes("unknown")));
+});
+
+test("known keys produce no unknown-key warnings", () => {
+  const { warnings } = validatePreferences({
+    version: 1, uat_dispatch: true, budget_ceiling: 50, skill_discovery: "auto",
+  });
+  assert.equal(warnings.filter(w => w.includes("unknown")).length, 0);
+});
+
+test("invalid value types produce errors and fall back to undefined", () => {
+  const cases = [
+    { input: { budget_ceiling: "not-a-number" }, field: "budget_ceiling" },
+    { input: { budget_enforcement: "invalid" }, field: "budget_enforcement" },
+    { input: { context_pause_threshold: "not-a-number" }, field: "context_pause_threshold" },
+    { input: { skill_discovery: "invalid-mode" }, field: "skill_discovery" },
+  ];
+  for (const { input, field } of cases) {
+    const { errors, preferences } = validatePreferences(input as any);
+    assert.ok(errors.some(e => e.includes(field)), `${field}: error produced`);
+    assert.equal((preferences as any)[field], undefined, `${field}: falls back to undefined`);
+  }
+});
+
+test("valid values pass through correctly", () => {
+  const { preferences: p1 } = validatePreferences({ budget_enforcement: "halt" });
+  assert.equal(p1.budget_enforcement, "halt");
+
+  const { preferences: p2 } = validatePreferences({ context_pause_threshold: 0.75 });
+  assert.equal(p2.context_pause_threshold, 0.75);
+
+  const { preferences: p3 } = validatePreferences({ auto_supervisor: { model: "claude-opus-4-6" } });
+  assert.equal(p3.auto_supervisor?.model, "claude-opus-4-6");
+});
+
+test("mixed valid/invalid/unknown keys handled correctly", () => {
+  const { preferences, errors, warnings } = validatePreferences({
+    uat_dispatch: true, totally_made_up: "value", budget_ceiling: "garbage",
+  } as any);
+  assert.equal(preferences.uat_dispatch, true);
+  assert.ok(warnings.some(w => w.includes("totally_made_up")));
+  assert.ok(errors.some(e => e.includes("budget_ceiling")));
+  assert.equal(preferences.budget_ceiling, undefined);
+});
+
+// ── Wizard fields ────────────────────────────────────────────────────────────
+
+test("budget fields validate correctly", () => {
+  const { preferences, errors } = validatePreferences({
+    budget_ceiling: 25.50, budget_enforcement: "warn", context_pause_threshold: 80,
+  });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.budget_ceiling, 25.50);
+  assert.equal(preferences.budget_enforcement, "warn");
+  assert.equal(preferences.context_pause_threshold, 80);
+});
+
+test("notification fields validate correctly", () => {
+  const { preferences, errors } = validatePreferences({
+    notifications: { enabled: true, on_complete: false, on_error: true, on_budget: true },
+  });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.notifications?.enabled, true);
+  assert.equal(preferences.notifications?.on_complete, false);
+});
+
+test("git fields comprehensive validation", () => {
+  const { preferences, errors } = validatePreferences({
+    git: {
+      auto_push: true, push_branches: false, remote: "upstream", snapshots: true,
+      pre_merge_check: "auto", commit_type: "feat", main_branch: "develop",
+      merge_strategy: "squash", isolation: "branch",
+    },
+  });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.git?.auto_push, true);
+  assert.equal(preferences.git?.remote, "upstream");
+  assert.equal(preferences.git?.isolation, "branch");
+});
+
+test("all wizard fields together produce no errors", () => {
+  const { errors, warnings } = validatePreferences({
+    version: 1,
+    models: { research: "claude-opus-4-6" },
+    auto_supervisor: { soft_timeout_minutes: 15 },
+    git: { main_branch: "main", auto_push: true, isolation: "worktree" },
+    skill_discovery: "suggest",
+    unique_milestone_ids: false,
+    budget_ceiling: 50, budget_enforcement: "pause", context_pause_threshold: 75,
+    notifications: { enabled: true },
+    uat_dispatch: false,
+  });
+  assert.equal(errors.length, 0);
+  assert.equal(warnings.filter(w => w.includes("unknown")).length, 0);
+});
+
+// ── Hook config ──────────────────────────────────────────────────────────────
+
+test("post-unit hook max_cycles clamping", () => {
+  assert.equal(Math.max(1, Math.min(10, Math.round(15))), 10);
+  assert.equal(Math.max(1, Math.min(10, Math.round(0))), 1);
+  assert.equal(Math.max(1, Math.min(10, Math.round(-5))), 1);
+  assert.equal(Math.max(1, Math.min(10, Math.round(3))), 3);
+});
+
+test("pre-dispatch hook action validation", () => {
+  const valid = new Set(["modify", "skip", "replace"]);
+  assert.ok(valid.has("modify"));
+  assert.ok(valid.has("skip"));
+  assert.ok(valid.has("replace"));
+  assert.ok(!valid.has("delete"));
+});
+
+// ── Model config parsing ─────────────────────────────────────────────────────
+
+test("parses OpenRouter model config with org/model IDs and fallbacks", () => {
+  const content = `---\nversion: 1\nmodels:\n  research:\n    model: moonshotai/kimi-k2.5\n    fallbacks:\n      - qwen/qwen3.5-397b-a17b\n  planning:\n    model: deepseek/deepseek-r1-0528\n    fallbacks:\n      - moonshotai/kimi-k2.5\n      - deepseek/deepseek-v3.2\n  execution:\n    model: qwen/qwen3-coder\n    fallbacks:\n      - qwen/qwen3-coder-next\n---\n`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.ok(prefs);
+  const models = prefs.models as GSDModelConfigV2;
+  const research = models.research as GSDPhaseModelConfig;
+  assert.equal(research.model, "moonshotai/kimi-k2.5");
+  assert.deepEqual(research.fallbacks, ["qwen/qwen3.5-397b-a17b"]);
+  const execution = models.execution as GSDPhaseModelConfig;
+  assert.deepEqual(execution.fallbacks, ["qwen/qwen3-coder-next"]);
+});
+
+test("parses model IDs with colons (OpenRouter :free, :exacto)", () => {
+  const content = `---\nmodels:\n  execution:\n    model: qwen/qwen3-coder\n    fallbacks:\n      - qwen/qwen3-coder:free\n      - qwen/qwen3-coder:exacto\n---\n`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.ok(prefs);
+  const models = prefs.models as GSDModelConfigV2;
+  const execution = models.execution as GSDPhaseModelConfig;
+  assert.deepEqual(execution.fallbacks, ["qwen/qwen3-coder:free", "qwen/qwen3-coder:exacto"]);
+});
+
+test("parses legacy string-per-phase model config", () => {
+  const content = `---\nmodels:\n  research: claude-opus-4-6\n  execution: claude-sonnet-4-6\n---\n`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.ok(prefs);
+  const models = prefs.models as GSDModelConfigV2;
+  assert.equal(models.research, "claude-opus-4-6");
+  assert.equal(models.execution, "claude-sonnet-4-6");
+});
+
+test("strips inline YAML comments from values", () => {
+  const content = `---\nmodels:\n  execution:\n    model: qwen/qwen3-coder  # fast\n    fallbacks:\n      - minimax/minimax-m2.5  # backup\n---\n`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.ok(prefs);
+  const models = prefs.models as GSDModelConfigV2;
+  const execution = models.execution as GSDPhaseModelConfig;
+  assert.equal(execution.model, "qwen/qwen3-coder");
+  assert.deepEqual(execution.fallbacks, ["minimax/minimax-m2.5"]);
+});
+
+test("handles Windows CRLF line endings", () => {
+  const content = "---\r\nmodels:\r\n  execution:\r\n    model: qwen/qwen3-coder\r\n---\r\n";
+  const prefs = parsePreferencesMarkdown(content);
+  assert.ok(prefs);
+  const models = prefs.models as GSDModelConfigV2;
+  const execution = models.execution as GSDPhaseModelConfig;
+  assert.equal(execution.model, "qwen/qwen3-coder");
+});
+
+test("handles model config with explicit provider field", () => {
+  const content = `---\nmodels:\n  execution:\n    model: claude-opus-4-6\n    provider: bedrock\n    fallbacks:\n      - claude-sonnet-4-6\n---\n`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.ok(prefs);
+  const models = prefs.models as GSDModelConfigV2;
+  const execution = models.execution as GSDPhaseModelConfig;
+  assert.equal(execution.model, "claude-opus-4-6");
+  assert.equal(execution.provider, "bedrock");
+});
+
+test("handles empty models config", () => {
+  const prefs = parsePreferencesMarkdown("---\nversion: 1\n---\n");
+  assert.ok(prefs);
+  assert.equal(prefs.models, undefined);
+});