gsd-pi 2.50.0 → 2.51.0-dev.7d435fe

package/src/resources/extensions/gsd/tests/rewrite-count-persist.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Regression tests for #2203: rewrite-docs circuit breaker must persist
+ * across session restarts.
+ *
+ * The rewrite attempt counter was stored in-memory on the session object,
+ * resetting to 0 on every session restart. This allowed the rewrite-docs
+ * dispatch rule to fire indefinitely, never tripping the MAX_REWRITE_ATTEMPTS
+ * circuit breaker.
+ *
+ * The fix persists the counter to `.gsd/runtime/rewrite-count.json`.
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, existsSync, readFileSync, writeFileSync, rmSync, mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { getRewriteCount, setRewriteCount } from "../auto-dispatch.ts";
+
+describe("rewrite-docs circuit breaker persistence (#2203)", () => {
+  let tempBase: string;
+
+  beforeEach(() => {
+    tempBase = mkdtempSync(join(tmpdir(), "gsd-rewrite-test-"));
+    // Create .gsd/ directory so gsdRoot resolves to it
+    mkdirSync(join(tempBase, ".gsd", "runtime"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempBase, { recursive: true, force: true });
+  });
+
+  test("getRewriteCount returns 0 when no file exists", () => {
+    const count = getRewriteCount(tempBase);
+    assert.equal(count, 0);
+  });
+
+  test("setRewriteCount writes and getRewriteCount reads back", () => {
+    setRewriteCount(tempBase, 2);
+    const count = getRewriteCount(tempBase);
+    assert.equal(count, 2);
+  });
+
+  test("counter persists across simulated session restarts", () => {
+    // Session 1: increment to 1
+    setRewriteCount(tempBase, 1);
+
+    // "Session restart" — only the disk file survives, session object is gone
+    const countAfterRestart = getRewriteCount(tempBase);
+    assert.equal(countAfterRestart, 1, "counter should survive session restart");
+
+    // Session 2: increment to 2
+    setRewriteCount(tempBase, countAfterRestart + 1);
+    assert.equal(getRewriteCount(tempBase), 2);
+  });
+
+  test("setRewriteCount(0) resets the counter", () => {
+    setRewriteCount(tempBase, 3);
+    assert.equal(getRewriteCount(tempBase), 3);
+
+    setRewriteCount(tempBase, 0);
+    assert.equal(getRewriteCount(tempBase), 0);
+  });
+
+  test("getRewriteCount handles corrupt JSON gracefully", () => {
+    const filePath = join(tempBase, ".gsd", "runtime", "rewrite-count.json");
+    // writeFileSync is imported at the top of this file
+    writeFileSync(filePath, "not json{{{");
+    const count = getRewriteCount(tempBase);
+    assert.equal(count, 0, "corrupt file should return 0");
+  });
+
+  test("rewrite-count.json is written to .gsd/runtime/", () => {
+    setRewriteCount(tempBase, 1);
+    const filePath = join(tempBase, ".gsd", "runtime", "rewrite-count.json");
+    assert.ok(existsSync(filePath), "rewrite-count.json should exist");
+
+    const content = JSON.parse(readFileSync(filePath, "utf-8"));
+    assert.equal(content.count, 1);
+    assert.ok(content.updatedAt, "should include timestamp");
+  });
+});

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

@@ -460,4 +460,150 @@ test('(n) stale replay guard', async () => {
     }
 });
 
