gsd-pi 2.78.0 → 2.78.1-dev.9d08d820b

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));

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 imports cleanupQuickBranch from quick.ts", () => {
+  it("register-hooks.ts loads cleanupQuickBranch from quick.ts", () => {
     assert.ok(
       hooksSource.includes("cleanupQuickBranch"),
       "register-hooks.ts must reference cleanupQuickBranch",
     );
 
-    // Verify it's imported (not just mentioned in a comment)
-    const importMatch = hooksSource.match(
-      /import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/,
-    );
+    // 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["']\)/);
     assert.ok(
       importMatch,
-      "cleanupQuickBranch must be imported from quick module",
+      "cleanupQuickBranch must be loaded from quick module",
     );
   });
 

package/src/resources/extensions/gsd/tests/register-hooks-compaction-checkpoint.test.ts

@@ -0,0 +1,93 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { parseContinue } from "../files.ts";
+import { closeDatabase } from "../gsd-db.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
+
+function createPlanningFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-compact-checkpoint-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    `# M001: Test Milestone
+
+**Vision:** Validate compaction checkpointing.
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+  > After this: Slice is done.
+`,
+  );
+
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    `# S01: Test Slice
+
+**Goal:** Validate planning checkpoint.
+**Demo:** Checkpoint exists after compaction.
+
+## Tasks
+`,
+  );
+
+  return base;
+}
+
+test("register-hooks writes CONTINUE checkpoint during planning phase without active task (#4258)", async (t) => {
+  const base = createPlanningFixtureBase();
+  const originalCwd = process.cwd();
+  process.chdir(base);
+  invalidateStateCache();
+  closeDatabase();
+
+  t.after(() => {
+    invalidateStateCache();
+    closeDatabase();
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const state = await deriveState(base);
+  assert.equal(state.phase, "planning", "fixture should derive planning phase");
+  assert.equal(state.activeMilestone?.id, "M001", "fixture should have active milestone");
+  assert.equal(state.activeSlice?.id, "S01", "fixture should have active slice");
+  assert.equal(state.activeTask, null, "fixture should have no active task");
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const compactHandlers = handlers.get("session_before_compact");
+  assert.ok(compactHandlers && compactHandlers.length > 0, "session_before_compact handler should be registered");
+
+  for (const handler of compactHandlers ?? []) {
+    await handler({});
+  }
+
+  const continuePath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-CONTINUE.md");
+  assert.ok(existsSync(continuePath), "compaction should create slice CONTINUE checkpoint");
+
+  const parsed = parseContinue(readFileSync(continuePath, "utf-8"));
+  assert.equal(parsed.frontmatter.milestone, "M001");
+  assert.equal(parsed.frontmatter.slice, "S01");
+  assert.equal(parsed.frontmatter.task, "none", "planning checkpoint should use non-task placeholder");
+  assert.equal(parsed.frontmatter.status, "compacted");
+  assert.match(parsed.completedWork, /planning phase/i, "completed-work should capture non-executing phase context");
+  assert.match(parsed.nextAction, /slice S01/i, "next action should route resume to the active slice");
+});