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

package/src/resources/extensions/gsd/tests/completion-hierarchy-guards.test.ts

@@ -1,192 +0,0 @@
-// GSD State Machine Regression Tests — Completion Hierarchy & State Derivation (#3161)
-
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-  insertSlice,
-  insertTask,
-  getTask,
-  getSlice,
-  getMilestone,
-  getSliceTasks,
-  updateTaskStatus,
-  updateSliceStatus,
-} from "../gsd-db.ts";
-import { isClosedStatus } from "../status-guards.ts";
-
-// ─── Setup / Teardown ──────────────────────────────────────────────────────
-
-beforeEach(() => {
-  openDatabase(":memory:");
-});
-
-afterEach(() => {
-  try { closeDatabase(); } catch { /* swallow */ }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("completion-hierarchy-guards", () => {
-
-  // ─── Test 1: isClosedStatus ─────────────────────────────────────────────
-  test("isClosedStatus returns true for 'complete' and 'done'", () => {
-    assert.ok(isClosedStatus("complete"), "'complete' should be closed");
-    assert.ok(isClosedStatus("done"), "'done' should be closed");
-    assert.ok(!isClosedStatus("pending"), "'pending' should not be closed");
-    assert.ok(!isClosedStatus("in-progress"), "'in-progress' should not be closed");
-    assert.ok(!isClosedStatus("blocked"), "'blocked' should not be closed");
-    assert.ok(!isClosedStatus(""), "empty string should not be closed");
-    assert.ok(!isClosedStatus("active"), "'active' should not be closed");
-  });
-
-  // ─── Test 2: vacuous truth guard — slice with zero tasks ───────────────
-  test("cannot complete slice with zero tasks — vacuous truth guard", () => {
-    insertMilestone({ id: "M001" });
-    insertSlice({ id: "S01", milestoneId: "M001" });
-
-    const tasks = getSliceTasks("M001", "S01");
-    assert.equal(tasks.length, 0, "newly inserted slice has zero tasks");
-
-    // The guard: a slice with no tasks is not completable.
-    // isSliceComplete from state.ts: plan.tasks.length > 0 && every done.
-    // Here we replicate the DB-side equivalent: zero tasks means guard fires.
-    const isCompletable = tasks.length > 0 && tasks.every(t => isClosedStatus(t.status));
-    assert.equal(isCompletable, false, "vacuous truth guard: zero tasks → not completable");
-  });
-
-  // ─── Test 3: cannot complete slice with incomplete tasks ─────────────────
-  test("cannot complete slice with incomplete tasks", () => {
-    insertMilestone({ id: "M001" });
-    insertSlice({ id: "S01", milestoneId: "M001" });
-    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "done" });
-    insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", status: "pending" });
-
-    const tasks = getSliceTasks("M001", "S01");
-    assert.equal(tasks.length, 2, "slice has 2 tasks");
-
-    const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
-    assert.equal(incompleteTasks.length, 1, "exactly one task is not closed");
-    assert.equal(incompleteTasks[0]?.id, "T02", "the incomplete task is T02");
-    assert.equal(incompleteTasks[0]?.status, "pending", "incomplete task status is 'pending'");
-  });
-
-  // ─── Test 4: phantom parent milestone and slice (H6) ────────────────────
-  test("task completion auto-creates phantom parent milestone and slice (H6)", () => {
-    // H6 finding: insertMilestone/insertSlice accept empty titles — phantom
-    // parents can be created without substantive content.
-    insertMilestone({ id: "M001" });
-    insertSlice({ id: "S01", milestoneId: "M001" });
-
-    const milestone = getMilestone("M001");
-    assert.ok(milestone !== null, "phantom milestone M001 should exist in DB");
-    assert.equal(milestone!.title, "", "phantom milestone has empty title by default");
-
-    const slice = getSlice("M001", "S01");
-    assert.ok(slice !== null, "phantom slice S01 should exist in DB");
-    assert.equal(slice!.title, "", "phantom slice has empty title by default");
-
-    // This documents the H6 finding: the DB allows phantom parents with
-    // no meaningful content, which can silently accept task completion calls.
-  });
-
-  // ─── Test 5: double task completion is detectable via isClosedStatus ────
-  test("double task completion is detectable via isClosedStatus", () => {
-    insertMilestone({ id: "M001" });
-    insertSlice({ id: "S01", milestoneId: "M001" });
-    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "done" });
-
-    const task = getTask("M001", "S01", "T01");
-    assert.ok(task !== null, "task T01 should exist");
-    assert.ok(
-      isClosedStatus(task!.status),
-      "isClosedStatus detects already-closed task — prevents double completion",
-    );
-
-    // The guard that prevents double completion: check isClosedStatus before
-    // calling updateTaskStatus again.
-    const wouldDoubleComplete = isClosedStatus(task!.status);
-    assert.ok(wouldDoubleComplete, "guard fires: task is already closed");
-  });
-
-  // ─── Test 6: updateSliceStatus rollback loses original status (M11) ─────
-  test("updateSliceStatus rollback goes to 'pending' not original status (M11)", () => {
-    insertMilestone({ id: "M001" });
-    // Insert with an explicit non-pending status to simulate an in-progress slice
-    insertSlice({ id: "S01", milestoneId: "M001", status: "pending" });
-
-    // Manually advance to "in_progress" equivalent via updateSliceStatus
-    updateSliceStatus("M001", "S01", "in_progress");
-    const afterProgress = getSlice("M001", "S01");
-    assert.equal(afterProgress!.status, "in_progress", "slice is in_progress after update");
-
-    // Simulate completion
-    updateSliceStatus("M001", "S01", "complete", new Date().toISOString());
-    const afterComplete = getSlice("M001", "S01");
-    assert.equal(afterComplete!.status, "complete", "slice is complete after completion");
-
-    // Simulate rollback — the DB only stores current status, not history.
-    // Rolling back means setting to "pending" — the original "in_progress" is lost.
-    updateSliceStatus("M001", "S01", "pending");
-    const afterRollback = getSlice("M001", "S01");
-    assert.equal(
-      afterRollback!.status,
-      "pending",
-      "M11: rollback sets status to 'pending', original 'in_progress' is lost",
-    );
-    // Document: there is no completed_at or status history to recover from.
-    // The rollback silently discards the in_progress state.
-  });
-
-  // ─── Test 7: milestone completion requires all slices closed ─────────────
-  test("milestone completion requires all slices closed", () => {
-    insertMilestone({ id: "M001" });
-    insertSlice({ id: "S01", milestoneId: "M001", status: "done" });
-    insertSlice({ id: "S02", milestoneId: "M001", status: "pending" });
-
-    const s01 = getSlice("M001", "S01");
-    const s02 = getSlice("M001", "S02");
-
-    assert.ok(s01 !== null, "S01 exists");
-    assert.ok(s02 !== null, "S02 exists");
-
-    const slices = [s01!, s02!];
-    const incompleteSlices = slices.filter(s => !isClosedStatus(s.status));
-    assert.ok(
-      incompleteSlices.length > 0,
-      "milestone is not completable — has incomplete slices",
-    );
-    assert.equal(incompleteSlices[0]?.id, "S02", "S02 is the incomplete slice");
-    assert.equal(incompleteSlices[0]?.status, "pending", "S02 status is 'pending'");
-  });
-
-  // ─── Test 8: closed parent blocks child completion ───────────────────────
-  test("closed parent blocks child completion", () => {
-    // Insert a milestone already in 'complete' state
-    insertMilestone({ id: "M001", status: "complete" });
-    insertSlice({ id: "S01", milestoneId: "M001" });
-
-    const milestone = getMilestone("M001");
-    assert.ok(milestone !== null, "milestone M001 exists");
-    assert.ok(
-      isClosedStatus(milestone!.status),
-      "parent milestone is closed — isClosedStatus returns true",
-    );
-
-    // The guard in complete-slice checks parent status via isClosedStatus.
-    // If isClosedStatus(milestone.status) === true, the child cannot be completed.
-    const parentIsClosed = isClosedStatus(milestone!.status);
-    assert.ok(parentIsClosed, "closed parent guard fires: milestone.status is 'complete'");
-
-    // Verify the slice itself is not yet closed
-    const slice = getSlice("M001", "S01");
-    assert.ok(slice !== null, "slice S01 exists");
-    assert.ok(!isClosedStatus(slice!.status), "slice S01 is not yet closed (parent is already closed)");
-  });
-
-});