+test('(q) verdict in ASSESSMENT file skips UAT dispatch (file-based path)', async () => {
+    // Regression test for #2644: run-uat prompt writes the verdict to
+    // S{sid}-ASSESSMENT.md (via gsd_summary_save artifact_type:"ASSESSMENT"),
+    // but checkNeedsRunUat only checked S{sid}-UAT.md — causing a stuck loop.
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M001-ROADMAP.md'),
+        [
+          '# M001: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: First slice** `risk:low` `depends:[]`',
+          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+
+      // UAT spec file WITHOUT a verdict (the spec never gets one)
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
+      // ASSESSMENT file WITH a verdict (where run-uat actually writes it)
+      writeSliceFile(base, 'M001', 'S01', 'ASSESSMENT', '---\nverdict: PASS\n---\n# UAT Assessment\n');
+
+      const state = {
+        activeMilestone: { id: 'M001', title: 'Test roadmap' },
+        activeSlice: { id: 'S02', title: 'Next slice' },
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Plan S02',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
+      assert.deepStrictEqual(
+        result,
+        null,
+        'verdict in ASSESSMENT file should prevent re-dispatch of run-uat',
+      );
+    } finally {
+      cleanup(base);
+    }
+});
+
+test('(r) no ASSESSMENT file still dispatches UAT (no false skip)', async () => {
+    // Guard: when there is no ASSESSMENT file at all, UAT should still dispatch
+    // normally. The ASSESSMENT check must not cause a false-negative skip.
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M001-ROADMAP.md'),
+        [
+          '# M001: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: First slice** `risk:low` `depends:[]`',
+          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+
+      // UAT spec file WITHOUT a verdict, and NO ASSESSMENT file
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
+
+      const state = {
+        activeMilestone: { id: 'M001', title: 'Test roadmap' },
+        activeSlice: { id: 'S02', title: 'Next slice' },
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Plan S02',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
+      assert.deepStrictEqual(
+        result,
+        { sliceId: 'S01', uatType: 'artifact-driven' },
+        'without ASSESSMENT file, UAT still dispatches normally',
+      );
+    } finally {
+      cleanup(base);
+    }
+});
+
+test('(s) ASSESSMENT without verdict does not skip UAT dispatch', async () => {
+    // Guard: an ASSESSMENT file that exists but has no verdict line should
+    // NOT suppress UAT dispatch — only a file with an actual verdict should.
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M001-ROADMAP.md'),
+        [
+          '# M001: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: First slice** `risk:low` `depends:[]`',
+          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+
+      // UAT spec WITHOUT verdict
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
+      // ASSESSMENT file WITHOUT verdict (partial/incomplete assessment)
+      writeSliceFile(base, 'M001', 'S01', 'ASSESSMENT', '# UAT Assessment\n\nStill running checks...\n');
+
+      const state = {
+        activeMilestone: { id: 'M001', title: 'Test roadmap' },
+        activeSlice: { id: 'S02', title: 'Next slice' },
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Plan S02',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
+      assert.deepStrictEqual(
+        result,
+        { sliceId: 'S01', uatType: 'artifact-driven' },
+        'ASSESSMENT without verdict should not suppress UAT dispatch',
+      );
+    } finally {
+      cleanup(base);
+    }
+});
+
 });

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

@@ -113,12 +113,12 @@ test("postUnitPostVerification pushes to sidecarQueue for hooks", () => {
   assert.ok(triageSectionStart > -1, "auto-post-unit.ts must have a triage check section");
   const hookSection = source.slice(hookSectionStart, triageSectionStart);
   assert.ok(
-    hookSection.includes("s.sidecarQueue.push("),
-    "hook section must push to s.sidecarQueue",
+    hookSection.includes("enqueueSidecar(") || hookSection.includes("s.sidecarQueue.push("),
+    "hook section must enqueue to sidecarQueue (via enqueueSidecar or direct push)",
   );
   assert.ok(
-    hookSection.includes('kind: "hook"'),
-    "hook sidecar item must have kind: 'hook'",
+    hookSection.includes('"hook"'),
+    "hook sidecar item must reference kind 'hook'",
   );
 });
 
@@ -132,12 +132,12 @@ test("postUnitPostVerification pushes to sidecarQueue for triage", () => {
   assert.ok(quickTaskSectionStart > -1, "auto-post-unit.ts must have a quick-task dispatch section");
   const triageSection = source.slice(triageSectionStart, quickTaskSectionStart);
   assert.ok(
-    triageSection.includes("s.sidecarQueue.push("),
-    "triage section must push to s.sidecarQueue",
+    triageSection.includes("enqueueSidecar(") || triageSection.includes("s.sidecarQueue.push("),
+    "triage section must enqueue to sidecarQueue (via enqueueSidecar or direct push)",
   );
   assert.ok(
-    triageSection.includes('kind: "triage"'),
-    "triage sidecar item must have kind: 'triage'",
+    triageSection.includes('"triage"'),
+    "triage sidecar item must reference kind 'triage'",
   );
 });
 
@@ -149,12 +149,12 @@ test("postUnitPostVerification pushes to sidecarQueue for quick-tasks", () => {
   assert.ok(quickTaskSectionStart > -1, "auto-post-unit.ts must have a quick-task dispatch section");
   const quickTaskSection = source.slice(quickTaskSectionStart);
   assert.ok(
-    quickTaskSection.includes("s.sidecarQueue.push("),
-    "quick-task section must push to s.sidecarQueue",
+    quickTaskSection.includes("enqueueSidecar(") || quickTaskSection.includes("s.sidecarQueue.push("),
+    "quick-task section must enqueue to sidecarQueue (via enqueueSidecar or direct push)",
   );
   assert.ok(
-    quickTaskSection.includes('kind: "quick-task"'),
-    "quick-task sidecar item must have kind: 'quick-task'",
+    quickTaskSection.includes('"quick-task"'),
+    "quick-task sidecar item must reference kind 'quick-task'",
   );
 });
 

package/src/resources/extensions/gsd/tests/skill-catalog.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Unit tests for GSD Skill Catalog — pack matching logic.
+ *
+ * Exercises matchPacksForProject() to verify that project signals
+ * correctly map to skill packs.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { PROJECT_FILES } from "../detection.ts";
+import { GREENFIELD_STACKS, SKILL_CATALOG, matchPacksForProject } from "../skill-catalog.ts";
+import type { ProjectSignals } from "../detection.ts";
+
+function makeSignals(overrides: Partial<ProjectSignals> = {}): ProjectSignals {
+  return {
+    detectedFiles: [],
+    isGitRepo: false,
+    isMonorepo: false,
+    xcodePlatforms: [],
+    hasCI: false,
+    hasTests: false,
+    verificationCommands: [],
+    ...overrides,
+  };
+}
+
+function packLabels(signals: ProjectSignals): string[] {
+  return matchPacksForProject(signals).map((p) => p.label);
+}
+
+// ── matchAlways packs are always included ────────────────────────────────────
+
+test("matchPacksForProject: always includes matchAlways packs", () => {
+  const labels = packLabels(makeSignals());
+  assert.ok(labels.includes("Skill Discovery"), "should include Skill Discovery");
+  assert.ok(labels.includes("Skill Authoring"), "should include Skill Authoring");
+  assert.ok(labels.includes("Browser Automation"), "should include Browser Automation");
+  assert.ok(labels.includes("Document Handling"), "should include Document Handling");
+  assert.ok(labels.includes("Code Review & Quality"), "should include Code Review & Quality");
+  assert.ok(labels.includes("Git Advanced Workflows"), "should include Git Advanced Workflows");
+});
+
+// ── Language matching ────────────────────────────────────────────────────────
+
+test("matchPacksForProject: Python language matches Python packs", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml"] }));
+  assert.ok(labels.includes("Python"), "should include Python");
+  assert.ok(labels.includes("Python Advanced"), "should include Python Advanced");
+});
+
+test("matchPacksForProject: Rust language matches Rust packs", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "rust", detectedFiles: ["Cargo.toml"] }));
+  assert.ok(labels.includes("Rust"), "should include Rust");
+  assert.ok(labels.includes("Rust Async Patterns"), "should include Rust Async Patterns");
+});
+
+test("matchPacksForProject: Go language matches Go packs", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "go", detectedFiles: ["go.mod"] }));
+  assert.ok(labels.includes("Go"), "should include Go");
+  assert.ok(labels.includes("Go Concurrency Patterns"), "should include Go Concurrency Patterns");
+});
+
+test("matchPacksForProject: JS/TS matches web frontend packs", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "javascript/typescript", detectedFiles: ["package.json"] }));
+  assert.ok(labels.includes("React & Web Frontend"), "should include React");
+  assert.ok(labels.includes("TypeScript & JS Development"), "should include TS/JS Dev");
+  assert.ok(labels.includes("React State & Patterns"), "should include React State");
+  assert.ok(labels.includes("shadcn/ui"), "should include shadcn");
+  assert.ok(labels.includes("Frontend Design & UX"), "should include Frontend Design");
+});
+
+// ── File matching ────────────────────────────────────────────────────────────
+
+test("matchPacksForProject: angular.json triggers Angular packs", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["angular.json"] }));
+  assert.ok(labels.includes("Angular"), "should include Angular");
+  assert.ok(labels.includes("Angular Migration"), "should include Angular Migration");
+});
+
+test("matchPacksForProject: next.config.ts triggers Next.js packs", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["next.config.ts"] }));
+  assert.ok(labels.includes("Next.js"), "should include Next.js");
+  assert.ok(labels.includes("Next.js App Router Patterns"), "should include Next.js App Router");
+});
+
+test("matchPacksForProject: *.vue triggers Vue.js", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["*.vue"] }));
+  assert.ok(labels.includes("Vue.js"), "should include Vue.js");
+});
+
+test("matchPacksForProject: Chart.yaml triggers Kubernetes", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["Chart.yaml"] }));
+  assert.ok(labels.includes("Kubernetes"), "should include Kubernetes");
+});
+
+test("matchPacksForProject: hardhat.config.ts triggers Blockchain", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["hardhat.config.ts"] }));
+  assert.ok(labels.includes("Blockchain & Web3"), "should include Blockchain & Web3");
+});
+
+test("matchPacksForProject: tailwind.config.ts triggers Tailwind CSS", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["tailwind.config.ts"] }));
+  assert.ok(labels.includes("Tailwind CSS"), "should include Tailwind CSS");
+});
+
+// ── Xcode platform matching ─────────────────────────────────────────────────
+
+test("matchPacksForProject: iphoneos triggers iOS packs", () => {
+  const labels = packLabels(makeSignals({ xcodePlatforms: ["iphoneos"] }));
+  assert.ok(labels.includes("iOS App Frameworks"), "should include iOS App Frameworks");
+  assert.ok(labels.includes("iOS Data Frameworks"), "should include iOS Data Frameworks");
+  assert.ok(labels.includes("iOS AI & ML"), "should include iOS AI & ML");
+  assert.ok(labels.includes("iOS Engineering"), "should include iOS Engineering");
+  assert.ok(labels.includes("iOS Hardware"), "should include iOS Hardware");
+  assert.ok(labels.includes("iOS Platform"), "should include iOS Platform");
+});
+
+// ── Isolation checks — packs that should NOT match ──────────────────────────
+
+test("matchPacksForProject: FastAPI does not match generic Python", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml"] }));
+  assert.ok(!labels.includes("FastAPI"), "FastAPI should NOT match generic Python projects");
+});
+
+test("matchPacksForProject: FastAPI matches when dep:fastapi detected", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml", "dep:fastapi"] }));
+  assert.ok(labels.includes("FastAPI"), "FastAPI should match when dep:fastapi is in detectedFiles");
+});
+
+test("matchPacksForProject: Spring Boot does not match via language alone", () => {
+  // Simulate Android project: has java/kotlin language but no root pom.xml/build.gradle
+  const labels = packLabels(makeSignals({ primaryLanguage: "java/kotlin", detectedFiles: ["app/build.gradle"] }));
+  assert.ok(!labels.includes("Java & Spring Boot"), "Spring Boot should NOT match via language alone");
+});
+
+test("matchPacksForProject: Spring Boot matches only dep:spring-boot", () => {
+  const positive = packLabels(makeSignals({ detectedFiles: ["dep:spring-boot"] }));
+  assert.ok(positive.includes("Java & Spring Boot"), "should include Spring Boot pack when dependency marker exists");
+
+  const androidLike = packLabels(makeSignals({ detectedFiles: ["build.gradle", "app/build.gradle"], primaryLanguage: "java/kotlin" }));
+  assert.ok(!androidLike.includes("Java & Spring Boot"), "generic Gradle + Android markers should not imply Spring Boot");
+});
+
+test("matchPacksForProject: Unity does not include Godot", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["ProjectSettings/ProjectVersion.txt"] }));
+  assert.ok(labels.includes("Unity"), "should include Unity");
+  assert.ok(!labels.includes("Godot"), "should NOT include Godot");
+});
+
+test("matchPacksForProject: Godot does not include Unity", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["project.godot"] }));
+  assert.ok(labels.includes("Godot"), "should include Godot");
+  assert.ok(!labels.includes("Unity"), "should NOT include Unity");
+});
+
+test("matchPacksForProject: .NET backend patterns match F# and solution markers", () => {
+  const fsprojLabels = packLabels(makeSignals({ detectedFiles: ["*.fsproj"], primaryLanguage: "fsharp" }));
+  assert.ok(fsprojLabels.includes(".NET Backend Patterns"), "should include generic .NET backend patterns for F# projects");
+  assert.ok(!fsprojLabels.includes(".NET & C#"), "should not include C#-specific pack for F# projects");
+
+  const slnLabels = packLabels(makeSignals({ detectedFiles: ["*.sln"], primaryLanguage: "dotnet" }));
+  assert.ok(slnLabels.includes(".NET Backend Patterns"), "should include generic .NET backend patterns for solution files");
+});
+
+test("SKILL_CATALOG: every matchFiles entry is backed by detection", () => {
+  const knownMarkers = new Set<string>([
+    ...PROJECT_FILES,
+    "*.sqlite",
+    "*.sql",
+    "*.csproj",
+    "*.fsproj",
+    "*.sln",
+    "*.vue",
+    "dep:fastapi",
+    "dep:spring-boot",
+  ]);
+
+  for (const pack of SKILL_CATALOG) {
+    for (const marker of pack.matchFiles ?? []) {
+      assert.ok(knownMarkers.has(marker), `Unknown detection marker: ${marker} (pack: ${pack.label})`);
+    }
+  }
+});
+
+test("GREENFIELD_STACKS: every pack label resolves to SKILL_CATALOG", () => {
+  const labels = new Set(SKILL_CATALOG.map((pack) => pack.label));
+
+  for (const stack of GREENFIELD_STACKS) {
+    for (const packLabel of stack.packs) {
+      assert.ok(labels.has(packLabel), `Unknown pack label: ${packLabel} (stack: ${stack.id})`);
+    }
+  }
+});

