gsd-pi 2.78.0 → 2.78.1-dev.8a893322c

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

@@ -10,7 +10,7 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { _resolveReportBasePath } from "../auto/phases.ts";
+import { _resolveDispatchGuardBasePath, _resolveReportBasePath } from "../auto/phases.ts";
 
 describe("_resolveReportBasePath", () => {
   test("uses originalBasePath when set (worktree scenario)", () => {
@@ -48,4 +48,21 @@ describe("_resolveReportBasePath", () => {
 
     assert.equal(_resolveReportBasePath(session), "/home/user/repo");
   });
+
+  test("uses GSD_PROJECT_ROOT for symlink-resolved worktree paths", () => {
+    const savedProjectRoot = process.env.GSD_PROJECT_ROOT;
+    process.env.GSD_PROJECT_ROOT = "/real/project";
+    try {
+      const session = {
+        originalBasePath: "",
+        basePath: "/Users/dev/.gsd/projects/abc123/worktrees/M001/slices/S01",
+      };
+
+      assert.equal(_resolveReportBasePath(session), "/real/project");
+      assert.equal(_resolveDispatchGuardBasePath(session), "/real/project");
+    } finally {
+      if (savedProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+      else process.env.GSD_PROJECT_ROOT = savedProjectRoot;
+    }
+  });
 });

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

@@ -5,6 +5,7 @@ import {
   resolveModelForComplexity,
   escalateTier,
   defaultRoutingConfig,
+  resolveModelForTier,
   scoreModel,
   computeTaskRequirements,
   scoreEligibleModels,
@@ -248,6 +249,172 @@ test("#2192: known model is still downgraded normally", () => {
   assert.notEqual(result.modelId, "claude-opus-4-6");
 });
 
+// ─── Cross-provider fallback ──────────────────────────────────────────────────
+
+test("uses cross-provider equivalent when configured primary is unavailable", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  // Profile default says claude-opus-4-6 for planning, but user is on GPT only
+  const result = resolveModelForComplexity(
+    makeClassification("heavy"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["gpt-4o", "gpt-4o-mini", "o1"],
+  );
+  // o1 is the heavy-tier GPT model — should be selected as cross-provider equivalent
+  assert.equal(result.modelId, "o1");
+  assert.equal(result.wasDowngraded, false);
+  assert.match(result.reason, /cross-provider/);
+});
+
+test("cross-provider: selects standard-tier equivalent when primary unavailable", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  // Planning configured with Opus, but only GPT standard models available
+  const result = resolveModelForComplexity(
+    makeClassification("heavy"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["gpt-4o", "gpt-4o-mini"],
+  );
+  // gpt-4o is standard tier, not heavy — no heavy-tier model available
+  // Should fall back to gpt-4o (best available)
+  assert.ok(result.modelId === "gpt-4o" || result.modelId === "claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
+test("cross-provider: configured primary available by bare ID wins over equivalent", () => {
+  const config = { ...defaultRoutingConfig(), enabled: true };
+  // Provider-prefixed ID — bare match should find it
+  const result = resolveModelForComplexity(
+    makeClassification("heavy"),
+    { primary: "claude-opus-4-6", fallbacks: [] },
+    config,
+    ["anthropic/claude-opus-4-6", "o1"],
+  );
+  assert.equal(result.modelId, "claude-opus-4-6");
+  assert.equal(result.wasDowngraded, false);
+});
+
+// ─── resolveModelForTier (provider-agnostic tier resolution) ────────────────
+
+test("resolveModelForTier: returns canonical Anthropic model when no available models", () => {
+  assert.equal(resolveModelForTier("heavy", []), "claude-opus-4-6");
+  assert.equal(resolveModelForTier("standard", []), "claude-sonnet-4-6");
+  assert.equal(resolveModelForTier("light", []), "claude-haiku-4-5");
+});
+
+test("resolveModelForTier: returns canonical model when it is available", () => {
+  assert.equal(
+    resolveModelForTier("heavy", ["claude-opus-4-6", "claude-sonnet-4-6"]),
+    "claude-opus-4-6",
+  );
+});
+
+test("resolveModelForTier: does not prefer canonical over cheaper same-tier model", () => {
+  const result = resolveModelForTier("light", ["claude-haiku-4-5", "gpt-4o-mini"]);
+  assert.equal(result, "gpt-4o-mini");
+});
+
+test("resolveModelForTier: honors configured tier_models pins", () => {
+  const config: DynamicRoutingConfig = {
+    ...defaultRoutingConfig(),
+    tier_models: { light: "claude-haiku-4-5" },
+  };
+  const result = resolveModelForTier("light", ["claude-haiku-4-5", "gpt-4o-mini"], config);
+  assert.equal(result, "claude-haiku-4-5");
+});
+
+test("resolveModelForTier: picks cross-provider equivalent when Anthropic unavailable", () => {
+  // Only OpenAI models available
+  const result = resolveModelForTier("heavy", ["gpt-4o", "gpt-4o-mini", "o1"]);
+  // o1 is the heavy-tier model in the OpenAI lineup
+  assert.equal(result, "o1");
+});
+
+test("resolveModelForTier: picks standard-tier cross-provider model", () => {
+  const result = resolveModelForTier("standard", ["gpt-4o", "gpt-4o-mini"]);
+  assert.equal(result, "gpt-4o");
+});
+
+test("resolveModelForTier: picks light-tier cross-provider model", () => {
+  const result = resolveModelForTier("light", ["gpt-4o", "gpt-4o-mini"]);
+  assert.equal(result, "gpt-4o-mini");
+});
+
+test("resolveModelForTier: falls back to canonical when no tier match available", () => {
+  // Only unknown models available — getModelTier classifies unknowns as
+  // "standard", so a request for "heavy" finds no match and the canonical
+  // Anthropic ID is returned as a documented fallback.
+  const result = resolveModelForTier("heavy", ["some-custom-model"]);
+  assert.equal(result, "claude-opus-4-6");
+});
+
+test("resolveModelForTier: handles provider-prefixed available models", () => {
+  const result = resolveModelForTier("heavy", ["anthropic/claude-opus-4-6"]);
+  assert.equal(result, "claude-opus-4-6");
+});
+
+test("resolveModelForTier: picks Gemini models when only Google available", () => {
+  const result = resolveModelForTier("light", ["gemini-2.5-pro", "gemini-2.0-flash"]);
+  assert.equal(result, "gemini-2.0-flash");
+});
+
+// ─── Behavioral: profile defaults are provider-agnostic at runtime ──────────
+
+test("resolveProfileDefaults: balanced with only OpenAI models returns OpenAI IDs", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults("balanced", ["gpt-4o", "gpt-4o-mini"]);
+  assert.ok(defaults.models, "balanced should populate models");
+  // All slots must resolve to an available OpenAI ID — not a claude- canonical.
+  for (const [phase, modelId] of Object.entries(defaults.models!)) {
+    assert.ok(typeof modelId === "string" && modelId.length > 0, `${phase} should resolve to a model ID`);
+    assert.ok(
+      !String(modelId).startsWith("claude-"),
+      `${phase} resolved to ${modelId} but no claude-* model is available — should be OpenAI`,
+    );
+  }
+});
+
+test("resolveProfileDefaults: budget with only OpenAI models picks gpt-4o-mini for light slots", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults("budget", ["gpt-4o", "gpt-4o-mini"]);
+  // light-tier slots in budget: research, execution_simple, completion, subagent
+  assert.equal(defaults.models?.research, "gpt-4o-mini");
+  assert.equal(defaults.models?.execution_simple, "gpt-4o-mini");
+  assert.equal(defaults.models?.completion, "gpt-4o-mini");
+  assert.equal(defaults.models?.subagent, "gpt-4o-mini");
+  // standard-tier slots: planning, execution
+  assert.equal(defaults.models?.planning, "gpt-4o");
+  assert.equal(defaults.models?.execution, "gpt-4o");
+});
+
+test("resolveProfileDefaults: honors dynamic routing tier_models pins", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults(
+    "budget",
+    ["claude-haiku-4-5", "gpt-4o-mini", "gpt-4o"],
+    { ...defaultRoutingConfig(), tier_models: { light: "claude-haiku-4-5" } },
+  );
+  assert.equal(defaults.models?.research, "claude-haiku-4-5");
+  assert.equal(defaults.models?.execution_simple, "claude-haiku-4-5");
+  assert.equal(defaults.models?.completion, "claude-haiku-4-5");
+  assert.equal(defaults.models?.subagent, "claude-haiku-4-5");
+});
+
+test("resolveProfileDefaults: empty availableModelIds falls back to canonical Anthropic IDs", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults("balanced", []);
+  // Documented fallback only — when registry is unavailable at bootstrap.
+  const planningModel = defaults.models?.planning;
+  assert.ok(typeof planningModel === "string" && planningModel.startsWith("claude-"));
+});
+
+test("resolveProfileDefaults: burn-max omits models so user choice is preserved", async () => {
+  const { resolveProfileDefaults } = await import("../preferences-models.js");
+  const defaults = resolveProfileDefaults("burn-max", ["gpt-4o"]);
+  assert.equal(defaults.models, undefined, "burn-max must not write model defaults");
+  assert.equal(defaults.dynamic_routing?.enabled, false);
+});
+
 // ─── Capability Scoring (ADR-004 Phase 2) ───────────────────────────────────
 
 test("defaultRoutingConfig includes capability_routing: true", () => {
@@ -279,14 +446,8 @@ test("scoreModel computes weighted average of capability × requirement", () =>
   assert.ok(Math.abs(score - 88.21) < 0.1, `score ${score} should be ~88.21`);
 });
 
-test("scoreModel returns 50 for empty requirements", () => {
-  const caps: ModelCapabilities = {
-    coding: 90, debugging: 80, research: 70,
-    reasoning: 85, speed: 50, longContext: 60, instruction: 75,
-  };
-  const score = scoreModel(caps, {});
-  assert.equal(score, 50);
-});
+// (Removed duplicate "scoreModel returns 50 for empty requirements" — the
+// `describe("scoreModel")` block below has the same scenario.)
 
 test("computeTaskRequirements returns base vector for known unit type", () => {
   const reqs = computeTaskRequirements("execute-task");

package/src/resources/extensions/gsd/tests/native-git-infra-errors.test.ts

@@ -0,0 +1,50 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { git } from "./test-utils.ts";
+import { GSD_GIT_ERROR } from "../errors.js";
+
+test("nativeAddAllWithExclusions preserves infrastructure failures from git add", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-native-git-infra-"));
+  const repo = join(base, "repo");
+  const bin = join(base, "bin");
+  mkdirSync(repo);
+  mkdirSync(bin);
+
+  const fakeGit = join(bin, "git");
+  writeFileSync(
+    fakeGit,
+    "#!/bin/sh\n" +
+      "echo 'fatal: ENFILE: file table overflow' >&2\n" +
+      "exit 1\n",
+    "utf-8",
+  );
+  chmodSync(fakeGit, 0o755);
+
+  const originalPath = process.env.PATH ?? "";
+  try {
+    git(repo, "init");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "Test User");
+    writeFileSync(join(repo, "README.md"), "# Test\n", "utf-8");
+
+    process.env.PATH = `${bin}:${originalPath}`;
+    const { nativeAddAllWithExclusions } = await import("../native-git-bridge.ts");
+
+    assert.throws(
+      () => nativeAddAllWithExclusions(repo, [".gsd/activity/"]),
+      (err) => {
+        const shaped = err as { code?: string; stderr?: string; message?: string };
+        assert.notEqual(shaped.code, GSD_GIT_ERROR);
+        assert.match(`${shaped.stderr ?? ""}${shaped.message ?? ""}`, /ENFILE/);
+        return true;
+      },
+    );
+  } finally {
+    process.env.PATH = originalPath;
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/orphaned-worktree-audit.test.ts

@@ -101,6 +101,14 @@ describe("auditOrphanedMilestoneBranches", () => {
       result.warnings.some(w => w.includes("NOT merged")),
       "should warn about unmerged branch",
     );
+    assert.ok(
+      result.warnings.some(w => w.includes("/gsd doctor fix")),
+      `warning should suggest the real remediation command; got: ${JSON.stringify(result.warnings)}`,
+    );
+    assert.ok(
+      result.warnings.every(w => !w.includes("/gsd health --fix")),
+      `warning must not suggest the removed health --fix command; got: ${JSON.stringify(result.warnings)}`,
+    );
 
     // Branch should still exist (data safety)
     const branches = run("git branch --list milestone/M001", dir);

package/src/resources/extensions/gsd/tests/parallel-crash-recovery.test.ts

@@ -19,13 +19,15 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
-  persistState,
   restoreState,
   resetOrchestrator,
-  getOrchestratorState,
   type PersistedState,
 } from "../parallel-orchestrator.ts";
-import { writeSessionStatus, readAllSessionStatuses, removeSessionStatus } from "../session-status-io.ts";
+import {
+  writeSessionStatus,
+  readAllSessionStatuses,
+  cleanupStaleSessions,
+} from "../session-status-io.ts";
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function makeTempDir(): string {
@@ -57,17 +59,20 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
 
 describe('parallel-crash-recovery', () => {
-test('Test 1: persistState writes valid JSON', () => {
+test('Test 1: orchestrator.json round-trips through restoreState (preserves worker fields)', () => {
   const basePath = makeTempDir();
   try {
-    // We can't call persistState directly without internal state set up,
-    // so we test the round-trip by writing a state file and reading it back
+    // Write a full state file to disk and then exercise the real production
+    // restoreState() reader against it. This verifies the persisted file
+    // schema (the contract between persistState's writer and the reader)
+    // — earlier this test inlined a test-only writer and re-parsed JSON,
+    // bypassing production code entirely.
     const state = makePersistedState({
       workers: [
         {
           milestoneId: "M001",
           title: "M001",
-          pid: process.pid,
+          pid: process.pid, // alive — survives restoreState's PID filter
           worktreePath: "/tmp/wt-M001",
           startedAt: Date.now(),
           state: "running",
@@ -78,13 +83,13 @@ test('Test 1: persistState writes valid JSON', () => {
     });
     writeStateFile(basePath, state);
 
-    const raw = readFileSync(stateFilePath(basePath), "utf-8");
-    const parsed = JSON.parse(raw) as PersistedState;
-    assert.deepStrictEqual(parsed.active, true, "persistState: active field preserved");
-    assert.deepStrictEqual(parsed.workers.length, 1, "persistState: worker count preserved");
-    assert.deepStrictEqual(parsed.workers[0].milestoneId, "M001", "persistState: milestoneId preserved");
-    assert.deepStrictEqual(parsed.workers[0].cost, 0.15, "persistState: cost preserved");
-    assert.deepStrictEqual(parsed.totalCost, 0.15, "persistState: totalCost preserved");
+    const restored = restoreState(basePath);
+    assert.ok(restored !== null, "restoreState: returns state for live worker");
+    assert.deepStrictEqual(restored!.active, true, "active field preserved through round-trip");
+    assert.deepStrictEqual(restored!.workers.length, 1, "worker count preserved");
+    assert.deepStrictEqual(restored!.workers[0].milestoneId, "M001", "milestoneId preserved");
+    assert.deepStrictEqual(restored!.workers[0].cost, 0.15, "cost preserved");
+    assert.deepStrictEqual(restored!.totalCost, 0.15, "totalCost preserved");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
@@ -201,11 +206,12 @@ test('Test 5: restoreState skips stopped/error workers even with alive PIDs', ()
   }
 });
 
-test('Test 6: orphan detection finds stale sessions', () => {
+test('Test 6: cleanupStaleSessions removes dead-PID sessions and keeps live ones', () => {
   const basePath = makeTempDir();
   try {
-    // Write a session status with a dead PID
     mkdirSync(join(basePath, ".gsd", "parallel"), { recursive: true });
+
+    // Dead PID
     writeSessionStatus(basePath, {
       milestoneId: "M001",
       pid: 99999999,
@@ -218,7 +224,7 @@ test('Test 6: orphan detection finds stale sessions', () => {
       worktreePath: "/tmp/wt-M001",
     });
 
-    // Write a session status with alive PID
+    // Live PID (this process)
     writeSessionStatus(basePath, {
       milestoneId: "M002",
       pid: process.pid,
@@ -231,37 +237,20 @@ test('Test 6: orphan detection finds stale sessions', () => {
       worktreePath: "/tmp/wt-M002",
     });
 
-    // Read all sessions — both should exist initially
     const before = readAllSessionStatuses(basePath);
-    assert.deepStrictEqual(before.length, 2, "orphan: both sessions exist before detection");
+    assert.deepStrictEqual(before.length, 2, "both sessions exist before cleanup");
 
-    // Now simulate orphan detection logic (same as prepareParallelStart)
-    const sessions = readAllSessionStatuses(basePath);
-    const orphans: Array<{ milestoneId: string; pid: number; alive: boolean }> = [];
-    for (const session of sessions) {
-      let alive: boolean;
-      try {
-        process.kill(session.pid, 0);
-        alive = true;
-      } catch {
-        alive = false;
-      }
-      orphans.push({ milestoneId: session.milestoneId, pid: session.pid, alive });
-      if (!alive) {
-        removeSessionStatus(basePath, session.milestoneId);
-      }
-    }
+    // Drive the real production cleanup function. Earlier this test
+    // re-implemented the cleanup loop inline (process.kill + remove*) and
+    // never exercised cleanupStaleSessions itself — so changes to the
+    // production sweep would not have been caught.
+    const removed = cleanupStaleSessions(basePath);
 
-    assert.ok(orphans.length === 2, "orphan: detected both sessions");
-    const deadOrphan = orphans.find(o => o.milestoneId === "M001");
-    assert.ok(deadOrphan !== undefined && !deadOrphan.alive, "orphan: M001 detected as dead");
-    const aliveOrphan = orphans.find(o => o.milestoneId === "M002");
-    assert.ok(aliveOrphan !== undefined && aliveOrphan.alive, "orphan: M002 detected as alive");
+    assert.deepStrictEqual(removed, ["M001"], "dead-PID session id is reported as removed");
 
-    // Dead session should be cleaned up
     const after = readAllSessionStatuses(basePath);
-    assert.deepStrictEqual(after.length, 1, "orphan: dead session cleaned up");
-    assert.deepStrictEqual(after[0].milestoneId, "M002", "orphan: alive session remains");
+    assert.deepStrictEqual(after.length, 1, "dead session cleaned up");
+    assert.deepStrictEqual(after[0].milestoneId, "M002", "alive session remains");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/phases-merge-error-stops-auto.test.ts

@@ -18,20 +18,14 @@ const phasesSrc = readFileSync(phasesPath, "utf-8");
 
 console.log("\n=== #2766: Non-MergeConflictError stops auto mode ===");
 
-// ── Test 1: phases.ts calls logError for non-conflict merge errors ──────
-
-assertTrue(
-  phasesPath.length > 0 && phasesPath.endsWith("phases.ts"),
-  "phases.ts file exists and is readable",
-);
+// ── Test 1: every mergeAndExit call site has a catch (mergeErr) block ──
 
 // Count all mergeAndExit catch blocks by finding "} catch (mergeErr)" patterns
-const mergeErrCatches = [...phasesPath.matchAll(/\} catch \(mergeErr\)/g)];
-// Use the source itself for matching
+const mergeAndExitCallCount = [...phasesSrc.matchAll(/\.mergeAndExit\(/g)].length;
 const mergeErrCatchCount = [...phasesSrc.matchAll(/\} catch \(mergeErr\)/g)].length;
 assertTrue(
-  mergeErrCatchCount >= 3,
-  `all mergeAndExit call sites have catch (mergeErr) blocks (found ${mergeErrCatchCount}, expected >= 3)`,
+  mergeErrCatchCount === mergeAndExitCallCount && mergeAndExitCallCount > 0,
+  `every mergeAndExit call site has a catch (mergeErr) block (calls=${mergeAndExitCallCount}, catches=${mergeErrCatchCount})`,
 );
 
 // ── Test 2: Every mergeErr catch block handles non-MergeConflictError ───

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

@@ -236,6 +236,20 @@ test("valid values pass through correctly", () => {
   assert.equal(p3.auto_supervisor?.model, "claude-opus-4-6");
 });
 
+test("min_request_interval_ms floors decimals and rejects timer overflow values", () => {
+  const valid = validatePreferences({ min_request_interval_ms: 1000.9 });
+  assert.equal(valid.errors.length, 0);
+  assert.equal(valid.preferences.min_request_interval_ms, 1000);
+
+  const max = validatePreferences({ min_request_interval_ms: 2_147_483_647 });
+  assert.equal(max.errors.length, 0);
+  assert.equal(max.preferences.min_request_interval_ms, 2_147_483_647);
+
+  const tooHigh = validatePreferences({ min_request_interval_ms: 2_147_483_648 });
+  assert.ok(tooHigh.errors.some(e => e.includes("min_request_interval_ms must be a non-negative number <= 2147483647")));
+  assert.equal(tooHigh.preferences.min_request_interval_ms, undefined);
+});
+
 test("mixed valid/invalid/unknown keys handled correctly", () => {
   const { preferences, errors, warnings } = validatePreferences({
     uat_dispatch: true, totally_made_up: "value", budget_ceiling: "garbage",
@@ -246,6 +260,71 @@ test("mixed valid/invalid/unknown keys handled correctly", () => {
   assert.equal(preferences.budget_ceiling, undefined);
 });
 
+test("disabled_model_providers validates and normalizes string arrays", () => {
+  const { preferences, errors } = validatePreferences({
+    disabled_model_providers: ["google-gemini-cli", "  google-gemini-cli  ", "openai-codex", "   "],
+  });
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.disabled_model_providers, ["google-gemini-cli", "openai-codex"]);
+});
+
+test("disabled_model_providers rejects non-array values", () => {
+  const { errors } = validatePreferences({ disabled_model_providers: "google-gemini-cli" as any });
+  assert.ok(errors.some((e) => e.includes("disabled_model_providers must be an array of strings")));
+});
+
+test("loadEffectiveGSDPreferences preserves disabled_model_providers across merge layers", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-disabled-provider-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-disabled-provider-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempGsdHome, "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "disabled_model_providers:",
+        "  - google-gemini-cli",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "disabled_model_providers:",
+        "  - openai-codex",
+        "  - google-gemini-cli",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.deepEqual(
+      loaded!.preferences.disabled_model_providers,
+      ["google-gemini-cli", "openai-codex"],
+    );
+  } finally {
+    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 });
+  }
+});
+
 // ── Wizard fields ────────────────────────────────────────────────────────────
 
 test("budget fields validate correctly", () => {
@@ -683,6 +762,54 @@ test("loadEffectiveGSDPreferences exposes slice_parallel prefs to runtime caller
   }
 });
 
+test("loadEffectiveGSDPreferences merges min_request_interval_ms with project overriding global (#2996)", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-rate-limit-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-rate-limit-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempGsdHome, "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "min_request_interval_ms: 250",
+        "budget_ceiling: 45",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "min_request_interval_ms: 100",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.min_request_interval_ms, 100);
+    assert.equal(loaded!.preferences.budget_ceiling, 45);
+  } finally {
+    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 });
+  }
+});
+
 test("preferences paths use canonical uppercase filenames", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -93,4 +93,20 @@ describe('register-hooks session_before_compact (#3696)', () => {
       'session_before_compact should not check isAutoPaused',
     );
   });
+
+  test('session_before_compact does not gate checkpointing to executing phase (#4258)', () => {
+    const compactIdx = registerHooksSrc.indexOf('session_before_compact');
+    assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
+
+    const preCheckpointSection = registerHooksSrc.slice(
+      compactIdx,
+      registerHooksSrc.indexOf('const sliceDir', compactIdx),
+    );
+
+    const normalized = preCheckpointSection.replace(/\/\/.*$/gm, '');
+    assert.ok(
+      !/if\s*\(\s*state\.phase\s*!==\s*['"]executing['"]\s*\)\s*\{?\s*return\b/.test(normalized),
+      'session_before_compact should not early-return on non-executing phases',
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -103,6 +103,13 @@ test("classifyError detects Codex server_error from extracted message", () => {
   assert.ok("retryAfterMs" in result && result.retryAfterMs === 30_000);
 });
 
+test("classifyError detects stream INTERNAL_ERROR received from peer as transient server", () => {
+  const result = classifyError("stream error: stream ID 75; INTERNAL_ERROR; received from peer");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "server");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs === 30_000);
+});
+
 test("classifyError detects overloaded error", () => {
   const result = classifyError("overloaded_error: Overloaded");
   assert.ok(isTransient(result));