package/src/resources/extensions/gsd/tests/db-path-worktree-symlink.test.ts

@@ -1,131 +0,0 @@
-/**
- * db-path-worktree-symlink.test.ts — #2517
- *
- * Regression test for the db_unavailable loop in worktree/symlink layouts.
- *
- * The path resolver must handle BOTH worktree path families:
- *   - /.gsd/worktrees/<MID>/...           (direct layout)
- *   - /.gsd/projects/<hash>/worktrees/<MID>/...  (symlink-resolved layout)
- *
- * When the second layout is not recognised, ensureDbOpen derives a wrong DB
- * path, the open fails silently, and every completion tool call returns
- * db_unavailable — triggering an artifact retry re-dispatch loop.
- *
- * Additionally, the post-unit artifact retry path must NOT retry when the
- * completion tool failed due to db_unavailable (infra failure), because
- * retrying can never succeed and causes cost spikes.
- */
-
-import { readFileSync } from "node:fs";
-import { join, sep } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-// ── Part 1: resolveProjectRootDbPath handles symlink-resolved layout ─────
-
-console.log("\n=== #2517 Part 1: resolveProjectRootDbPath symlink layout ===");
-
-// Import the resolver directly
-const { resolveProjectRootDbPath } = await import("../bootstrap/dynamic-tools.js");
-
-// Standard worktree layout (already works)
-const standardPath = `/home/user/myproject/.gsd/worktrees/M001/work`;
-const standardResult = resolveProjectRootDbPath(standardPath);
-assertEq(
-  standardResult,
-  join("/home/user/myproject", ".gsd", "gsd.db"),
-  "Standard worktree layout resolves to project root DB path",
-);
-
-// Symlink-resolved layout (the regression — /.gsd/projects/<hash>/worktrees/...)
-const symlinkPath = `/home/user/myproject/.gsd/projects/abc123def/worktrees/M001/work`;
-const symlinkResult = resolveProjectRootDbPath(symlinkPath);
-assertEq(
-  symlinkResult,
-  join("/home/user/myproject", ".gsd", "gsd.db"),
-  "Symlink-resolved layout (/.gsd/projects/<hash>/worktrees/) resolves to project root DB path (#2517)",
-);
-
-// Windows-style separators for symlink layout
-if (sep === "\\") {
-  const winSymlinkPath = `C:\\Users\\dev\\project\\.gsd\\projects\\abc123def\\worktrees\\M001\\work`;
-  const winResult = resolveProjectRootDbPath(winSymlinkPath);
-  assertEq(
-    winResult,
-    join("C:\\Users\\dev\\project", ".gsd", "gsd.db"),
-    "Windows symlink layout resolves correctly",
-  );
-} else {
-  // On non-Windows, test forward-slash variant explicitly
-  const fwdSymlinkPath = `/home/user/myproject/.gsd/projects/abc123def/worktrees/M001/work`;
-  const fwdResult = resolveProjectRootDbPath(fwdSymlinkPath);
-  assertEq(
-    fwdResult,
-    join("/home/user/myproject", ".gsd", "gsd.db"),
-    "Forward-slash symlink layout resolves correctly on POSIX",
-  );
-}
-
-// Edge: deeper nesting under projects/<hash>/worktrees
-const deepSymlinkPath = `/home/user/myproject/.gsd/projects/deadbeef42/worktrees/M003/sub/dir`;
-const deepResult = resolveProjectRootDbPath(deepSymlinkPath);
-assertEq(
-  deepResult,
-  join("/home/user/myproject", ".gsd", "gsd.db"),
-  "Deep symlink worktree path still resolves to project root DB",
-);
-
-// Non-worktree path should be unchanged
-const normalPath = `/home/user/myproject`;
-const normalResult = resolveProjectRootDbPath(normalPath);
-assertEq(
-  normalResult,
-  join("/home/user/myproject", ".gsd", "gsd.db"),
-  "Non-worktree path is unchanged",
-);
-
-// ── Part 2: ensureDbOpen returns structured failure context ──────────────
-
-console.log("\n=== #2517 Part 2: ensureDbOpen structured diagnostics ===");
-
-const dynamicToolsSrc = readFileSync(
-  join(import.meta.dirname, "..", "bootstrap", "dynamic-tools.ts"),
-  "utf-8",
-);
-
-// ensureDbOpen should return a structured result, not just boolean false
-// Check that the catch block provides diagnostic information
-assertTrue(
-  dynamicToolsSrc.includes("resolvedPath") || dynamicToolsSrc.includes("diagnostic"),
-  "ensureDbOpen catch block surfaces diagnostic information (resolvedPath or diagnostic) instead of bare false (#2517)",
-);
-
-// ── Part 3: post-unit does NOT artifact-retry on db_unavailable ──────────
-
-console.log("\n=== #2517 Part 3: post-unit db_unavailable is infra-fatal ===");
-
-const postUnitSrc = readFileSync(
-  join(import.meta.dirname, "..", "auto-post-unit.ts"),
-  "utf-8",
-);
-
-// The artifact retry block should check DB availability and skip retry
-// when the DB is unavailable (infra failure, not a missing artifact).
-assertTrue(
-  postUnitSrc.includes("db_unavailable") || postUnitSrc.includes("isDbAvailable"),
-  "post-unit artifact retry path checks DB availability to avoid retry loop (#2517)",
-);
-
-// Verify the retry block is guarded: when !isDbAvailable(), the code must
-// NOT return "retry". The pattern should be: if (!verified && !isDbAvailable()) { skip }
-// followed by else if (!verified) { ... return "retry" }
-const dbUnavailableGuard = postUnitSrc.match(
-  /!triggerArtifactVerified\s*&&\s*!isDbAvailable\(\)/,
-);
-assertTrue(
-  !!dbUnavailableGuard,
-  "The retry block explicitly guards against !isDbAvailable() before returning 'retry' (#2517)",
-);
-
-report();

