gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

package/src/resources/extensions/gsd/tests/integration/parallel-merge.test.ts

@@ -38,12 +38,6 @@ import {
   writeSessionStatus,
   readSessionStatus,
 } from "../../session-status-io.ts";
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-  updateMilestoneStatus,
-} from "../../gsd-db.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -471,107 +465,3 @@ test("mergeAllCompleted — by-completion order respects startedAt", async () =>
     cleanup(repo);
   }
 });
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// Bug #2812 — determineMergeOrder should use worktree DB as source of truth
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/** Set up a worktree DB with a milestone marked complete */
-function setupWorktreeDb(basePath: string, mid: string): void {
-  const wtGsdDir = join(basePath, ".gsd", "worktrees", mid, ".gsd");
-  mkdirSync(wtGsdDir, { recursive: true });
-  const dbPath = join(wtGsdDir, "gsd.db");
-  openDatabase(dbPath);
-  insertMilestone({ id: mid, title: `Milestone ${mid}`, status: "complete" });
-  updateMilestoneStatus(mid, "complete", new Date().toISOString());
-  closeDatabase();
-}
-
-test("determineMergeOrder — finds milestones completed in worktree DB even when worker state is 'error' (#2812)", () => {
-  const base = realpathSync(mkdtempSync(join(tmpdir(), "merge-db-bug-")));
-  try {
-    // Simulate the bug scenario: orchestrator has stale "error" state
-    // but the worktree DB shows milestone is actually complete.
-    setupWorktreeDb(base, "M011");
-
-    const workers = [
-      makeWorker({ milestoneId: "M010", state: "error" }),
-      makeWorker({ milestoneId: "M011", state: "error" }),  // stale — actually complete in DB
-      makeWorker({ milestoneId: "M012", state: "running" }),
-    ];
-
-    const order = determineMergeOrder(workers, "sequential", base);
-
-    // M011 should be included because its worktree DB says status='complete'
-    assert.ok(
-      order.includes("M011"),
-      `Expected M011 in merge order (worktree DB says complete), got: [${order}]`,
-    );
-    // M010 and M012 should NOT be included (no worktree DB with complete status)
-    assert.ok(!order.includes("M010"), "M010 should not be in merge order (error, no DB)");
-    assert.ok(!order.includes("M012"), "M012 should not be in merge order (running, no DB)");
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("determineMergeOrder — workers with state='stopped' still included without basePath", () => {
-  // Backward compatibility: existing behavior still works when basePath is omitted
-  const workers = [
-    makeWorker({ milestoneId: "M001", state: "stopped" }),
-    makeWorker({ milestoneId: "M002", state: "error" }),
-  ];
-  const order = determineMergeOrder(workers, "sequential");
-  assert.deepEqual(order, ["M001"]);
-});
-
-test("determineMergeOrder — combines stopped workers and DB-complete milestones without duplicates", () => {
-  const base = realpathSync(mkdtempSync(join(tmpdir(), "merge-dedup-")));
-  try {
-    // M001 is stopped in orchestrator AND complete in worktree DB
-    setupWorktreeDb(base, "M001");
-
-    const workers = [
-      makeWorker({ milestoneId: "M001", state: "stopped" }),
-      makeWorker({ milestoneId: "M002", state: "running" }),
-    ];
-
-    const order = determineMergeOrder(workers, "sequential", base);
-    // M001 should appear exactly once
-    assert.deepEqual(order, ["M001"]);
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("mergeAllCompleted — discovers DB-complete milestones when workers show error (#2812)", async () => {
-  const savedCwd = process.cwd();
-  const repo = createTempRepo();
-
-  try {
-    // Create milestone branch with a file
-    createMilestoneBranch(repo, "M011", [
-      { name: "feature.ts", content: "export const feature = true;\n" },
-    ]);
-    setupRoadmap(repo, "M011", "Feature System", ["S01: Feature module"]);
-
-    // Set up worktree DB showing M011 is complete
-    setupWorktreeDb(repo, "M011");
-
-    // Orchestrator thinks M011 is in error (stale state)
-    const workers = [
-      makeWorker({ milestoneId: "M011", state: "error" }),
-    ];
-
-    process.chdir(repo);
-    const results = await mergeAllCompleted(repo, workers, "sequential");
-
-    // Should find and merge M011 despite orchestrator "error" state
-    assert.equal(results.length, 1, "should have one result");
-    assert.equal(results[0]!.milestoneId, "M011");
-    assert.equal(results[0]!.success, true, `M011 merge should succeed: ${results[0]!.error}`);
-  } finally {
-    process.chdir(savedCwd);
-    cleanup(repo);
-  }
-});

package/src/resources/extensions/gsd/tests/integration/run-uat.test.ts

@@ -171,7 +171,7 @@ test('(k) run-uat prompt template', () => {
   const milestoneId = 'M001';
   const sliceId = 'S01';
   const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
-  const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md';
+  const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
   const uatType = 'live-runtime';
   const inlinedContext = '<!-- no context -->';
   let promptResult: string | undefined;

package/src/resources/extensions/gsd/tests/memory-extractor.test.ts

@@ -1,4 +1,4 @@
-import { parseMemoryResponse, _resetExtractionState, buildMemoryLLMCall } from '../memory-extractor.ts';
+import { parseMemoryResponse, _resetExtractionState } from '../memory-extractor.ts';
 import {
   openDatabase,
   closeDatabase,
@@ -9,7 +9,7 @@ import {
   getActiveMemoriesRanked,
 } from '../memory-store.ts';
 import type { MemoryAction } from '../memory-store.ts';
-import { describe, test, beforeEach, afterEach, mock } from 'node:test';
+import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -169,86 +169,3 @@ test('memory-extractor: reset extraction state', () => {
   assert.ok(true, '_resetExtractionState should not throw');
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: buildMemoryLLMCall resolves OAuth API key via modelRegistry
-// Regression test for #2959 — OAuth users had broken memory extraction
-// because streamSimpleAnthropic only checked env vars, not auth.json.
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('memory-extractor: buildMemoryLLMCall resolves API key from modelRegistry for OAuth users', async () => {
-  const OAUTH_TOKEN = 'sk-ant-oat-test-oauth-token-12345';
-  let getApiKeyCalled = false;
-
-  const fakeModel = {
-    id: 'claude-haiku-test',
-    provider: 'anthropic',
-    api: 'anthropic-messages',
-    cost: { input: 0.25, output: 1.25 },
-  };
-
-  const ctx = {
-    modelRegistry: {
-      getAvailable: () => [fakeModel],
-      getApiKey: async (_model: any) => {
-        getApiKeyCalled = true;
-        return OAUTH_TOKEN;
-      },
-    },
-  } as any;
-
-  const llmCallFn = buildMemoryLLMCall(ctx);
-  assert.ok(llmCallFn !== null, 'buildMemoryLLMCall should return a function when models are available');
-
-  // The function should have resolved the API key eagerly via modelRegistry.getApiKey.
-  // Give the async getApiKey a tick to resolve.
-  await new Promise(resolve => setTimeout(resolve, 50));
-  assert.ok(getApiKeyCalled, 'buildMemoryLLMCall must call modelRegistry.getApiKey() to resolve OAuth tokens');
-});
-
-test('memory-extractor: buildMemoryLLMCall returns null when no models available', () => {
-  const ctx = {
-    modelRegistry: {
-      getAvailable: () => [],
-      getApiKey: async () => undefined,
-    },
-  } as any;
-
-  const llmCallFn = buildMemoryLLMCall(ctx);
-  assert.strictEqual(llmCallFn, null, 'should return null when no models available');
-});
-
-test('memory-extractor: buildMemoryLLMCall prefers haiku model', async () => {
-  let resolvedModelId: string | undefined;
-
-  const haikuModel = {
-    id: 'claude-3-5-haiku-20241022',
-    provider: 'anthropic',
-    api: 'anthropic-messages',
-    cost: { input: 0.25, output: 1.25 },
-  };
-  const sonnetModel = {
-    id: 'claude-sonnet-4-20250514',
-    provider: 'anthropic',
-    api: 'anthropic-messages',
-    cost: { input: 3, output: 15 },
-  };
-
-  const ctx = {
-    modelRegistry: {
-      getAvailable: () => [sonnetModel, haikuModel],
-      getApiKey: async (model: any) => {
-        resolvedModelId = model.id;
-        return 'sk-ant-oat-test-token';
-      },
-    },
-  } as any;
-
-  const llmCallFn = buildMemoryLLMCall(ctx);
-  assert.ok(llmCallFn !== null, 'should return a function');
-
-  // Wait for the async getApiKey to resolve
-  await new Promise(resolve => setTimeout(resolve, 50));
-  assert.strictEqual(resolvedModelId, 'claude-3-5-haiku-20241022',
-    'should resolve API key for haiku model, not sonnet');
-});
-

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

@@ -67,37 +67,3 @@ test("all cost table entries have valid data", () => {
     assert.ok(entry.updatedAt, `${entry.id} missing updatedAt`);
   }
 });
-
-// ─── #2885: openai-codex and modern OpenAI models in cost table ──────────────
-
-test("#2885: cost table includes openai-codex provider models", () => {
-  const ids = BUNDLED_COST_TABLE.map(e => e.id);
-  const codexModels = [
-    "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
-    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4",
-  ];
-  for (const model of codexModels) {
-    assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
-  }
-});
-
-test("#2885: cost table includes modern OpenAI models", () => {
-  const ids = BUNDLED_COST_TABLE.map(e => e.id);
-  const newModels = [
-    "o4-mini", "o4-mini-deep-research",
-    "gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano",
-    "gpt-5", "gpt-5-mini", "gpt-5-nano", "gpt-5-pro",
-  ];
-  for (const model of newModels) {
-    assert.ok(ids.includes(model), `cost table should include modern OpenAI model "${model}"`);
-  }
-});
-
-test("#2885: lookupModelCost returns costs for new models (not 999 fallback)", () => {
-  const newModels = ["o4-mini", "gpt-4.1", "gpt-5", "gpt-5.4", "gpt-5.1-codex-mini"];
-  for (const model of newModels) {
-    const entry = lookupModelCost(model);
-    assert.ok(entry, `lookupModelCost should find "${model}"`);
-    assert.ok(entry.inputPer1k < 999, `${model} should have a real cost, not the 999 fallback`);
-  }
-});

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

@@ -172,11 +172,11 @@ test("#2192: unknown model is not downgraded — respects user config", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
   const result = resolveModelForComplexity(
     makeClassification("light"),
-    { primary: "some-future-unknown-model-v9", fallbacks: [] },
+    { primary: "gpt-5.4", fallbacks: [] },
     config,
-    ["some-future-unknown-model-v9", ...AVAILABLE_MODELS],
+    ["gpt-5.4", ...AVAILABLE_MODELS],
   );
-  assert.equal(result.modelId, "some-future-unknown-model-v9", "unknown model should be used as-is");
+  assert.equal(result.modelId, "gpt-5.4", "unknown model should be used as-is");
   assert.equal(result.wasDowngraded, false, "should not be downgraded");
   assert.ok(result.reason.includes("not in the known tier map"), "reason should explain why");
 });
@@ -205,68 +205,3 @@ test("#2192: known model is still downgraded normally", () => {
   assert.equal(result.wasDowngraded, true, "known heavy model should still be downgraded for light tasks");
   assert.notEqual(result.modelId, "claude-opus-4-6");
 });
-
-// ─── #2885: openai-codex and modern OpenAI models in tier map ────────────────
-
-test("#2885: openai-codex light-tier models are recognized", () => {
-  const config = { ...defaultRoutingConfig(), enabled: true };
-  const lightModels = ["gpt-4.1-mini", "gpt-4.1-nano", "gpt-5-mini", "gpt-5-nano", "gpt-5.1-codex-mini", "gpt-5.3-codex-spark"];
-  for (const model of lightModels) {
-    const result = resolveModelForComplexity(
-      makeClassification("light"),
-      { primary: model, fallbacks: [] },
-      config,
-      [model, ...AVAILABLE_MODELS],
-    );
-    // Model is known AND light-tier, so requesting light should NOT downgrade
-    assert.equal(result.wasDowngraded, false, `${model} should be known as light tier (wasDowngraded)`);
-    assert.equal(result.modelId, model, `${model} should be returned as-is for light tier`);
-    // Verify it IS known (not hitting the unknown-model bail-out)
-    assert.ok(!result.reason.includes("not in the known tier map"), `${model} should be in the known tier map`);
-  }
-});
-
-test("#2885: openai-codex standard-tier models are recognized", () => {
-  const config = { ...defaultRoutingConfig(), enabled: true };
-  const standardModels = ["gpt-4.1", "gpt-5.1-codex-max"];
-  for (const model of standardModels) {
-    const result = resolveModelForComplexity(
-      makeClassification("standard"),
-      { primary: model, fallbacks: [] },
-      config,
-      [model, ...AVAILABLE_MODELS],
-    );
-    assert.equal(result.wasDowngraded, false, `${model} should be known as standard tier`);
-    assert.equal(result.modelId, model, `${model} should be returned as-is for standard tier`);
-    assert.ok(!result.reason.includes("not in the known tier map"), `${model} should be in the known tier map`);
-  }
-});
-
-test("#2885: openai-codex heavy-tier models are recognized", () => {
-  const config = { ...defaultRoutingConfig(), enabled: true };
-  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "o4-mini", "o4-mini-deep-research"];
-  for (const model of heavyModels) {
-    const result = resolveModelForComplexity(
-      makeClassification("heavy"),
-      { primary: model, fallbacks: [] },
-      config,
-      [model, ...AVAILABLE_MODELS],
-    );
-    assert.equal(result.wasDowngraded, false, `${model} should be known as heavy tier`);
-    assert.equal(result.modelId, model, `${model} should be returned as-is for heavy tier`);
-    assert.ok(!result.reason.includes("not in the known tier map"), `${model} should be in the known tier map`);
-  }
-});
-
-test("#2885: heavy openai-codex model downgrades to light for light task", () => {
-  const config = { ...defaultRoutingConfig(), enabled: true };
-  const result = resolveModelForComplexity(
-    makeClassification("light"),
-    { primary: "gpt-5.4", fallbacks: [] },
-    config,
-    ["gpt-5.4", "gpt-4.1-nano", ...AVAILABLE_MODELS],
-  );
-  assert.equal(result.wasDowngraded, true, "heavy model should downgrade for light task");
-  // Should pick a light-tier model
-  assert.notEqual(result.modelId, "gpt-5.4", "should not use the heavy model for light task");
-});

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

@@ -154,34 +154,6 @@ test("all auto-dispatch unitTypes have preference mapping or subagent handling",
   assert.deepEqual(unmapped, [], `Unmapped unitTypes in preferences-models.ts: ${unmapped.join(", ")}`);
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// #2900: worktree-merge must map to completion phase
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("#2900: resolveModelWithFallbacksForUnit handles worktree-merge", () => {
-  assert.ok(preferencesSrc.includes('"worktree-merge"'), "missing worktree-merge case in switch");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// #2900: KNOWN_UNIT_TYPES must include all dispatched unit types
-// ═══════════════════════════════════════════════════════════════════════════
-
-const preferenceTypesSrc = readSrc("preferences-types.ts");
-
-test("#2900: KNOWN_UNIT_TYPES includes all auto-dispatch unit types", () => {
-  const missing: string[] = [];
-  for (const ut of ALL_KNOWN_UNIT_TYPES) {
-    if (!preferenceTypesSrc.includes(`"${ut}"`)) {
-      missing.push(ut);
-    }
-  }
-  assert.deepEqual(missing, [], `Missing from KNOWN_UNIT_TYPES: ${missing.join(", ")}`);
-});
-
-test("#2900: KNOWN_UNIT_TYPES includes worktree-merge", () => {
-  assert.ok(preferenceTypesSrc.includes('"worktree-merge"'), "worktree-merge missing from KNOWN_UNIT_TYPES");
-});
-
 // ═══════════════════════════════════════════════════════════════════════════
 // metrics.ts: classifyUnitPhase coverage
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -4,7 +4,6 @@ import assert from "node:assert/strict";
 import {
   buildDesktopNotificationCommand,
   shouldSendDesktopNotification,
-  formatNotificationTitle,
 } from "../notifications.js";
 import type { NotificationPreferences } from "../types.js";
 
@@ -88,47 +87,3 @@ test("buildDesktopNotificationCommand preserves literal shell characters on linu
 test("buildDesktopNotificationCommand skips unsupported platforms", () => {
   assert.equal(buildDesktopNotificationCommand("win32", "Title", "Message"), null);
 });
-
-// ─── formatNotificationTitle — project context in notifications (#2708) ──────
-
-test("formatNotificationTitle returns 'GSD' when no project name is given", () => {
-  assert.equal(formatNotificationTitle(), "GSD");
-  assert.equal(formatNotificationTitle(undefined), "GSD");
-  assert.equal(formatNotificationTitle(""), "GSD");
-});
-
-test("formatNotificationTitle includes project name when provided", () => {
-  assert.equal(formatNotificationTitle("my-app"), "GSD — my-app");
-});
-
-test("formatNotificationTitle trims whitespace from project name", () => {
-  assert.equal(formatNotificationTitle("  spaced  "), "GSD — spaced");
-});
-
-test("buildDesktopNotificationCommand includes project name in title on linux", () => {
-  const command = buildDesktopNotificationCommand(
-    "linux",
-    formatNotificationTitle("my-project"),
-    "All milestones complete!",
-    "success",
-  );
-  assert.ok(command);
-  assert.equal(command.args[2], "GSD — my-project");
-  assert.equal(command.args[3], "All milestones complete!");
-});
-
-test("buildDesktopNotificationCommand includes project name in title on macOS", () => {
-  const command = buildDesktopNotificationCommand(
-    "darwin",
-    formatNotificationTitle("my-project"),
-    "Budget 90%",
-    "warning",
-  );
-  assert.ok(command);
-  if (command.file.includes("terminal-notifier")) {
-    const titleIdx = command.args.indexOf("-title");
-    assert.equal(command.args[titleIdx + 1], "GSD — my-project");
-  } else {
-    assert.match(command.args[1], /GSD — my-project/);
-  }
-});

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

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices, updateSliceStatus } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices } from '../gsd-db.ts';
 import { handlePlanMilestone } from '../tools/plan-milestone.ts';
 import { parseRoadmap } from '../parsers-legacy.ts';
 
@@ -197,35 +197,3 @@ test('handlePlanMilestone reruns idempotently and updates existing planning stat
     cleanup(base);
   }
 });
-
-// Regression: #2960 — plan-milestone must refuse to overwrite completed slices
-test('handlePlanMilestone refuses to re-plan a milestone with completed slices (#2960)', async () => {
-  const base = makeTmpBase();
-  const dbPath = join(base, '.gsd', 'gsd.db');
-  openDatabase(dbPath);
-
-  try {
-    // First plan succeeds
-    const first = await handlePlanMilestone(validParams(), base);
-    assert.ok(!('error' in first), `initial plan should succeed: ${'error' in first ? first.error : ''}`);
-
-    // Mark S01 as complete
-    updateSliceStatus('M001', 'S01', 'complete');
-
-    // Second plan should fail — S01 is already complete
-    const second = await handlePlanMilestone({
-      ...validParams(),
-      vision: 'Should not overwrite',
-    }, base);
-    assert.ok('error' in second, 'should refuse to re-plan when slices are completed');
-    assert.match(second.error, /cannot re-plan/i);
-    assert.match(second.error, /S01/);
-
-    // Verify the completed slice was not overwritten
-    const slices = getMilestoneSlices('M001');
-    const s01 = slices.find(s => s.id === 'S01');
-    assert.equal(s01?.status, 'complete', 'S01 should still be complete');
-  } finally {
-    cleanup(base);
-  }
-});

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

@@ -202,35 +202,6 @@ test("reassess-roadmap prompt names gsd_reassess_roadmap as the tool to use", ()
   assert.match(prompt, /gsd_reassess_roadmap/);
 });
 
-// ─── Bug #2933: prompt parameter names must match camelCase TypeBox schema ───
-
-test("execute-task prompt uses camelCase parameter names matching TypeBox schema", () => {
-  const prompt = readPrompt("execute-task");
-  // The gsd_complete_task tool schema uses camelCase: milestoneId, sliceId, taskId
-  // Prompts must NOT tell the LLM to use snake_case (milestone_id, slice_id, task_id)
-  const toolCallLine = prompt.split("\n").find((l) => /gsd_complete_task/.test(l) || /gsd_task_complete/.test(l));
-  assert.ok(toolCallLine, "prompt must contain a gsd_complete_task or gsd_task_complete tool call line");
-  assert.doesNotMatch(toolCallLine!, /milestone_id/, "must use milestoneId, not milestone_id");
-  assert.doesNotMatch(toolCallLine!, /slice_id/, "must use sliceId, not slice_id");
-  assert.doesNotMatch(toolCallLine!, /task_id/, "must use taskId, not task_id");
-  // Positive: must mention the camelCase names
-  assert.match(toolCallLine!, /milestoneId/);
-  assert.match(toolCallLine!, /sliceId/);
-  assert.match(toolCallLine!, /taskId/);
-});
-
-test("complete-slice prompt uses camelCase parameter names matching TypeBox schema", () => {
-  const prompt = readPrompt("complete-slice");
-  // The gsd_complete_slice tool schema uses camelCase: milestoneId, sliceId
-  const toolCallLine = prompt.split("\n").find((l) => /gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l));
-  assert.ok(toolCallLine, "prompt must contain a gsd_complete_slice or gsd_slice_complete tool call line");
-  assert.doesNotMatch(toolCallLine!, /milestone_id/, "must use milestoneId, not milestone_id");
-  assert.doesNotMatch(toolCallLine!, /slice_id/, "must use sliceId, not slice_id");
-  // Positive: must mention the camelCase names
-  assert.match(toolCallLine!, /milestoneId/);
-  assert.match(toolCallLine!, /sliceId/);
-});
-
 test("reactive-execute prompt references tool calls instead of checkbox updates", () => {
   const prompt = readPrompt("reactive-execute");
   assert.doesNotMatch(prompt, /checkbox updates/);

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

@@ -118,44 +118,6 @@ test("classifyError: rate limit takes precedence over auth keywords", () => {
   assert.ok(isTransient(result));
 });
 
-// ── STREAM_RE: V8 JSON parse error variants (#2916) ────────────────────────
-
-test("classifyError: 'Expected comma/brace after property value in JSON' is transient stream", () => {
-  const result = classifyError(
-    "Expected ',' or '}' after property value in JSON at position 2056 (line 1 column 2057)"
-  );
-  assert.equal(result.kind, "stream");
-  assert.ok(isTransient(result));
-  assert.ok("retryAfterMs" in result && result.retryAfterMs === 15_000);
-});
-
-test("classifyError: 'Expected colon after property name in JSON' is transient stream", () => {
-  const result = classifyError(
-    "Expected ':' after property name in JSON at position 500 (line 1 column 501)"
-  );
-  assert.equal(result.kind, "stream");
-  assert.ok(isTransient(result));
-  assert.ok("retryAfterMs" in result && result.retryAfterMs === 15_000);
-});
-
-test("classifyError: 'Expected property name or brace in JSON' is transient stream", () => {
-  const result = classifyError(
-    "Expected property name or '}' in JSON at position 42 (line 1 column 43)"
-  );
-  assert.equal(result.kind, "stream");
-  assert.ok(isTransient(result));
-  assert.ok("retryAfterMs" in result && result.retryAfterMs === 15_000);
-});
-
-test("classifyError: 'Unterminated string in JSON' is transient stream", () => {
-  const result = classifyError(
-    "Unterminated string in JSON at position 100 (line 1 column 101)"
-  );
-  assert.equal(result.kind, "stream");
-  assert.ok(isTransient(result));
-  assert.ok("retryAfterMs" in result && result.retryAfterMs === 15_000);
-});
-
 // ── isTransientNetworkError ──────────────────────────────────────────────────
 
 test("isTransientNetworkError detects ECONNRESET", () => {