gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

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

@@ -5,7 +5,6 @@ import {
   resolveModelForComplexity,
   escalateTier,
   defaultRoutingConfig,
-  resolveModelForTier,
   scoreModel,
   computeTaskRequirements,
   scoreEligibleModels,
@@ -249,172 +248,6 @@ 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", () => {
@@ -446,8 +279,14 @@ test("scoreModel computes weighted average of capability × requirement", () =>
   assert.ok(Math.abs(score - 88.21) < 0.1, `score ${score} should be ~88.21`);
 });
 
-// (Removed duplicate "scoreModel returns 50 for empty requirements" — the
-// `describe("scoreModel")` block below has the same scenario.)
+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);
+});
 
 test("computeTaskRequirements returns base vector for known unit type", () => {
   const reqs = computeTaskRequirements("execute-task");

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

@@ -101,14 +101,6 @@ 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,15 +19,13 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import {
+  persistState,
   restoreState,
   resetOrchestrator,
+  getOrchestratorState,
   type PersistedState,
 } from "../parallel-orchestrator.ts";
-import {
-  writeSessionStatus,
-  readAllSessionStatuses,
-  cleanupStaleSessions,
-} from "../session-status-io.ts";
+import { writeSessionStatus, readAllSessionStatuses, removeSessionStatus } from "../session-status-io.ts";
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function makeTempDir(): string {
@@ -59,20 +57,17 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
 
 describe('parallel-crash-recovery', () => {
-test('Test 1: orchestrator.json round-trips through restoreState (preserves worker fields)', () => {
+test('Test 1: persistState writes valid JSON', () => {
   const basePath = makeTempDir();
   try {
-    // 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.
+    // 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
     const state = makePersistedState({
       workers: [
         {
           milestoneId: "M001",
           title: "M001",
-          pid: process.pid, // alive — survives restoreState's PID filter
+          pid: process.pid,
           worktreePath: "/tmp/wt-M001",
           startedAt: Date.now(),
           state: "running",
@@ -83,13 +78,13 @@ test('Test 1: orchestrator.json round-trips through restoreState (preserves work
     });
     writeStateFile(basePath, state);
 
-    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");
+    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");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
@@ -206,12 +201,11 @@ test('Test 5: restoreState skips stopped/error workers even with alive PIDs', ()
   }
 });
 
-test('Test 6: cleanupStaleSessions removes dead-PID sessions and keeps live ones', () => {
+test('Test 6: orphan detection finds stale sessions', () => {
   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,
@@ -224,7 +218,7 @@ test('Test 6: cleanupStaleSessions removes dead-PID sessions and keeps live ones
       worktreePath: "/tmp/wt-M001",
     });
 
-    // Live PID (this process)
+    // Write a session status with alive PID
     writeSessionStatus(basePath, {
       milestoneId: "M002",
       pid: process.pid,
@@ -237,20 +231,37 @@ test('Test 6: cleanupStaleSessions removes dead-PID sessions and keeps live ones
       worktreePath: "/tmp/wt-M002",
     });
 
+    // Read all sessions — both should exist initially
     const before = readAllSessionStatuses(basePath);
-    assert.deepStrictEqual(before.length, 2, "both sessions exist before cleanup");
+    assert.deepStrictEqual(before.length, 2, "orphan: both sessions exist before detection");
 
-    // 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);
+    // 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);
+      }
+    }
 
-    assert.deepStrictEqual(removed, ["M001"], "dead-PID session id is reported as removed");
+    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");
 
+    // Dead session should be cleaned up
     const after = readAllSessionStatuses(basePath);
-    assert.deepStrictEqual(after.length, 1, "dead session cleaned up");
-    assert.deepStrictEqual(after[0].milestoneId, "M002", "alive session remains");
+    assert.deepStrictEqual(after.length, 1, "orphan: dead session cleaned up");
+    assert.deepStrictEqual(after[0].milestoneId, "M002", "orphan: alive session remains");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }

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

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

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

@@ -236,20 +236,6 @@ 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",
@@ -260,71 +246,6 @@ 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", () => {
@@ -762,54 +683,6 @@ 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,20 +93,4 @@ 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,13 +103,6 @@ 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));

package/src/resources/extensions/gsd/tests/quick-turn-end-cleanup.test.ts

@@ -23,19 +23,19 @@ describe("quick task turn_end cleanup (#2668)", () => {
     "utf-8",
   );
 
-  it("register-hooks.ts loads cleanupQuickBranch from quick.ts", () => {
+  it("register-hooks.ts imports cleanupQuickBranch from quick.ts", () => {
     assert.ok(
       hooksSource.includes("cleanupQuickBranch"),
       "register-hooks.ts must reference cleanupQuickBranch",
     );
 
-    // Verify it is loaded from quick.ts (static or lazy), not just mentioned in a comment.
-    const importMatch =
-      hooksSource.match(/import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/) ||
-      hooksSource.match(/const\s+\{\s*cleanupQuickBranch\s*\}\s*=\s*await\s+import\(["'][^"']*quick\.js["']\)/);
+    // Verify it's imported (not just mentioned in a comment)
+    const importMatch = hooksSource.match(
+      /import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/,
+    );
     assert.ok(
       importMatch,
-      "cleanupQuickBranch must be loaded from quick module",
+      "cleanupQuickBranch must be imported from quick module",
     );
   });