package/src/resources/extensions/gsd/tests/discord-invite-links.test.ts

@@ -1,47 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-/**
- * Validates that all Discord invite links in user-facing files point to valid,
- * consistent invite URLs — not expired vanity links.
- *
- * Regression test for https://github.com/gsd-build/gsd-2/issues/2699
- */
-
-const ROOT = process.cwd();
-
-/** Canonical Discord invite for the GSD community. */
-const VALID_INVITE = "https://discord.com/invite/nKXTsAcmbT";
-
-/** Files that contain user-facing Discord invite links. */
-const FILES_WITH_INVITE_LINKS: string[] = [
-  "README.md",
-  "docs/what-is-pi/15-pi-packages-the-ecosystem.md",
-];
-
-describe("Discord invite links (#2699)", () => {
-  for (const relPath of FILES_WITH_INVITE_LINKS) {
-    it(`${relPath} contains only the canonical Discord invite`, () => {
-      const content = readFileSync(join(ROOT, relPath), "utf8");
-
-      // Extract all Discord invite URLs (discord.gg/X or discord.com/invite/X)
-      const invitePattern = /https?:\/\/(?:discord\.gg|discord\.com\/invite)\/[A-Za-z0-9]+/g;
-      const matches = content.match(invitePattern);
-
-      assert.ok(
-        matches && matches.length > 0,
-        `Expected at least one Discord invite link in ${relPath}`,
-      );
-
-      for (const link of matches) {
-        assert.equal(
-          link,
-          VALID_INVITE,
-          `Invalid Discord invite in ${relPath}: found "${link}", expected "${VALID_INVITE}"`,
-        );
-      }
-    });
-  }
-});

