@nathapp/nax 0.27.1 → 0.29.0

package/test/unit/utils-helpers.test.ts

@@ -1,318 +0,0 @@
-// RE-ARCH: keep
-/**
- * Tests for src/execution/helpers.ts
- *
- * Covers: hookCtx, getAllReadyStories, acquireLock, releaseLock, formatProgress
- */
-
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import {
-  type StoryCounts,
-  acquireLock,
-  formatProgress,
-  getAllReadyStories,
-  hookCtx,
-  releaseLock,
-} from "../../src/execution/helpers";
-import type { PRD, UserStory } from "../../src/prd";
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Test fixtures
-// ─────────────────────────────────────────────────────────────────────────────
-
-const mockStory = (
-  id: string,
-  passes: boolean,
-  status: "pending" | "skipped",
-  dependencies: string[] = [],
-): UserStory => ({
-  id,
-  title: `Story ${id}`,
-  description: `Description for ${id}`,
-  acceptanceCriteria: [],
-  dependencies,
-  passes,
-  status,
-  estimatedComplexity: "medium",
-});
-
-const createMockPRD = (stories: UserStory[]): PRD => ({
-  feature: "test-feature",
-  userStories: stories,
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// hookCtx
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("hookCtx", () => {
-  it("creates hook context with minimal args", () => {
-    const ctx = hookCtx("my-feature");
-    expect(ctx.event).toBe("on-start");
-    expect(ctx.feature).toBe("my-feature");
-  });
-
-  it("merges optional fields", () => {
-    const ctx = hookCtx("my-feature", {
-      storyId: "US-001",
-      cost: 0.42,
-    });
-    expect(ctx.event).toBe("on-start");
-    expect(ctx.feature).toBe("my-feature");
-    expect(ctx.storyId).toBe("US-001");
-    expect(ctx.cost).toBe(0.42);
-  });
-
-  it("overrides defaults with opts", () => {
-    const ctx = hookCtx("my-feature", {
-      storyId: "US-999",
-    });
-    expect(ctx.storyId).toBe("US-999");
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// getAllReadyStories
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("getAllReadyStories", () => {
-  it("returns pending stories with no dependencies", () => {
-    const prd = createMockPRD([mockStory("US-001", false, "pending"), mockStory("US-002", false, "pending")]);
-
-    const ready = getAllReadyStories(prd);
-    expect(ready.length).toBe(2);
-    expect(ready.map((s) => s.id)).toEqual(["US-001", "US-002"]);
-  });
-
-  it("excludes stories that already passed", () => {
-    const prd = createMockPRD([mockStory("US-001", true, "pending"), mockStory("US-002", false, "pending")]);
-
-    const ready = getAllReadyStories(prd);
-    expect(ready.length).toBe(1);
-    expect(ready[0].id).toBe("US-002");
-  });
-
-  it("excludes skipped stories", () => {
-    const prd = createMockPRD([mockStory("US-001", false, "skipped"), mockStory("US-002", false, "pending")]);
-
-    const ready = getAllReadyStories(prd);
-    expect(ready.length).toBe(1);
-    expect(ready[0].id).toBe("US-002");
-  });
-
-  it("includes stories whose dependencies are complete", () => {
-    const prd = createMockPRD([
-      mockStory("US-001", true, "pending"),
-      mockStory("US-002", false, "pending", ["US-001"]),
-    ]);
-
-    const ready = getAllReadyStories(prd);
-    expect(ready.length).toBe(1);
-    expect(ready[0].id).toBe("US-002");
-  });
-
-  it("excludes stories with unsatisfied dependencies", () => {
-    const prd = createMockPRD([
-      mockStory("US-001", false, "pending"),
-      mockStory("US-002", false, "pending", ["US-001"]),
-    ]);
-
-    const ready = getAllReadyStories(prd);
-    expect(ready.length).toBe(1);
-    expect(ready[0].id).toBe("US-001");
-  });
-
-  it("handles complex dependency chains", () => {
-    const prd = createMockPRD([
-      mockStory("US-001", true, "pending"),
-      mockStory("US-002", true, "pending", ["US-001"]),
-      mockStory("US-003", false, "pending", ["US-001", "US-002"]),
-      mockStory("US-004", false, "pending", ["US-002"]),
-    ]);
-
-    const ready = getAllReadyStories(prd);
-    expect(ready.length).toBe(2);
-    expect(ready.map((s) => s.id).sort()).toEqual(["US-003", "US-004"]);
-  });
-
-  it("returns empty array when all stories are complete", () => {
-    const prd = createMockPRD([mockStory("US-001", true, "pending"), mockStory("US-002", true, "pending")]);
-
-    const ready = getAllReadyStories(prd);
-    expect(ready.length).toBe(0);
-  });
-
-  it("handles skipped dependencies correctly", () => {
-    const prd = createMockPRD([
-      mockStory("US-001", false, "skipped"),
-      mockStory("US-002", false, "pending", ["US-001"]),
-    ]);
-
-    const ready = getAllReadyStories(prd);
-    // US-002 is ready because US-001 is skipped (treated as complete)
-    expect(ready.length).toBe(1);
-    expect(ready[0].id).toBe("US-002");
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// acquireLock / releaseLock
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("acquireLock / releaseLock", () => {
-  let testDir: string;
-
-  beforeEach(() => {
-    // Create a temporary directory for lock tests
-    testDir = path.join(os.tmpdir(), `nax-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    fs.mkdirSync(testDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    // Clean up lock file and test directory
-    await releaseLock(testDir);
-    try {
-      fs.rmSync(testDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  it("acquires lock when no lock exists", async () => {
-    const acquired = await acquireLock(testDir);
-    expect(acquired).toBe(true);
-
-    // Verify lock file was created
-    const lockPath = path.join(testDir, "nax.lock");
-    expect(fs.existsSync(lockPath)).toBe(true);
-  });
-
-  it("fails to acquire lock when already locked", async () => {
-    const first = await acquireLock(testDir);
-    expect(first).toBe(true);
-
-    const second = await acquireLock(testDir);
-    expect(second).toBe(false);
-  });
-
-  it("releases lock successfully", async () => {
-    await acquireLock(testDir);
-    await releaseLock(testDir);
-
-    // Verify lock file was removed
-    const lockPath = path.join(testDir, "nax.lock");
-    expect(fs.existsSync(lockPath)).toBe(false);
-  });
-
-  it("can reacquire lock after release", async () => {
-    const first = await acquireLock(testDir);
-    expect(first).toBe(true);
-
-    await releaseLock(testDir);
-
-    const second = await acquireLock(testDir);
-    expect(second).toBe(true);
-  });
-
-  it("removes stale lock from dead process", async () => {
-    // Create a lock with a non-existent PID
-    const lockPath = path.join(testDir, "nax.lock");
-    const staleLock = {
-      pid: 999999, // Non-existent process
-      timestamp: Date.now() - 1000000,
-    };
-    fs.writeFileSync(lockPath, JSON.stringify(staleLock));
-
-    // Should acquire lock by removing stale lock
-    const acquired = await acquireLock(testDir);
-    expect(acquired).toBe(true);
-  });
-
-  it("handles non-existent directory gracefully during release", async () => {
-    const nonExistentDir = path.join(os.tmpdir(), "nax-nonexistent");
-    await expect(releaseLock(nonExistentDir)).resolves.toBeUndefined();
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// formatProgress
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("formatProgress", () => {
-  it("formats progress with all stories pending", () => {
-    const counts: StoryCounts = {
-      total: 12,
-      passed: 0,
-      failed: 0,
-      pending: 12,
-    };
-
-    const progress = formatProgress(counts, 0, 5.0, 0, 12);
-    expect(progress).toContain("0/12 stories");
-    expect(progress).toContain("0 passed");
-    expect(progress).toContain("0 failed");
-    expect(progress).toContain("$0.00/$5.00");
-    expect(progress).toContain("calculating...");
-  });
-
-  it("formats progress with some completed stories", () => {
-    const counts: StoryCounts = {
-      total: 12,
-      passed: 5,
-      failed: 1,
-      pending: 6,
-    };
-
-    const progress = formatProgress(counts, 0.45, 5.0, 600000, 12);
-    expect(progress).toContain("6/12 stories");
-    expect(progress).toContain("5 passed");
-    expect(progress).toContain("1 failed");
-    expect(progress).toContain("$0.45/$5.00");
-    expect(progress).toContain("min remaining");
-  });
-
-  it("formats progress when all stories complete", () => {
-    const counts: StoryCounts = {
-      total: 12,
-      passed: 10,
-      failed: 2,
-      pending: 0,
-    };
-
-    const progress = formatProgress(counts, 4.5, 5.0, 3600000, 12);
-    expect(progress).toContain("12/12 stories");
-    expect(progress).toContain("10 passed");
-    expect(progress).toContain("2 failed");
-    expect(progress).toContain("$4.50/$5.00");
-    expect(progress).toContain("complete");
-  });
-
-  it("calculates ETA correctly", () => {
-    const counts: StoryCounts = {
-      total: 10,
-      passed: 5,
-      failed: 0,
-      pending: 5,
-    };
-
-    // 5 completed in 600000ms (10 minutes) = 120000ms per story
-    // 5 remaining = 600000ms (10 minutes)
-    const progress = formatProgress(counts, 1.0, 5.0, 600000, 10);
-    expect(progress).toContain("~10 min remaining");
-  });
-
-  it("handles zero elapsed time", () => {
-    const counts: StoryCounts = {
-      total: 10,
-      passed: 1,
-      failed: 0,
-      pending: 9,
-    };
-
-    const progress = formatProgress(counts, 0.1, 5.0, 0, 10);
-    expect(progress).toContain("~0 min remaining");
-  });
-});

package/test/unit/verdict.test.ts

@@ -1,325 +0,0 @@
-// RE-ARCH: keep
-/**
- * Tests for src/tdd/verdict.ts
- *
- * Covers: readVerdict, cleanupVerdict, categorizeVerdict
- */
-
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { existsSync } from "node:fs";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { categorizeVerdict, cleanupVerdict, readVerdict } from "../../src/tdd/verdict";
-import type { VerifierVerdict } from "../../src/tdd/verdict";
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Test fixtures
-// ─────────────────────────────────────────────────────────────────────────────
-
-/** Build a fully valid verdict with sensible defaults. */
-function makeVerdict(overrides: Partial<VerifierVerdict> = {}): VerifierVerdict {
-  return {
-    version: 1,
-    approved: true,
-    tests: { allPassing: true, passCount: 10, failCount: 0 },
-    testModifications: { detected: false, files: [], legitimate: true, reasoning: "No modifications" },
-    acceptanceCriteria: {
-      allMet: true,
-      criteria: [{ criterion: "Feature works", met: true }],
-    },
-    quality: { rating: "good", issues: [] },
-    fixes: [],
-    reasoning: "All good.",
-    ...overrides,
-  };
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Setup / teardown
-// ─────────────────────────────────────────────────────────────────────────────
-
-let workdir: string;
-
-beforeEach(async () => {
-  workdir = path.join(tmpdir(), `verdict-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  await mkdir(workdir, { recursive: true });
-});
-
-afterEach(async () => {
-  await rm(workdir, { recursive: true, force: true });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// readVerdict
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("readVerdict", () => {
-  it("returns parsed verdict when file exists and is valid", async () => {
-    const verdict = makeVerdict();
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(verdict), "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).not.toBeNull();
-    expect(result?.version).toBe(1);
-    expect(result?.approved).toBe(true);
-    expect(result?.tests.allPassing).toBe(true);
-    expect(result?.tests.passCount).toBe(10);
-    expect(result?.tests.failCount).toBe(0);
-  });
-
-  it("returns null when file does not exist (no throw)", async () => {
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-
-  it("returns null when JSON is malformed (no throw, logs warning)", async () => {
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), "{ this is not valid json !!!", "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-
-  it("returns null when required field 'version' is missing", async () => {
-    const bad = { approved: true, tests: { allPassing: true, passCount: 5, failCount: 0 } };
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-
-  it("returns null when required field 'approved' is missing", async () => {
-    const bad = { version: 1, tests: { allPassing: true, passCount: 5, failCount: 0 } };
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-
-  it("returns null when required field 'tests' is missing", async () => {
-    const bad = { version: 1, approved: true };
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-
-  it("returns null when tests sub-fields are missing", async () => {
-    const bad = { version: 1, approved: true, tests: { allPassing: true } };
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-
-  it("returns null when version is not 1", async () => {
-    const bad = { version: 2, approved: true, tests: { allPassing: true, passCount: 5, failCount: 0 } };
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify(bad), "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-
-  it("returns null for empty JSON object", async () => {
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify({}), "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-
-  it("returns null for JSON array (not an object)", async () => {
-    await writeFile(path.join(workdir, ".nax-verifier-verdict.json"), JSON.stringify([1, 2, 3]), "utf-8");
-
-    const result = await readVerdict(workdir);
-    expect(result).toBeNull();
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// cleanupVerdict
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("cleanupVerdict", () => {
-  it("deletes the verdict file when it exists", async () => {
-    const verdictPath = path.join(workdir, ".nax-verifier-verdict.json");
-    await writeFile(verdictPath, JSON.stringify(makeVerdict()), "utf-8");
-
-    expect(existsSync(verdictPath)).toBe(true);
-
-    await cleanupVerdict(workdir);
-
-    expect(existsSync(verdictPath)).toBe(false);
-  });
-
-  it("does not throw when verdict file does not exist", async () => {
-    // Should not throw
-    await expect(cleanupVerdict(workdir)).resolves.toBeUndefined();
-  });
-
-  it("does not throw when called twice (second call is a no-op)", async () => {
-    const verdictPath = path.join(workdir, ".nax-verifier-verdict.json");
-    await writeFile(verdictPath, JSON.stringify(makeVerdict()), "utf-8");
-
-    await cleanupVerdict(workdir);
-    // Second call — file already gone
-    await expect(cleanupVerdict(workdir)).resolves.toBeUndefined();
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// categorizeVerdict — with valid verdict
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("categorizeVerdict — with verdict", () => {
-  it("returns success when approved=true", () => {
-    const result = categorizeVerdict(makeVerdict({ approved: true }), false);
-    expect(result.success).toBe(true);
-    expect(result.failureCategory).toBeUndefined();
-  });
-
-  it("returns success when approved=true regardless of testsPass", () => {
-    const result = categorizeVerdict(makeVerdict({ approved: true }), false);
-    expect(result.success).toBe(true);
-  });
-
-  it("returns verifier-rejected when illegitimate test modifications detected", () => {
-    const verdict = makeVerdict({
-      approved: false,
-      testModifications: {
-        detected: true,
-        files: ["test/foo.test.ts"],
-        legitimate: false,
-        reasoning: "Assertions loosened to hide failures",
-      },
-    });
-
-    const result = categorizeVerdict(verdict, true);
-    expect(result.success).toBe(false);
-    expect(result.failureCategory).toBe("verifier-rejected");
-    expect(result.reviewReason).toContain("illegitimate test modifications");
-    expect(result.reviewReason).toContain("test/foo.test.ts");
-  });
-
-  it("returns tests-failing when tests are not all passing", () => {
-    const verdict = makeVerdict({
-      approved: false,
-      tests: { allPassing: false, passCount: 8, failCount: 3 },
-      testModifications: { detected: false, files: [], legitimate: true, reasoning: "" },
-    });
-
-    const result = categorizeVerdict(verdict, false);
-    expect(result.success).toBe(false);
-    expect(result.failureCategory).toBe("tests-failing");
-    expect(result.reviewReason).toContain("3 failure(s)");
-  });
-
-  it("returns verifier-rejected when acceptance criteria not met", () => {
-    const verdict = makeVerdict({
-      approved: false,
-      tests: { allPassing: true, passCount: 10, failCount: 0 },
-      testModifications: { detected: false, files: [], legitimate: true, reasoning: "" },
-      acceptanceCriteria: {
-        allMet: false,
-        criteria: [
-          { criterion: "Feature works", met: true },
-          { criterion: "Error handling", met: false },
-        ],
-      },
-    });
-
-    const result = categorizeVerdict(verdict, true);
-    expect(result.success).toBe(false);
-    expect(result.failureCategory).toBe("verifier-rejected");
-    expect(result.reviewReason).toContain("Acceptance criteria not met");
-    expect(result.reviewReason).toContain("Error handling");
-  });
-
-  it("returns verifier-rejected when quality rating is poor", () => {
-    const verdict = makeVerdict({
-      approved: false,
-      tests: { allPassing: true, passCount: 10, failCount: 0 },
-      testModifications: { detected: false, files: [], legitimate: true, reasoning: "" },
-      acceptanceCriteria: {
-        allMet: true,
-        criteria: [{ criterion: "Feature works", met: true }],
-      },
-      quality: { rating: "poor", issues: ["Security vulnerability", "Memory leak"] },
-    });
-
-    const result = categorizeVerdict(verdict, true);
-    expect(result.success).toBe(false);
-    expect(result.failureCategory).toBe("verifier-rejected");
-    expect(result.reviewReason).toContain("Poor code quality");
-    expect(result.reviewReason).toContain("Security vulnerability");
-  });
-
-  it("returns verifier-rejected for catch-all (approved=false, no matching reason)", () => {
-    const verdict = makeVerdict({
-      approved: false,
-      tests: { allPassing: true, passCount: 10, failCount: 0 },
-      testModifications: { detected: false, files: [], legitimate: true, reasoning: "" },
-      acceptanceCriteria: { allMet: true, criteria: [] },
-      quality: { rating: "acceptable", issues: [] },
-      reasoning: "Something else went wrong",
-    });
-
-    const result = categorizeVerdict(verdict, true);
-    expect(result.success).toBe(false);
-    expect(result.failureCategory).toBe("verifier-rejected");
-    expect(result.reviewReason).toContain("Something else went wrong");
-  });
-
-  it("legitimate test modifications do not trigger verifier-rejected", () => {
-    const verdict = makeVerdict({
-      approved: false,
-      tests: { allPassing: false, passCount: 5, failCount: 2 },
-      testModifications: {
-        detected: true,
-        files: ["test/bar.test.ts"],
-        legitimate: true,
-        reasoning: "Tests updated to fix incorrect expected values",
-      },
-      acceptanceCriteria: { allMet: true, criteria: [] },
-      quality: { rating: "good", issues: [] },
-    });
-
-    // Should fall through to tests-failing (not illegitimate mod path)
-    const result = categorizeVerdict(verdict, false);
-    expect(result.failureCategory).toBe("tests-failing");
-  });
-
-  it("not-detected test modifications do not trigger verifier-rejected for test mods", () => {
-    const verdict = makeVerdict({
-      approved: false,
-      tests: { allPassing: false, passCount: 3, failCount: 4 },
-      testModifications: {
-        detected: false,
-        files: [],
-        legitimate: true,
-        reasoning: "",
-      },
-    });
-
-    const result = categorizeVerdict(verdict, false);
-    expect(result.failureCategory).toBe("tests-failing");
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// categorizeVerdict — null verdict (fallback)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe("categorizeVerdict — null verdict (fallback)", () => {
-  it("returns success when null verdict + testsPass=true", () => {
-    const result = categorizeVerdict(null, true);
-    expect(result.success).toBe(true);
-    expect(result.failureCategory).toBeUndefined();
-  });
-
-  it("returns tests-failing when null verdict + testsPass=false", () => {
-    const result = categorizeVerdict(null, false);
-    expect(result.success).toBe(false);
-    expect(result.failureCategory).toBe("tests-failing");
-    expect(result.reviewReason).toContain("no verdict file");
-  });
-});

package/test/unit/verification/orchestrator-types.test.ts

@@ -1,54 +0,0 @@
-// RE-ARCH: keep
-import { describe, expect, test } from "bun:test";
-import {
-  makeSkippedResult,
-  makePassResult,
-  makeFailResult,
-  type VerifyResult,
-} from "../../../src/verification/orchestrator-types";
-
-describe("makeSkippedResult", () => {
-  test("returns SKIPPED success result", () => {
-    const r = makeSkippedResult("US-001", "scoped");
-    expect(r.success).toBe(true);
-    expect(r.status).toBe("SKIPPED");
-    expect(r.storyId).toBe("US-001");
-    expect(r.strategy).toBe("scoped");
-    expect(r.countsTowardEscalation).toBe(false);
-    expect(r.failures).toEqual([]);
-  });
-});
-
-describe("makePassResult", () => {
-  test("returns PASS success result", () => {
-    const r = makePassResult("US-002", "regression", { passCount: 42, durationMs: 1234 });
-    expect(r.success).toBe(true);
-    expect(r.status).toBe("PASS");
-    expect(r.passCount).toBe(42);
-    expect(r.failCount).toBe(0);
-    expect(r.totalCount).toBe(42);
-    expect(r.durationMs).toBe(1234);
-    expect(r.countsTowardEscalation).toBe(false);
-  });
-});
-
-describe("makeFailResult", () => {
-  test("returns failure result with correct totals", () => {
-    const r = makeFailResult("US-003", "scoped", "TEST_FAILURE", {
-      passCount: 10,
-      failCount: 3,
-      durationMs: 5000,
-    });
-    expect(r.success).toBe(false);
-    expect(r.status).toBe("TEST_FAILURE");
-    expect(r.passCount).toBe(10);
-    expect(r.failCount).toBe(3);
-    expect(r.totalCount).toBe(13);
-    expect(r.countsTowardEscalation).toBe(true);
-  });
-
-  test("timeout does not count toward escalation by default when overridden", () => {
-    const r = makeFailResult("US-004", "scoped", "TIMEOUT", { countsTowardEscalation: false });
-    expect(r.countsTowardEscalation).toBe(false);
-  });
-});