gsd-pi 2.58.0 → 2.59.0-dev.023bd39

package/src/resources/extensions/gsd/tests/project-relocation-recovery.test.ts

@@ -0,0 +1,297 @@
+/**
+ * Project Relocation Recovery Tests (#2750)
+ *
+ * Verifies that moving/renaming a GSD project directory does not cause
+ * silent data loss. When a repo has a remote URL, the identity hash
+ * should be based solely on the remote — making moves transparent.
+ *
+ * For local-only repos (no remote), ensureGsdSymlink should detect
+ * orphaned state directories with a matching .gsd-id marker and
+ * recover them automatically.
+ */
+
+import { describe, test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  realpathSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import {
+  repoIdentity,
+  externalGsdRoot,
+  ensureGsdSymlink,
+  readRepoMeta,
+  externalProjectsRoot,
+} from "../repo-identity.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function normalizePath(p: string): string {
+  const resolved =
+    process.platform === "win32" ? realpathSync.native(p) : realpathSync(p);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function initRepo(dir: string, remote?: string): void {
+  git(["init", "-b", "main"], dir);
+  git(["config", "user.name", "Test"], dir);
+  git(["config", "user.email", "test@example.com"], dir);
+  if (remote) {
+    git(["remote", "add", "origin", remote], dir);
+  }
+  writeFileSync(join(dir, "README.md"), "# Test\n", "utf-8");
+  git(["add", "README.md"], dir);
+  git(["commit", "-m", "init"], dir);
+}
+
+describe("project-relocation-recovery (#2750)", () => {
+  let stateDir: string;
+  let savedStateDir: string | undefined;
+
+  before(() => {
+    savedStateDir = process.env.GSD_STATE_DIR;
+    stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-state-")));
+    process.env.GSD_STATE_DIR = stateDir;
+  });
+
+  after(() => {
+    if (savedStateDir !== undefined) {
+      process.env.GSD_STATE_DIR = savedStateDir;
+    } else {
+      delete process.env.GSD_STATE_DIR;
+    }
+    rmSync(stateDir, { recursive: true, force: true });
+  });
+
+  // ── Remote repos: identity should be path-independent ─────────────────
+
+  test("repoIdentity is stable across moves for repos with a remote URL", () => {
+    const repoA = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-a-")));
+    initRepo(repoA, "https://github.com/example/myrepo.git");
+
+    const identityBefore = repoIdentity(repoA);
+
+    // Move the repo to a new location
+    const repoB = join(
+      tmpdir(),
+      `gsd-reloc-b-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    renameSync(repoA, repoB);
+
+    const identityAfter = repoIdentity(repoB);
+
+    assert.strictEqual(
+      identityAfter,
+      identityBefore,
+      "identity hash must be stable when a remote-enabled repo is moved",
+    );
+
+    rmSync(repoB, { recursive: true, force: true });
+  });
+
+  test("ensureGsdSymlink reuses the same external dir after repo move (remote repo)", () => {
+    const repoA = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-reuse-a-")));
+    initRepo(repoA, "https://github.com/example/reloc-reuse.git");
+
+    // Initialize GSD state with some planning data
+    const externalA = ensureGsdSymlink(repoA);
+    const milestonesPath = join(externalA, "milestones");
+    mkdirSync(milestonesPath, { recursive: true });
+    writeFileSync(
+      join(milestonesPath, "M001.md"),
+      "# Milestone 1\nImportant planning data\n",
+      "utf-8",
+    );
+
+    // Move the repo
+    const repoB = join(
+      tmpdir(),
+      `gsd-reloc-reuse-b-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    renameSync(repoA, repoB);
+
+    // ensureGsdSymlink at the new location should find the same external dir
+    const externalB = ensureGsdSymlink(repoB);
+
+    assert.strictEqual(
+      normalizePath(externalB),
+      normalizePath(externalA),
+      "external state dir must be the same after move",
+    );
+
+    // Planning data must survive the move
+    assert.ok(
+      existsSync(join(externalB, "milestones", "M001.md")),
+      "milestone data must survive project relocation",
+    );
+
+    const content = readFileSync(
+      join(externalB, "milestones", "M001.md"),
+      "utf-8",
+    );
+    assert.ok(
+      content.includes("Important planning data"),
+      "milestone content must be preserved",
+    );
+
+    rmSync(repoB, { recursive: true, force: true });
+  });
+
+  test("repo-meta.json gitRoot is updated after move (remote repo)", () => {
+    const repoA = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-meta-a-")));
+    initRepo(repoA, "https://github.com/example/reloc-meta.git");
+
+    const externalA = ensureGsdSymlink(repoA);
+    const metaBefore = readRepoMeta(externalA);
+    assert.ok(metaBefore !== null, "metadata should exist before move");
+
+    // Move the repo
+    const repoB = join(
+      tmpdir(),
+      `gsd-reloc-meta-b-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    renameSync(repoA, repoB);
+
+    const externalB = ensureGsdSymlink(repoB);
+    const metaAfter = readRepoMeta(externalB);
+    assert.ok(metaAfter !== null, "metadata should exist after move");
+    assert.strictEqual(
+      normalizePath(metaAfter!.gitRoot),
+      normalizePath(repoB),
+      "repo-meta.json gitRoot must be updated to new location",
+    );
+    assert.strictEqual(
+      metaAfter!.createdAt,
+      metaBefore!.createdAt,
+      "createdAt must be preserved across moves",
+    );
+
+    rmSync(repoB, { recursive: true, force: true });
+  });
+
+  // ── Local-only repos: .gsd-id marker provides recovery ────────────────
+
+  test("ensureGsdSymlink writes a .gsd-id marker in the project root", () => {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-marker-")));
+    initRepo(repo);
+
+    ensureGsdSymlink(repo);
+
+    const markerPath = join(repo, ".gsd-id");
+    assert.ok(existsSync(markerPath), ".gsd-id marker must be written by ensureGsdSymlink");
+
+    const markerId = readFileSync(markerPath, "utf-8").trim();
+    const computedId = repoIdentity(repo);
+    assert.strictEqual(markerId, computedId, ".gsd-id must contain the repo identity hash");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("local-only repo recovers state via .gsd-id marker after move", () => {
+    const repoA = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-local-a-")));
+    initRepo(repoA);
+    // No remote — identity includes gitRoot
+
+    // Initialize GSD state
+    const externalA = ensureGsdSymlink(repoA);
+    mkdirSync(join(externalA, "milestones"), { recursive: true });
+    writeFileSync(
+      join(externalA, "milestones", "M001.md"),
+      "# Local Milestone\n",
+      "utf-8",
+    );
+
+    const identityBefore = repoIdentity(repoA);
+
+    // Move the repo
+    const repoB = join(
+      tmpdir(),
+      `gsd-reloc-local-b-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    renameSync(repoA, repoB);
+
+    // The identity WILL change (no remote, gitRoot changed)
+    const identityAfter = repoIdentity(repoB);
+    assert.notStrictEqual(
+      identityAfter,
+      identityBefore,
+      "local-only repo identity changes with move (expected)",
+    );
+
+    // But ensureGsdSymlink should detect .gsd-id marker and recover
+    const externalB = ensureGsdSymlink(repoB);
+    assert.ok(
+      existsSync(join(externalB, "milestones", "M001.md")),
+      "local-only repo must recover state via .gsd-id marker after move",
+    );
+
+    rmSync(repoB, { recursive: true, force: true });
+  });
+
+  // ── Edge cases ────────────────────────────────────────────────────────
+
+  test("identity remains different for repos with different remotes", () => {
+    const repoA = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-diff-a-")));
+    initRepo(repoA, "https://github.com/example/repo-alpha.git");
+
+    const repoB = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-diff-b-")));
+    initRepo(repoB, "https://github.com/example/repo-beta.git");
+
+    assert.notStrictEqual(
+      repoIdentity(repoA),
+      repoIdentity(repoB),
+      "repos with different remotes must have different identities",
+    );
+
+    rmSync(repoA, { recursive: true, force: true });
+    rmSync(repoB, { recursive: true, force: true });
+  });
+
+  test("no orphaned state dir created when remote repo is moved", () => {
+    const repoA = realpathSync(mkdtempSync(join(tmpdir(), "gsd-reloc-orphan-a-")));
+    initRepo(repoA, "https://github.com/example/no-orphan.git");
+
+    ensureGsdSymlink(repoA);
+
+    // Count project dirs before move
+    const projectsDir = externalProjectsRoot();
+    const countBefore = existsSync(projectsDir)
+      ? readdirSync(projectsDir).length
+      : 0;
+
+    // Move the repo
+    const repoB = join(
+      tmpdir(),
+      `gsd-reloc-orphan-b-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    renameSync(repoA, repoB);
+
+    ensureGsdSymlink(repoB);
+
+    const countAfter = readdirSync(projectsDir).length;
+    assert.strictEqual(
+      countAfter,
+      countBefore,
+      "moving a remote repo must not create a new orphaned state directory",
+    );
+
+    rmSync(repoB, { recursive: true, force: true });
+  });
+});

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

@@ -202,6 +202,35 @@ 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/prompt-loader-replacement.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Regression test for #2968: loadPrompt replaceAll expands $' in replacement strings.
+ *
+ * JavaScript's String.replaceAll interprets special replacement patterns ($', $`, $&)
+ * in the replacement string. When a template variable value contains $' (common in
+ * bash commands like `grep -q '^0$'`), the replacement injects the entire remainder
+ * of the template, causing exponential prompt expansion.
+ *
+ * The fix: use split/join instead of replaceAll, which has no special pattern
+ * interpretation.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+
+/**
+ * Replicate the OLD (buggy) substitution logic from prompt-loader.ts.
+ * Uses replaceAll which interprets $' $` $& in the replacement string.
+ */
+function substituteBuggy(template: string, vars: Record<string, string>): string {
+  let content = template;
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.replaceAll(`{{${key}}}`, value);
+  }
+  return content.trim();
+}
+
+/**
+ * Replicate the FIXED substitution logic from prompt-loader.ts.
+ * Uses split/join which treats the replacement as a literal string.
+ */
+function substituteFixed(template: string, vars: Record<string, string>): string {
+  let content = template;
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.split(`{{${key}}}`).join(value);
+  }
+  return content.trim();
+}
+
+test("replaceAll $' expansion bug — demonstrates the problem", () => {
+  // This test shows the bug: replaceAll interprets $' as "insert portion after match"
+  const template = "Hello {{name}}, welcome to {{place}}!";
+  const valueWithDollarQuote = "grep -q '^0$'";
+
+  // Using replaceAll (buggy approach)
+  const buggyResult = template.replaceAll("{{name}}", valueWithDollarQuote);
+
+  // $' in the replacement string causes replaceAll to append the text after the match
+  // So it should NOT equal the expected result
+  const expected = "Hello grep -q '^0$', welcome to {{place}}!";
+
+  // The buggy result will contain extra text injected by $' expansion
+  assert.notEqual(buggyResult, expected,
+    "replaceAll should have expanded $' — if this fails, the JS engine changed behavior");
+  assert.ok(buggyResult.length > expected.length,
+    `Buggy result should be longer due to $' expansion. Got length ${buggyResult.length} vs expected ${expected.length}`);
+});
+
+test("split/join replacement — safe from $' expansion", () => {
+  const template = "Hello {{name}}, welcome to {{place}}!";
+  const valueWithDollarQuote = "grep -q '^0$'";
+
+  // Using split/join (safe approach)
+  const safeResult = template.split("{{name}}").join(valueWithDollarQuote);
+  const expected = "Hello grep -q '^0$', welcome to {{place}}!";
+
+  assert.equal(safeResult, expected,
+    "split/join should preserve $' literally without expansion");
+});
+
+test("fixed substitution preserves $' literally in replacement values", () => {
+  const template =
+    "Task: {{taskDescription}}\n\nVerification:\n```bash\n{{verificationCommand}}\n```\n\nEnd of prompt.";
+
+  const vars: Record<string, string> = {
+    taskDescription: "Run tests",
+    verificationCommand: "grep -c 'foo' file.txt | grep -q '^0$' && echo 'PASS' || echo 'FAIL'",
+  };
+
+  const buggyResult = substituteBuggy(template, vars);
+  const fixedResult = substituteFixed(template, vars);
+
+  // The $' in the verification command value should appear literally in fixed result
+  const expectedSnippet = "grep -q '^0$'";
+  assert.ok(fixedResult.includes(expectedSnippet),
+    `Fixed result should contain the literal string: ${expectedSnippet}`);
+
+  // The fixed result should NOT have blown up in size
+  const maxReasonableLength = 300;
+  assert.ok(fixedResult.length < maxReasonableLength,
+    `Fixed result length ${fixedResult.length} exceeds reasonable maximum ${maxReasonableLength} — prompt explosion detected!`);
+
+  // The buggy result DOES blow up — it's larger than the fixed result
+  assert.ok(buggyResult.length > fixedResult.length,
+    `Buggy result (${buggyResult.length}) should be larger than fixed (${fixedResult.length}) due to $' expansion`);
+});
+
+test("multiple $-pattern values do not cause cascading expansion", () => {
+  const template = "A: {{a}}\nB: {{b}}\nC: {{c}}\nEnd.";
+  const vars: Record<string, string> = {
+    a: "value with $' single quote pattern",
+    b: "value with $` backtick pattern",
+    c: "value with $& ampersand pattern",
+  };
+
+  const buggyResult = substituteBuggy(template, vars);
+  const fixedResult = substituteFixed(template, vars);
+
+  // The fixed version should preserve all values literally
+  assert.ok(fixedResult.includes("$'"), "Fixed result should contain literal $'");
+  assert.ok(fixedResult.includes("$`"), "Fixed result should contain literal $`");
+  assert.ok(fixedResult.includes("$&"), "Fixed result should contain literal $&");
+
+  // The fixed version should be a reasonable size
+  assert.ok(fixedResult.length < 200,
+    `Fixed result length ${fixedResult.length} should be under 200`);
+
+  // The buggy version will be larger due to expansion
+  assert.ok(buggyResult.length > fixedResult.length,
+    `Buggy result (${buggyResult.length}) should be larger than fixed (${fixedResult.length}) due to $-pattern expansion`);
+});
+
+test("realistic execute-task prompt does not explode with $' in slice plan", () => {
+  // Simulate a realistic execute-task template with multiple variables
+  const template = [
+    "# Execute Task",
+    "",
+    "## Context",
+    "Working directory: {{workingDirectory}}",
+    "Milestone: {{milestoneId}}",
+    "Slice: {{sliceId}} — {{sliceTitle}}",
+    "",
+    "## Slice Plan Excerpt",
+    "{{slicePlanExcerpt}}",
+    "",
+    "## Instructions",
+    "Complete the task described above.",
+    "{{skillActivation}}",
+    "",
+    "## Verification",
+    "Run the verification commands to confirm success.",
+  ].join("\n");
+
+  const slicePlanWithDollarPatterns = [
+    "### Step 1: Validate output",
+    "```bash",
+    "grep -c 'error' output.log | grep -q '^0$' && echo 'PASS' || echo 'FAIL'",
+    "```",
+    "",
+    "### Step 2: Check format",
+    "```bash",
+    "diff <(cat expected.txt) <(cat actual.txt) | grep -q '^$' && echo 'MATCH'",
+    "```",
+  ].join("\n");
+
+  const vars: Record<string, string> = {
+    workingDirectory: "/home/user/project",
+    milestoneId: "M001",
+    sliceId: "S01",
+    sliceTitle: "Build pipeline",
+    slicePlanExcerpt: slicePlanWithDollarPatterns,
+    skillActivation: "Load relevant skills.",
+  };
+
+  const fixedResult = substituteFixed(template, vars);
+
+  // Should contain the literal $' patterns
+  assert.ok(fixedResult.includes("'^0$'"), "Should preserve '^0$' literally");
+  assert.ok(fixedResult.includes("'^$'"), "Should preserve '^$' literally");
+
+  // Result should be reasonable size (template ~300 chars + values ~400 chars)
+  assert.ok(fixedResult.length < 1000,
+    `Result length ${fixedResult.length} exceeds 1000 — prompt explosion detected!`);
+
+  // Compare with buggy version to confirm it WOULD have exploded
+  const buggyResult = substituteBuggy(template, vars);
+  assert.ok(buggyResult.length > fixedResult.length * 1.5,
+    `Buggy result (${buggyResult.length}) should be significantly larger than fixed (${fixedResult.length})`);
+});

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

@@ -0,0 +1,69 @@
+// prompt-tool-names — Ensures prompt files reference correct tool names.
+//
+// The registered GSD tool is `search-the-web`, not `web_search`.
+// `web_search` is an Anthropic API implementation detail that should
+// never appear in GSD prompts or agent frontmatter.
+// See: https://github.com/gsd-build/gsd-2/issues/2920
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const promptsDir = join(__dirname, "..", "prompts");
+const agentsDir = join(__dirname, "..", "..", "..", "agents");
+
+/** Collect all .md files in a directory (non-recursive). */
+function mdFiles(dir: string): string[] {
+  return readdirSync(dir)
+    .filter((f) => f.endsWith(".md"))
+    .map((f) => join(dir, f));
+}
+
+const WRONG_TOOL = "web_search";
+const CORRECT_TOOL = "search-the-web";
+
+test("prompt files must not reference `web_search` — use `search-the-web` instead", () => {
+  const files = mdFiles(promptsDir);
+  assert.ok(files.length > 0, "Expected at least one prompt file");
+
+  const violations: string[] = [];
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    if (content.includes(WRONG_TOOL)) {
+      violations.push(file);
+    }
+  }
+
+  assert.deepStrictEqual(
+    violations,
+    [],
+    `These prompt files reference "${WRONG_TOOL}" instead of "${CORRECT_TOOL}":\n${violations.join("\n")}`,
+  );
+});
+
+test("agent frontmatter must not reference `web_search` — use `search-the-web` instead", () => {
+  const files = mdFiles(agentsDir);
+  assert.ok(files.length > 0, "Expected at least one agent file");
+
+  const violations: string[] = [];
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    // Check frontmatter tools line specifically
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+      const frontmatter = frontmatterMatch[1];
+      if (frontmatter.includes(WRONG_TOOL)) {
+        violations.push(file);
+      }
+    }
+  }
+
+  assert.deepStrictEqual(
+    violations,
+    [],
+    `These agent files reference "${WRONG_TOOL}" in frontmatter instead of "${CORRECT_TOOL}":\n${violations.join("\n")}`,
+  );
+});

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

@@ -118,6 +118,44 @@ 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", () => {