package/src/resources/extensions/gsd/tests/terminated-transient.test.ts

@@ -1,49 +1,84 @@
 /**
  * terminated-transient.test.ts — Regression test for #2309.
  *
- * classifyProviderError should treat 'terminated' errors (process killed,
+ * classifyError should treat 'terminated' errors (process killed,
  * connection reset) as transient with auto-resume, not permanent.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { classifyProviderError } from "../provider-error-pause.ts";
+import { classifyError, isTransient } from "../error-classifier.ts";
 
 test("#2309: 'terminated' errors should be classified as transient", () => {
-  const result = classifyProviderError("terminated");
-  assert.equal(result.isTransient, true, "'terminated' should be transient");
-  assert.equal(result.isRateLimit, false, "'terminated' is not a rate limit");
-  assert.ok(result.suggestedDelayMs > 0, "'terminated' should have a retry delay");
+  const result = classifyError("terminated");
+  assert.equal(isTransient(result), true, "'terminated' should be transient");
+  assert.equal(result.kind, "connection", "'terminated' matches connection");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0, "'terminated' should have a retry delay");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "'terminated' should use 15s backoff");
 });
 
-test("#2309: 'connection reset' errors should be classified as transient", () => {
-  const result = classifyProviderError("connection reset by peer");
-  assert.equal(result.isTransient, true, "'connection reset' should be transient");
+test("#2309: 'connection reset by peer' errors should be classified as transient (network)", () => {
+  const result = classifyError("connection reset by peer");
+  assert.equal(isTransient(result), true, "'connection reset by peer' should be transient");
+  assert.equal(result.kind, "network", "'connection reset by peer' matches NETWORK_RE (connection.*reset) before CONNECTION_RE");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 3_000, "network errors use 3s backoff");
 });
 
 test("#2309: 'other side closed' errors should be classified as transient", () => {
-  const result = classifyProviderError("other side closed the connection");
-  assert.equal(result.isTransient, true, "'other side closed' should be transient");
+  const result = classifyError("other side closed the connection");
+  assert.equal(isTransient(result), true, "'other side closed' should be transient");
+  assert.equal(result.kind, "connection", "'other side closed' matches CONNECTION_RE");
 });
 
 test("#2309: 'fetch failed' errors should be classified as transient", () => {
-  const result = classifyProviderError("fetch failed: network error");
-  assert.equal(result.isTransient, true, "'fetch failed' should be transient");
+  const result = classifyError("fetch failed: network error");
+  assert.equal(isTransient(result), true, "'fetch failed' should be transient");
+  assert.equal(result.kind, "network", "'fetch failed' matches NETWORK_RE");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 3_000, "network errors use 3s backoff");
 });
 
 test("#2309: 'connection refused' errors should be classified as transient", () => {
-  const result = classifyProviderError("ECONNREFUSED: connection refused");
-  assert.equal(result.isTransient, true, "'connection refused' should be transient");
+  const result = classifyError("ECONNREFUSED: connection refused");
+  assert.equal(isTransient(result), true, "'connection refused' should be transient");
+  assert.equal(result.kind, "network", "'ECONNREFUSED' matches NETWORK_RE (same-model retry)");
 });
 
 test("#2309: permanent errors are still permanent", () => {
-  const authResult = classifyProviderError("unauthorized: invalid API key");
-  assert.equal(authResult.isTransient, false, "auth errors should stay permanent");
-  assert.equal(authResult.suggestedDelayMs, 0, "permanent errors have no delay");
+  const authResult = classifyError("unauthorized: invalid API key");
+  assert.equal(isTransient(authResult), false, "auth errors should stay permanent");
+  assert.equal(authResult.kind, "permanent", "auth errors are permanent");
+  assert.equal("retryAfterMs" in authResult, false, "permanent errors have no retryAfterMs");
 });
 
 test("#2309: rate limits are still transient", () => {
-  const rlResult = classifyProviderError("rate limit exceeded (429)");
-  assert.equal(rlResult.isTransient, true, "rate limits are still transient");
-  assert.equal(rlResult.isRateLimit, true, "rate limits are flagged as rate limits");
+  const rlResult = classifyError("rate limit exceeded (429)");
+  assert.equal(isTransient(rlResult), true, "rate limits are still transient");
+  assert.equal(rlResult.kind, "rate-limit", "rate limits are flagged as rate-limit kind");
+});
+
+// --- #2572: stream-truncation JSON parse errors should be transient ---
+
+test("#2572: 'Expected double-quoted property name' (truncated stream) is transient", () => {
+  const result = classifyError("Expected double-quoted property name in JSON at position 23 (line 1 column 24)");
+  assert.equal(isTransient(result), true, "truncated-stream JSON parse error should be transient");
+  assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "should use 15s backoff");
+});
+
+test("#2572: 'Unexpected end of JSON input' (truncated stream) is transient", () => {
+  const result = classifyError("Unexpected end of JSON input");
+  assert.equal(isTransient(result), true, "'Unexpected end of JSON input' should be transient");
+  assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
+});
+
+test("#2572: 'Unexpected token' in JSON (truncated stream) is transient", () => {
+  const result = classifyError("Unexpected token < in JSON at position 0");
+  assert.equal(isTransient(result), true, "'Unexpected token in JSON' should be transient");
+  assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
+});
+
+test("#2572: 'SyntaxError' with JSON context (truncated stream) is transient", () => {
+  const result = classifyError("SyntaxError: JSON.parse: unexpected character at line 1 column 1");
+  assert.equal(isTransient(result), true, "'SyntaxError...JSON' should be transient");
+  assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
 });

package/src/resources/extensions/gsd/tests/token-cost-display.test.ts

@@ -63,13 +63,13 @@ test("show_token_cost defaults to undefined (disabled) when not set", () => {
   assert.equal(preferences.show_token_cost, undefined);
 });
 
-test("empty preferences.md does not enable show_token_cost", () => {
+test("empty PREFERENCES.md does not enable show_token_cost", () => {
   const prefs = parsePreferencesMarkdown("---\nversion: 1\n---\n");
   assert.ok(prefs);
   assert.equal(prefs.show_token_cost, undefined);
 });
 
-test("preferences.md with show_token_cost: true enables the preference", () => {
+test("PREFERENCES.md with show_token_cost: true enables the preference", () => {
   const prefs = parsePreferencesMarkdown("---\nshow_token_cost: true\n---\n");
   assert.ok(prefs);
   assert.equal(prefs.show_token_cost, true);

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -119,7 +119,7 @@ test("dispatch: triage dispatch keeps the loop in continue mode", () => {
     postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
-    triageBlock.includes('return "continue"'),
+    triageBlock.includes('return "continue"') || triageBlock.includes("return enqueueSidecar("),
     "triage dispatch should return 'continue' after enqueuing sidecar work",
   );
 });
@@ -320,7 +320,7 @@ test("dispatch: quick-task dispatch keeps the loop in continue mode", () => {
     postUnitSrc.indexOf("if (s.stepMode)"),
   );
   assert.ok(
-    quickTaskSection.includes('return "continue"'),
+    quickTaskSection.includes('return "continue"') || quickTaskSection.includes("return enqueueSidecar("),
     "quick-task dispatch should return 'continue' after enqueuing sidecar work",
   );
 });