package/src/resources/extensions/gsd/tests/discuss-empty-db-fallback.test.ts

@@ -1,127 +0,0 @@
-/**
- * discuss-empty-db-fallback.test.ts — Tests for #2892.
- *
- * When the DB is open but empty (e.g., after crash/truncation),
- * getMilestoneSlices() returns [] and showDiscuss() incorrectly declares
- * "All slices are complete." The fix adds a roadmap fallback: when the DB
- * returns zero slices but a ROADMAP file exists, parse slices from the
- * roadmap instead of treating zero slices as "all complete."
- */
-
-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";
-import { parseRoadmapSlices } from "../roadmap-slices.ts";
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function readGuidedFlowSource(): string {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = dirname(thisFile);
-  return readFileSync(join(thisDir, "..", "guided-flow.ts"), "utf-8");
-}
-
-const SAMPLE_ROADMAP = `# M012 Roadmap
-
-## Slices
-- [ ] **S01: Core setup** \`risk:low\` \`depends:[]\`
-  > After this: basic project scaffolding works
-- [ ] **S02: Auth module** \`risk:medium\` \`depends:[S01]\`
-  > After this: users can log in
-- [ ] **S03: Dashboard** \`risk:low\` \`depends:[S02]\`
-  > After this: dashboard renders
-`;
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-describe("discuss-empty-db-fallback (#2892)", () => {
-
-  test("1. parseRoadmapSlices extracts slices from a valid ROADMAP", () => {
-    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
-    assert.strictEqual(slices.length, 3, "should parse 3 slices from sample roadmap");
-    assert.strictEqual(slices[0]!.id, "S01");
-    assert.strictEqual(slices[1]!.id, "S02");
-    assert.strictEqual(slices[2]!.id, "S03");
-    // All slices are incomplete ([ ] not [x])
-    assert.ok(slices.every(s => !s.done), "all slices should be incomplete");
-  });
-
-  test("2. guided-flow imports parseRoadmapSlices for roadmap fallback", () => {
-    const source = readGuidedFlowSource();
-    assert.ok(
-      source.includes("parseRoadmapSlices"),
-      "guided-flow must import parseRoadmapSlices to support roadmap fallback when DB is empty",
-    );
-  });
-
-  test("3. guided-flow has roadmap fallback when normSlices is empty but roadmapContent exists", () => {
-    const source = readGuidedFlowSource();
-    // The fix must add a fallback that checks normSlices.length === 0 && roadmapContent
-    // and repopulates normSlices from the roadmap before the pendingSlices guard.
-    //
-    // Pattern: after DB query produces normSlices, if empty + roadmap exists,
-    // fall back to parseRoadmapSlices(roadmapContent).
-    const fallbackPattern = /normSlices\.length\s*===\s*0\s*&&\s*roadmapContent/;
-    assert.ok(
-      fallbackPattern.test(source),
-      "guided-flow must check normSlices.length === 0 && roadmapContent to trigger roadmap fallback",
-    );
-  });
-
-  test("4. guided-flow no longer has unguarded pendingSlices === 0 exit after DB-only query", () => {
-    const source = readGuidedFlowSource();
-    // Extract the showDiscuss function body
-    const fnMatch = source.match(
-      /async function showDiscuss\s*\([^)]*\)[^{]*\{([\s\S]*?)\nfunction\s/,
-    );
-    assert.ok(!!fnMatch, "showDiscuss function body must be found");
-
-    if (fnMatch) {
-      const body = fnMatch[1]!;
-      // After the DB query block (isDbAvailable/getMilestoneSlices), there should
-      // be a roadmap fallback BEFORE the pendingSlices.length === 0 check.
-      // Find the getMilestoneSlices call and the pendingSlices === 0 check
-      const dbQueryIdx = body.indexOf("getMilestoneSlices");
-      const fallbackIdx = body.indexOf("parseRoadmapSlices");
-      const pendingGuardIdx = body.indexOf('pendingSlices.length === 0');
-
-      assert.ok(dbQueryIdx > 0, "getMilestoneSlices call must exist");
-      assert.ok(fallbackIdx > 0, "parseRoadmapSlices fallback must exist");
-      assert.ok(pendingGuardIdx > 0, "pendingSlices.length === 0 guard must exist");
-      assert.ok(
-        fallbackIdx > dbQueryIdx && fallbackIdx < pendingGuardIdx,
-        "parseRoadmapSlices fallback must appear BETWEEN DB query and pendingSlices === 0 guard",
-      );
-    }
-  });
-
-  test("5. roadmap-parsed slices map to NormSlice format with done=false by default", () => {
-    // When falling back to roadmap, incomplete slices ([ ]) should map to done:false,
-    // ensuring they appear as pending and are NOT falsely reported as complete.
-    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
-    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
-    const pendingSlices = normSlices.filter(s => !s.done);
-    assert.strictEqual(pendingSlices.length, 3,
-      "all 3 incomplete roadmap slices should be pending — not falsely treated as complete");
-  });
-
-  test("6. roadmap with completed slices correctly reports them as done", () => {
-    const completedRoadmap = `# M012 Roadmap
-
-## Slices
-- [x] **S01: Core setup** \`risk:low\` \`depends:[]\`
-  > After this: basic project scaffolding works
-- [ ] **S02: Auth module** \`risk:medium\` \`depends:[S01]\`
-  > After this: users can log in
-- [x] **S03: Dashboard** \`risk:low\` \`depends:[S02]\`
-  > After this: dashboard renders
-`;
-    const slices = parseRoadmapSlices(completedRoadmap);
-    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
-    const pendingSlices = normSlices.filter(s => !s.done);
-    assert.strictEqual(pendingSlices.length, 1, "only S02 should be pending");
-    assert.strictEqual(pendingSlices[0]!.id, "S02");
-  });
-});

package/src/resources/extensions/gsd/tests/dynamic-routing-default.test.ts

@@ -1,20 +0,0 @@
-/**
- * Dynamic routing default — verifies routing is enabled by default.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { defaultRoutingConfig } from "../model-router.js";
-
-test("defaultRoutingConfig returns enabled: true", () => {
-  const config = defaultRoutingConfig();
-  assert.equal(config.enabled, true, "dynamic routing should be enabled by default");
-});
-
-test("defaultRoutingConfig enables all routing features", () => {
-  const config = defaultRoutingConfig();
-  assert.equal(config.escalate_on_failure, true);
-  assert.equal(config.budget_pressure, true);
-  assert.equal(config.cross_provider, true);
-  assert.equal(config.hooks, true);
-});

package/src/resources/extensions/gsd/tests/empty-content-abort-loop.test.ts

@@ -1,74 +0,0 @@
-/**
- * empty-content-abort-loop.test.ts — Regression test for #2695.
- *
- * When the LLM sends an assistant message with empty `content: []` and
- * `stopReason: "aborted"`, this is NOT a fatal abort — it is a non-fatal
- * end-of-turn. The abort handler in agent-end-recovery.ts must distinguish
- * this case and NOT pause auto-mode, allowing the loop to continue via
- * resolveAgentEnd instead of entering a stuck re-dispatch loop.
- */
-
-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";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const RECOVERY_PATH = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
-
-function getRecoverySource(): string {
-  return readFileSync(RECOVERY_PATH, "utf-8");
-}
-
-test("agent-end-recovery.ts does not pause on aborted messages with empty content (#2695)", () => {
-  const source = getRecoverySource();
-
-  // The abort handler at `stopReason === "aborted"` must check for empty content
-  // before deciding to pause. An empty content array is a non-fatal agent stop.
-  const abortIdx = source.indexOf('stopReason === "aborted"');
-  assert.ok(abortIdx > -1, "abort handler must exist in agent-end-recovery.ts");
-
-  // Extract the region around the abort handler (enough to see the guard logic)
-  const abortRegion = source.slice(Math.max(0, abortIdx - 200), abortIdx + 600);
-
-  // Must check for empty content before pausing
-  assert.ok(
-    abortRegion.includes("content") && (abortRegion.includes("length") || abortRegion.includes("?.length")),
-    "abort handler must inspect content array length to distinguish empty-content aborts from fatal aborts (#2695)",
-  );
-});
-
-test("agent-end-recovery.ts routes empty-content aborted messages to resolveAgentEnd (#2695)", () => {
-  const source = getRecoverySource();
-
-  // The abort block must have a path that calls resolveAgentEnd for empty-content messages
-  // instead of unconditionally calling pauseAuto
-  const abortIdx = source.indexOf('stopReason === "aborted"');
-  assert.ok(abortIdx > -1, "abort handler must exist");
-
-  // Get the full abort handling block (from the if to the next stopReason check or success path)
-  const afterAbort = source.slice(abortIdx, abortIdx + 800);
-
-  // The abort block must have a code path that calls resolveAgentEnd (for empty-content case)
-  assert.ok(
-    afterAbort.includes("resolveAgentEnd"),
-    "abort handler must route empty-content aborted messages to resolveAgentEnd instead of always pausing (#2695)",
-  );
-});
-
-test("agent-end-recovery.ts checks for errorMessage presence in abort handler (#2695)", () => {
-  const source = getRecoverySource();
-
-  const abortIdx = source.indexOf('stopReason === "aborted"');
-  assert.ok(abortIdx > -1, "abort handler must exist");
-
-  const abortRegion = source.slice(abortIdx, abortIdx + 600);
-
-  // Fatal aborts should have error context (errorMessage field).
-  // The handler should check for this to distinguish fatal from non-fatal aborts.
-  assert.ok(
-    abortRegion.includes("errorMessage"),
-    "abort handler must check for errorMessage to distinguish fatal aborts from empty-content non-fatal stops (#2695)",
-  );
-});