gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.b0acf17e9

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

@@ -7,20 +7,17 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
-import { MAX_TRANSIENT_AUTO_RESUMES } from "../bootstrap/agent-end-recovery.ts";
+import { MAX_TRANSIENT_AUTO_RESUMES, resetTransientRetryState } from "../bootstrap/agent-end-recovery.ts";
+import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
 // barrel to avoid pulling the full AgentSession / @gsd/pi-ai dep graph into
 // this unit test (see #4837).
 import { RETRYABLE_ERROR_RE } from "../../../../../packages/pi-coding-agent/src/core/retryable-error-regex.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import { streamOpenAICodexResponses } from "../../../../../packages/pi-ai/src/providers/openai-codex-responses.ts";
 
 // ── classifyError ────────────────────────────────────────────────────────────
 
@@ -518,172 +515,73 @@ test("resumeAutoAfterProviderDelay resets provider retry state without clearing
   ]);
 });
 
-// ── Escalating backoff for transient errors (#1166) ─────────────────────────
-
-test("agent-end-recovery.ts tracks consecutive transient errors for escalating backoff", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-
-  assert.ok(
-    src.includes("consecutiveTransientCount"),
-    "agent-end-recovery.ts must track consecutiveTransientCount for escalating backoff (#1166)",
-  );
-  assert.ok(
-    src.includes("MAX_TRANSIENT_AUTO_RESUMES"),
-    "agent-end-recovery.ts must define MAX_TRANSIENT_AUTO_RESUMES to cap infinite retries (#1166)",
-  );
-});
-
-test("agent-end-recovery.ts resets retry state before resolveAgentEnd on success", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-
-  // After successful agent_end, resetRetryState must be called before resolveAgentEnd.
-  assert.ok(
-    /resetRetryState[\s\S]{0,250}resolveAgentEnd/.test(src),
-    "resetRetryState must be called before resolveAgentEnd on the success path (#1166)",
-  );
-});
-
-test("agent-end-recovery.ts applies escalating delay for repeated transient errors", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+// ── Provider recovery behavior (#1166 / #2813 / #4373) ─────────────────────
 
-  // Must contain the exponential backoff formula (may span multiple lines)
-  assert.ok(
-    src.includes("2 ** Math.max(0, retryState.consecutiveTransientCount"),
-    "agent-end-recovery.ts must escalate retryAfterMs exponentially for consecutive transient errors (#1166)",
-  );
+test("resetTransientRetryState is callable by resume recovery", () => {
+  resetTransientRetryState();
+  assert.equal(classifyError("stream_exhausted_without_result").kind, "connection");
 });
 
-test("agent-end-recovery.ts resumes transient provider pauses through startAuto instead of a hidden prompt", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-
-  assert.ok(
-    src.includes("resumeAutoAfterProviderDelay"),
-    "agent-end-recovery.ts must resume paused auto-mode through resumeAutoAfterProviderDelay (#2813)",
-  );
-  assert.ok(
-    !src.includes('Continue execution — provider error recovery delay elapsed.'),
-    "transient provider resume must not rely on a hidden continue prompt (#2813)",
-  );
-});
-
-test("agent-end-recovery.ts does not defer rate-limit errors to core retry handler before fallback (#4373)", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-  assert.ok(
-    src.includes('if (isTransient(cls) && cls.kind !== "rate-limit")'),
-    "rate-limit errors must bypass transient core-retry deferral so fallback can execute (#4373)",
-  );
-});
-
-test("agent-end-recovery.ts updates dashboard dispatched model after fallback switch", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-  assert.ok(
-    src.includes("setCurrentDispatchedModelId"),
-    "agent-end-recovery.ts should update currentDispatchedModelId when recovery switches model",
-  );
-});
-
-// ── Codex error extraction (#1166) ──────────────────────────────────────────
-
-test("openai-codex-responses.ts extracts nested error fields", () => {
-  const codexSource = readFileSync(
-    join(__dirname, "../../../../../packages/pi-ai/src/providers/openai-codex-responses.ts"),
-    "utf-8",
-  );
-
-  // Must access event.error.message (nested), not just event.message (top-level)
-  assert.ok(
-    codexSource.includes("errorObj?.message"),
-    "mapCodexEvents must extract message from nested event.error object (#1166)",
-  );
-  assert.ok(
-    codexSource.includes("errorObj?.type"),
-    "mapCodexEvents must extract type from nested event.error object (#1166)",
-  );
-});
-
-// ── Fix 1: resetTransientRetryState resets module-level singleton ────────────
-
-test("resetTransientRetryState is exported from agent-end-recovery.ts", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-  assert.ok(
-    src.includes("export function resetTransientRetryState"),
-    "agent-end-recovery.ts must export resetTransientRetryState for provider-error-resume.ts",
+test("cancelled unit stop reason differentiates session startup failures", () => {
+  assert.deepEqual(
+    _buildCancelledUnitStopReason("plan-slice", "S01", {
+      category: "session-failed",
+      message: "Session creation timed out",
+    }),
+    {
+      notifyMessage: "Session creation failed for plan-slice S01: Session creation timed out. Stopping auto-mode.",
+      stopReason: "Session creation failed: Session creation timed out",
+      loopReason: "session-failed",
+    },
   );
-});
-
-// ── Fix 2: Session creation timeout treated as transient in phases.ts ───────
-
-test("phases.ts handles timeout session-creation failures with pause instead of stopAuto", () => {
-  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
 
-  // The cancelled + isTransient session-start path must pause, not hard-stop
-  assert.ok(
-    src.includes('errorCategory === "timeout"'),
-    "phases.ts must check errorCategory === 'timeout' on transient cancelled unitResults",
-  );
-  assert.ok(
-    src.includes('errorCategory === "session-failed"'),
-    "phases.ts must also check errorCategory === 'session-failed' on transient cancelled unitResults",
-  );
-  // Must call pauseAuto or pauseAutoForProviderError (not stopAuto) for timeout cancellations
-  assert.ok(
-    /errorCategory === "timeout"[\s\S]{0,1800}pauseAuto/.test(src),
-    "phases.ts must call pauseAuto for session-timeout failures (not stopAuto or continue)",
-  );
-  assert.ok(
-    /errorCategory === "session-failed"[\s\S]{0,700}pauseAuto/.test(src),
-    "phases.ts must call pauseAuto for transient session-start failures (not stopAuto or continue)",
-  );
-  // Must NOT use action: "continue" for transient cancellations (causes infinite loops)
-  assert.ok(
-    !/isTransient[\s\S]{0,500}action:\s*"continue"/.test(src),
-    "phases.ts must NOT return action:continue for cancelled units — use break+pause instead",
+  assert.deepEqual(
+    _buildCancelledUnitStopReason("execute-task", "T01", {
+      category: "aborted",
+      message: "Request aborted by user",
+    }),
+    {
+      notifyMessage: "Unit execute-task T01 aborted after dispatch: Request aborted by user. Stopping auto-mode.",
+      stopReason: "Unit aborted: Request aborted by user",
+      loopReason: "unit-aborted",
+    },
   );
 });
 
-// ── Fix 2b: Session creation timeout schedules auto-resume timer ─────────────
+test("openai-codex response stream surfaces nested error type and message", async () => {
+  const originalFetch = globalThis.fetch;
+  const tokenPayload = Buffer.from(JSON.stringify({
+    "https://api.openai.com/auth": { chatgpt_account_id: "acct-test" },
+  })).toString("base64");
+  const apiKey = `header.${tokenPayload}.signature`;
+  globalThis.fetch = (async () => new Response(
+    'data: {"type":"error","error":{"type":"server_error","code":"server_error","message":"upstream failed"}}\n\n',
+    { status: 200, headers: { "content-type": "text/event-stream" } },
+  )) as typeof fetch;
 
-test("phases.ts schedules auto-resume timer for session creation timeouts", () => {
-  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
-
-  // Must use pauseAutoForProviderError (not bare pauseAuto) for session-timeout
-  assert.ok(
-    src.includes("pauseAutoForProviderError"),
-    "phases.ts must use pauseAutoForProviderError for session-timeout auto-resume",
-  );
-  // Must schedule resume via resumeAutoAfterProviderDelay
-  assert.ok(
-    src.includes("resumeAutoAfterProviderDelay"),
-    "phases.ts must schedule resume via resumeAutoAfterProviderDelay",
-  );
-  // Must track consecutive session timeouts
-  assert.ok(
-    src.includes("consecutiveSessionTimeouts"),
-    "phases.ts must track consecutive session timeouts for escalating backoff",
-  );
-  // Must cap session timeout auto-resumes
-  assert.ok(
-    /MAX_SESSION_TIMEOUT_AUTO_RESUMES\s*=\s*\d+/.test(src),
-    "phases.ts must cap session timeout auto-resumes",
-  );
-});
+  try {
+    const stream = streamOpenAICodexResponses(
+      {
+        provider: "openai-codex-responses",
+        id: "gpt-5.1-codex",
+        baseUrl: "https://codex.example.test",
+      } as any,
+      { messages: [], systemPrompt: "", tools: [] } as any,
+      { apiKey } as any,
+    );
 
-test("phases.ts differentiates session creation timeout from unit hard timeout", () => {
-  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
-  assert.ok(
-    src.includes("Session creation timed out"),
-    "phases.ts must check for 'Session creation timed out' message to differentiate from unit hard timeout",
-  );
-});
+    const events = [];
+    for await (const event of stream) {
+      events.push(event);
+    }
 
-test("phases.ts resets session timeout counter on successful unit completion", () => {
-  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
-  const resetIdx = src.indexOf("consecutiveSessionTimeouts = 0");
-  const closeoutIdx = src.indexOf("closeoutUnit");
-  assert.ok(
-    resetIdx !== -1 && closeoutIdx !== -1 && resetIdx < closeoutIdx,
-    "consecutiveSessionTimeouts must reset before closeoutUnit (on success path)",
-  );
+    const errorEvent = events.find((event) => event.type === "error");
+    assert.ok(errorEvent, "stream should emit an error event");
+    assert.equal(errorEvent.error.errorMessage, "Codex server_error: upstream failed");
+    assert.equal(classifyError(errorEvent.error.errorMessage).kind, "server");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
 });
 
 // ── Fix 3: MAX_TRANSIENT_AUTO_RESUMES raised to 8 ───────────────────────────

package/src/resources/extensions/gsd/tests/query-tools-db-open.test.ts

@@ -6,42 +6,46 @@
  * The fix imports ensureDbOpen from dynamic-tools and calls it before
  * querying the DB.
  *
- * This structural test verifies the ensureDbOpen import and usage exist
- * in query-tools.ts.
+ * This behavior test registers the query tool and executes it against a
+ * temp workspace where the DB must be opened on demand.
  */
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'bootstrap', 'query-tools.ts'), 'utf-8');
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { closeDatabase, insertMilestone, openDatabase } from '../gsd-db.ts';
+import { registerQueryTools } from '../bootstrap/query-tools.ts';
 
 describe('query-tools ensureDbOpen usage (#3672)', () => {
-  test('imports ensureDbOpen from dynamic-tools', () => {
-    assert.match(source, /ensureDbOpen.*import\(|import.*ensureDbOpen/,
-      'query-tools should import ensureDbOpen');
-  });
+  test('gsd_milestone_status opens the workspace DB before querying', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-query-tools-'));
+    const dbPath = join(base, '.gsd', 'gsd.db');
+    const tools: Record<string, any> = {};
+    const originalCwd = process.cwd();
+    try {
+      mkdirSync(join(base, '.gsd'), { recursive: true });
+      openDatabase(dbPath);
+      insertMilestone({ id: 'M001', title: 'Query me', status: 'active' });
+      closeDatabase();
 
-  test('calls ensureDbOpen() before DB queries', () => {
-    assert.match(source, /await ensureDbOpen\(\)/,
-      'query-tools should call await ensureDbOpen()');
-  });
-
-  test('no longer imports isDbAvailable in the execute path', () => {
-    // The old code imported isDbAvailable and checked it; the fix removed that
-    // The execute function should not destructure isDbAvailable from gsd-db
-    const executeBlock = source.slice(source.indexOf('async execute('));
-    assert.doesNotMatch(executeBlock, /isDbAvailable,/,
-      'execute path should not destructure isDbAvailable (replaced by ensureDbOpen)');
-  });
+      registerQueryTools({ registerTool(tool: any) { tools[tool.name] = tool; } } as any);
+      process.chdir(base);
+      const result = await tools.gsd_milestone_status.execute(
+        'call-1',
+        { milestoneId: 'M001' },
+        undefined,
+        undefined,
+        undefined,
+      );
 
-  test('uses dbAvailable result from ensureDbOpen', () => {
-    assert.match(source, /dbAvailable\s*=\s*await ensureDbOpen\(\)/,
-      'should store ensureDbOpen result in dbAvailable');
+      assert.notEqual(result.details?.error, 'db_unavailable');
+      assert.equal(result.details?.milestoneId ?? result.details?.milestone?.id, 'M001');
+    } finally {
+      process.chdir(originalCwd);
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/queue-auto-guard.test.ts

@@ -11,203 +11,29 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-// ─── Structural test: verify the guard exists in source ──────────────────────
+import { _setAutoActiveForTest } from "../auto.ts";
+import { handleWorkflowCommand } from "../commands/handlers/workflow.ts";
 
 describe("/gsd queue auto-mode guard (#4704)", () => {
-  it("handleWorkflowCommand checks isAutoActive() before calling showQueue", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    // Find the queue command block
-    const queueBlockMatch = src.match(
-      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(queueBlockMatch, "queue command block exists in handleWorkflowCommand");
-
-    const queueBlock = queueBlockMatch[1];
-
-    // Verify auto-mode guard comes BEFORE showQueue call. Accepts either the
-    // inline isAutoActive() check (Tier 1) or the shared requireNotAutoActive()
-    // helper (Tier 2 / #4712).
-    const guardIndex = Math.max(
-      queueBlock.indexOf("isAutoActive()"),
-      queueBlock.indexOf("requireNotAutoActive("),
-    );
-    const showQueueIndex = queueBlock.indexOf("showQueue(");
-
-    assert.ok(guardIndex !== -1, "auto-mode guard exists in queue command block");
-    assert.ok(showQueueIndex !== -1, "showQueue() call exists in queue command block");
-    assert.ok(
-      guardIndex < showQueueIndex,
-      "auto-mode guard appears before showQueue() call",
-    );
-  });
-
-  it("guard shows error message mentioning /gsd stop", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    assert.ok(
-      src.includes("cannot run while auto-mode is active"),
-      "error message explains that the command cannot run during auto-mode",
-    );
-    assert.ok(
-      src.includes("/gsd stop"),
-      "error message mentions /gsd stop as the resolution",
-    );
-  });
-
-  it("guard returns true (handled) to prevent falling through", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    const queueBlockMatch = src.match(
-      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(queueBlockMatch);
-    const queueBlock = queueBlockMatch[1];
-
-    // The guard block should have its own return true before showQueue
-    const guardBlock = queueBlock.slice(0, queueBlock.indexOf("showQueue("));
-    assert.ok(
-      guardBlock.includes("return true"),
-      "guard block returns true before showQueue is reached",
-    );
-  });
-});
-
-// ─── .gsd/audit/ runtime classification regression ──────────────────────────
-
-describe(".gsd/audit/ runtime classification (#4704)", () => {
-  it("GSD_RUNTIME_PATTERNS in gitignore.ts includes .gsd/audit/", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "gitignore.ts"),
-      "utf-8",
-    );
-    assert.ok(
-      src.includes('".gsd/audit/"'),
-      ".gsd/audit/ listed in GSD_RUNTIME_PATTERNS",
-    );
-  });
-
-  it("RUNTIME_EXCLUSION_PATHS in git-service.ts includes .gsd/audit/", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "git-service.ts"),
-      "utf-8",
-    );
-    assert.ok(
-      src.includes('".gsd/audit/"'),
-      ".gsd/audit/ listed in RUNTIME_EXCLUSION_PATHS",
-    );
-  });
-
-  it("SKIP_PATHS in worktree-manager.ts includes .gsd/audit/", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "worktree-manager.ts"),
-      "utf-8",
-    );
-    assert.ok(
-      src.includes('".gsd/audit/"'),
-      ".gsd/audit/ listed in SKIP_PATHS",
-    );
-  });
-});
-
-// ─── Windows gsd.db close+reopen around pre-merge stash ─────────────────────
-
-describe("Windows pre-merge DB release (#4704)", () => {
-  it("mergeMilestoneToMain closes gsd.db on win32 before git stash", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "auto-worktree.ts"),
-      "utf-8",
-    );
-
-    // Locate the stash push line and ensure a win32-gated closeDatabase()
-    // call precedes it in the same function scope.
-    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
-    assert.ok(stashIndex !== -1, "pre-merge stash push exists");
-
-    const beforeStash = src.slice(0, stashIndex);
-    const win32Index = beforeStash.lastIndexOf('process.platform === "win32"');
-    const closeIndex = beforeStash.lastIndexOf("closeDatabase()");
-
-    assert.ok(win32Index !== -1, "win32 platform guard appears before stash");
-    assert.ok(closeIndex !== -1, "closeDatabase() invoked before stash");
-    assert.ok(
-      win32Index < closeIndex && closeIndex < stashIndex,
-      "platform guard wraps the closeDatabase() call before the stash",
-    );
-  });
-
-  it("openDatabase is called after the stash to reopen the connection", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "auto-worktree.ts"),
-      "utf-8",
-    );
-    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
-    const afterStash = src.slice(stashIndex);
-    assert.ok(
-      afterStash.includes("openDatabase("),
-      "openDatabase() called after the pre-merge stash",
-    );
-  });
-
-  it("pre-merge stash targets entries by marker instead of refs/stash or stash@{0}", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "auto-worktree.ts"),
-      "utf-8",
-    );
-
-    assert.ok(src.includes("stashMarker"), "stash marker is tracked");
-    assert.ok(
-      src.includes('"stash", "list", "--format=%gd%x00%s"'),
-      "stash lookup reads ref and message together",
-    );
-    assert.ok(!src.includes('"rev-parse", "refs/stash"'), "refs/stash is not used for identity");
-    assert.ok(!src.includes('["stash", "pop"]'), "stash pop is never unqualified");
-    assert.ok(!src.includes('["stash", "drop"]'), "stash drop is never unqualified");
-  });
-
-  it("stash drop after pop failure requires auto-resolved .gsd conflicts", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "auto-worktree.ts"),
-      "utf-8",
-    );
-
-    assert.ok(
-      src.includes("gsdUU.length > 0 && nonGsdUU.length === 0"),
-      "stash drop must only run after detected .gsd conflicts were auto-resolved",
-    );
-    assert.ok(
-      src.includes("git stash pop failed without resolvable conflict files; leaving stash for manual recovery"),
-      "non-conflict stash pop failures must leave the stash for manual recovery",
-    );
+  it("returns handled and notifies when auto-mode is active", async () => {
+    const notifications: Array<{ message: string; level?: string }> = [];
+    _setAutoActiveForTest(true);
+    try {
+      const handled = await handleWorkflowCommand("queue", {
+        ui: {
+          notify(message: string, level?: string) {
+            notifications.push({ message, level });
+          },
+        },
+      } as any, {} as any);
+
+      assert.equal(handled, true);
+      assert.deepEqual(notifications, [{
+        message: "/gsd queue cannot run while auto-mode is active.\nStop auto-mode first with /gsd stop, then run /gsd queue.",
+        level: "error",
+      }]);
+    } finally {
+      _setAutoActiveForTest(false);
+    }
   });
 });