gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/tests/migrate-writer.test.ts

@@ -1,398 +0,0 @@
-// Migration writer format round-trip test suite
-// Tests that format functions produce output that parses back correctly
-// through parseRoadmap(), parsePlan(), parseSummary(), and parseRequirementCounts().
-// Pure in-memory tests — no filesystem needed.
-
-import {
-  formatRoadmap,
-  formatPlan,
-  formatSliceSummary,
-  formatTaskSummary,
-  formatTaskPlan,
-  formatRequirements,
-  formatProject,
-  formatDecisions,
-  formatContext,
-  formatState,
-} from '../migrate/writer.ts';
-import {
-  parseRoadmap,
-  parsePlan,
-  parseSummary,
-  parseRequirementCounts,
-} from '../files.ts';
-import type {
-  GSDMilestone,
-  GSDSlice,
-  GSDTask,
-  GSDRequirement,
-  GSDSliceSummaryData,
-  GSDTaskSummaryData,
-} from '../migrate/types.ts';
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-// ─── Test Data Builders ────────────────────────────────────────────────────
-
-function makeTask(overrides: Partial<GSDTask> = {}): GSDTask {
-  return {
-    id: 'T01',
-    title: 'Setup Auth',
-    description: 'Implement authentication',
-    done: false,
-    estimate: '30m',
-    files: ['src/auth.ts'],
-    mustHaves: ['JWT support'],
-    summary: null,
-    ...overrides,
-  };
-}
-
-function makeSlice(overrides: Partial<GSDSlice> = {}): GSDSlice {
-  return {
-    id: 'S01',
-    title: 'Auth System',
-    risk: 'medium' as const,
-    depends: [],
-    done: false,
-    demo: 'Login flow works end-to-end',
-    goal: 'Working authentication',
-    tasks: [makeTask()],
-    research: null,
-    summary: null,
-    ...overrides,
-  };
-}
-
-function makeMilestone(overrides: Partial<GSDMilestone> = {}): GSDMilestone {
-  return {
-    id: 'M001',
-    title: 'Core Platform',
-    vision: 'Build the core platform',
-    successCriteria: ['All tests pass', 'Deploy to staging'],
-    slices: [makeSlice()],
-    research: null,
-    boundaryMap: [],
-    ...overrides,
-  };
-}
-
-function makeSliceSummary(overrides: Partial<GSDSliceSummaryData> = {}): GSDSliceSummaryData {
-  return {
-    completedAt: '2026-03-10',
-    provides: ['auth-flow', 'jwt-tokens'],
-    keyFiles: ['src/auth.ts', 'src/middleware.ts'],
-    keyDecisions: ['Use JWT over sessions'],
-    patternsEstablished: ['Middleware pattern'],
-    duration: '2h',
-    whatHappened: 'Implemented full auth system with JWT.',
-    ...overrides,
-  };
-}
-
-function makeTaskSummary(overrides: Partial<GSDTaskSummaryData> = {}): GSDTaskSummaryData {
-  return {
-    completedAt: '2026-03-09',
-    provides: ['auth-endpoint'],
-    keyFiles: ['src/auth.ts'],
-    duration: '45m',
-    whatHappened: 'Built the auth endpoint.',
-    ...overrides,
-  };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Scenario A: Roadmap round-trip with 2 slices (1 done, 1 not)
-// ═══════════════════════════════════════════════════════════════════════════
-
-{
-  const milestone = makeMilestone({
-    slices: [
-      makeSlice({
-        id: 'S01',
-        title: 'Auth System',
-        risk: 'high',
-        depends: [],
-        done: true,
-        demo: 'Login flow works',
-      }),
-      makeSlice({
-        id: 'S02',
-        title: 'Dashboard',
-        risk: 'low',
-        depends: ['S01'],
-        done: false,
-        demo: 'Dashboard renders data',
-      }),
-    ],
-  });
-
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-
-  assertEq(parsed.title, 'M001: Core Platform', 'roadmap: title');
-  assertEq(parsed.vision, 'Build the core platform', 'roadmap: vision');
-  assertEq(parsed.successCriteria.length, 2, 'roadmap: successCriteria count');
-  assertEq(parsed.successCriteria[0], 'All tests pass', 'roadmap: successCriteria[0]');
-  assertEq(parsed.successCriteria[1], 'Deploy to staging', 'roadmap: successCriteria[1]');
-  assertEq(parsed.slices.length, 2, 'roadmap: slices count');
-
-  assertEq(parsed.slices[0].id, 'S01', 'roadmap: S01 id');
-  assertEq(parsed.slices[0].title, 'Auth System', 'roadmap: S01 title');
-  assertEq(parsed.slices[0].done, true, 'roadmap: S01 done');
-  assertEq(parsed.slices[0].risk, 'high', 'roadmap: S01 risk');
-  assertEq(parsed.slices[0].depends.length, 0, 'roadmap: S01 depends empty');
-  assertEq(parsed.slices[0].demo, 'Login flow works', 'roadmap: S01 demo');
-
-  assertEq(parsed.slices[1].id, 'S02', 'roadmap: S02 id');
-  assertEq(parsed.slices[1].title, 'Dashboard', 'roadmap: S02 title');
-  assertEq(parsed.slices[1].done, false, 'roadmap: S02 done');
-  assertEq(parsed.slices[1].risk, 'low', 'roadmap: S02 risk');
-  assertEq(parsed.slices[1].depends, ['S01'], 'roadmap: S02 depends');
-  assertEq(parsed.slices[1].demo, 'Dashboard renders data', 'roadmap: S02 demo');
-
-  assertEq(parsed.boundaryMap.length, 0, 'roadmap: boundaryMap empty');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Scenario B: Plan round-trip with 3 tasks (mixed done)
-// ═══════════════════════════════════════════════════════════════════════════
-
-{
-  const slice = makeSlice({
-    id: 'S01',
-    title: 'Auth System',
-    goal: 'Working authentication system',
-    demo: 'Login works with valid credentials',
-    tasks: [
-      makeTask({ id: 'T01', title: 'Setup Models', done: true, estimate: '15m', description: 'Define user model' }),
-      makeTask({ id: 'T02', title: 'Build Endpoints', done: false, estimate: '30m', description: 'REST API endpoints' }),
-      makeTask({ id: 'T03', title: 'Write Tests', done: true, estimate: '20m', description: 'Unit and integration tests' }),
-    ],
-  });
-
-  const output = formatPlan(slice);
-  const parsed = parsePlan(output);
-
-  assertEq(parsed.id, 'S01', 'plan: id');
-  assertEq(parsed.title, 'Auth System', 'plan: title');
-  assertEq(parsed.goal, 'Working authentication system', 'plan: goal');
-  assertEq(parsed.demo, 'Login works with valid credentials', 'plan: demo');
-  assertEq(parsed.tasks.length, 3, 'plan: tasks count');
-
-  assertEq(parsed.tasks[0].id, 'T01', 'plan: T01 id');
-  assertEq(parsed.tasks[0].title, 'Setup Models', 'plan: T01 title');
-  assertEq(parsed.tasks[0].done, true, 'plan: T01 done');
-  assertEq(parsed.tasks[0].estimate, '15m', 'plan: T01 estimate');
-
-  assertEq(parsed.tasks[1].id, 'T02', 'plan: T02 id');
-  assertEq(parsed.tasks[1].done, false, 'plan: T02 done');
-  assertEq(parsed.tasks[1].estimate, '30m', 'plan: T02 estimate');
-
-  assertEq(parsed.tasks[2].id, 'T03', 'plan: T03 id');
-  assertEq(parsed.tasks[2].done, true, 'plan: T03 done');
-  assertEq(parsed.tasks[2].estimate, '20m', 'plan: T03 estimate');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Scenario C: Slice summary round-trip with full data
-// ═══════════════════════════════════════════════════════════════════════════
-
-{
-  const slice = makeSlice({
-    id: 'S01',
-    title: 'Auth System',
-    done: true,
-    summary: makeSliceSummary(),
-  });
-
-  const output = formatSliceSummary(slice, 'M001');
-  const parsed = parseSummary(output);
-
-  assertEq(parsed.frontmatter.id, 'S01', 'sliceSummary: id');
-  assertEq(parsed.frontmatter.parent, 'M001', 'sliceSummary: parent');
-  assertEq(parsed.frontmatter.milestone, 'M001', 'sliceSummary: milestone');
-  assertEq(parsed.frontmatter.provides, ['auth-flow', 'jwt-tokens'], 'sliceSummary: provides');
-  assertEq(parsed.frontmatter.requires.length, 0, 'sliceSummary: requires empty');
-  assertEq(parsed.frontmatter.affects.length, 0, 'sliceSummary: affects empty');
-  assertEq(parsed.frontmatter.key_files, ['src/auth.ts', 'src/middleware.ts'], 'sliceSummary: key_files');
-  assertEq(parsed.frontmatter.key_decisions, ['Use JWT over sessions'], 'sliceSummary: key_decisions');
-  assertEq(parsed.frontmatter.patterns_established, ['Middleware pattern'], 'sliceSummary: patterns_established');
-  assertEq(parsed.frontmatter.duration, '2h', 'sliceSummary: duration');
-  assertEq(parsed.frontmatter.completed_at, '2026-03-10', 'sliceSummary: completed_at');
-  assertEq(parsed.frontmatter.verification_result, 'passed', 'sliceSummary: verification_result');
-  assertEq(parsed.frontmatter.blocker_discovered, false, 'sliceSummary: blocker_discovered');
-  assertTrue(parsed.whatHappened.includes('Implemented full auth system'), 'sliceSummary: whatHappened content');
-  assertEq(parsed.title, 'S01: Auth System', 'sliceSummary: title');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Scenario D: Task summary round-trip
-// ═══════════════════════════════════════════════════════════════════════════
-
-{
-  const task = makeTask({
-    id: 'T01',
-    title: 'Setup Auth',
-    done: true,
-    summary: makeTaskSummary(),
-  });
-
-  const output = formatTaskSummary(task, 'S01', 'M001');
-  const parsed = parseSummary(output);
-
-  assertEq(parsed.frontmatter.id, 'T01', 'taskSummary: id');
-  assertEq(parsed.frontmatter.parent, 'S01', 'taskSummary: parent');
-  assertEq(parsed.frontmatter.milestone, 'M001', 'taskSummary: milestone');
-  assertEq(parsed.frontmatter.provides, ['auth-endpoint'], 'taskSummary: provides');
-  assertEq(parsed.frontmatter.key_files, ['src/auth.ts'], 'taskSummary: key_files');
-  assertEq(parsed.frontmatter.duration, '45m', 'taskSummary: duration');
-  assertEq(parsed.frontmatter.completed_at, '2026-03-09', 'taskSummary: completed_at');
-  assertTrue(parsed.whatHappened.includes('Built the auth endpoint'), 'taskSummary: whatHappened content');
-  assertEq(parsed.title, 'T01: Setup Auth', 'taskSummary: title');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Scenario E: Requirements round-trip with mixed statuses
-// ═══════════════════════════════════════════════════════════════════════════
-
-{
-  const requirements: GSDRequirement[] = [
-    { id: 'R001', title: 'Auth Required', class: 'core-capability', status: 'active', description: 'Must have auth', source: 'spec', primarySlice: 'S01' },
-    { id: 'R002', title: 'Logging', class: 'observability', status: 'active', description: 'Must log', source: 'spec', primarySlice: 'S02' },
-    { id: 'R003', title: 'OAuth Support', class: 'core-capability', status: 'validated', description: 'OAuth working', source: 'testing', primarySlice: 'S01' },
-    { id: 'R004', title: 'Dark Mode', class: 'ui', status: 'deferred', description: 'Nice to have', source: 'feedback', primarySlice: 'none' },
-    { id: 'R005', title: 'Legacy API', class: 'compat', status: 'out-of-scope', description: 'Dropped', source: 'decision', primarySlice: 'none' },
-  ];
-
-  const output = formatRequirements(requirements);
-  const counts = parseRequirementCounts(output);
-
-  assertEq(counts.active, 2, 'requirements: active count');
-  assertEq(counts.validated, 1, 'requirements: validated count');
-  assertEq(counts.deferred, 1, 'requirements: deferred count');
-  assertEq(counts.outOfScope, 1, 'requirements: outOfScope count');
-  assertEq(counts.total, 5, 'requirements: total count');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Scenario F: Edge cases
-// ═══════════════════════════════════════════════════════════════════════════
-
-// F1: Empty vision → fallback text
-{
-  const milestone = makeMilestone({ vision: '' });
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-  assertEq(parsed.vision, '(migrated project)', 'edge: empty vision fallback');
-}
-
-// F2: Empty successCriteria → empty array
-{
-  const milestone = makeMilestone({ successCriteria: [] });
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-  assertEq(parsed.successCriteria.length, 0, 'edge: empty successCriteria');
-}
-
-// F3: Empty tasks → empty array in parsed plan
-{
-  const slice = makeSlice({ tasks: [] });
-  const output = formatPlan(slice);
-  const parsed = parsePlan(output);
-  assertEq(parsed.tasks.length, 0, 'edge: empty tasks');
-}
-
-// F4: Null summary → empty string from formatSliceSummary
-{
-  const slice = makeSlice({ summary: null });
-  const output = formatSliceSummary(slice, 'M001');
-  assertEq(output, '', 'edge: null summary returns empty string');
-}
-
-// F5: Done=true checkbox in roadmap
-{
-  const milestone = makeMilestone({
-    slices: [makeSlice({ id: 'S01', done: true })],
-  });
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-  assertEq(parsed.slices[0].done, true, 'edge: done checkbox true');
-}
-
-// F6: Done=false checkbox in roadmap
-{
-  const milestone = makeMilestone({
-    slices: [makeSlice({ id: 'S01', done: false })],
-  });
-  const output = formatRoadmap(milestone);
-  const parsed = parseRoadmap(output);
-  assertEq(parsed.slices[0].done, false, 'edge: done checkbox false');
-}
-
-// F7: Null task summary → empty string from formatTaskSummary
-{
-  const task = makeTask({ summary: null });
-  const output = formatTaskSummary(task, 'S01', 'M001');
-  assertEq(output, '', 'edge: null task summary returns empty string');
-}
-
-// F8: Empty requirements → all zeros
-{
-  const output = formatRequirements([]);
-  const counts = parseRequirementCounts(output);
-  assertEq(counts.total, 0, 'edge: empty requirements total 0');
-}
-
-// F9: formatProject with empty content → produces valid stub
-{
-  const output = formatProject('');
-  assertTrue(output.includes('# Project'), 'edge: empty project has heading');
-  assertTrue(output.length > 10, 'edge: empty project not blank');
-}
-
-// F10: formatProject with existing content → passes through
-{
-  const content = '# My Project\n\nDescription here.\n';
-  const output = formatProject(content);
-  assertEq(output, content, 'edge: project passthrough');
-}
-
-// F11: formatDecisions with empty content → produces valid stub
-{
-  const output = formatDecisions('');
-  assertTrue(output.includes('# Decisions'), 'edge: empty decisions has heading');
-}
-
-// F12: formatContext produces valid content
-{
-  const output = formatContext('M001');
-  assertTrue(output.includes('M001'), 'edge: context mentions milestone');
-}
-
-// F13: formatState produces valid content
-{
-  const milestones = [makeMilestone({
-    slices: [
-      makeSlice({ done: true }),
-      makeSlice({ id: 'S02', done: false }),
-    ],
-  })];
-  const output = formatState(milestones);
-  assertTrue(output.includes('1/2'), 'edge: state shows slice progress');
-}
-
-// F14: Task with no estimate → no est backtick in plan
-{
-  const slice = makeSlice({
-    tasks: [makeTask({ id: 'T01', title: 'Quick Fix', estimate: '' })],
-  });
-  const output = formatPlan(slice);
-  const parsed = parsePlan(output);
-  assertEq(parsed.tasks[0].id, 'T01', 'edge: task no estimate id');
-  assertEq(parsed.tasks[0].estimate, '', 'edge: task no estimate empty');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-
-report();

package/dist/resources/extensions/gsd/tests/milestone-transition-worktree.test.ts

@@ -1,147 +0,0 @@
-/**
- * milestone-transition-worktree.test.ts — Tests for #616 fix.
- *
- * Verifies that when auto-mode transitions between milestones, the
- * worktree lifecycle is handled: old worktree merged, new worktree created.
- *
- * Uses source-level checks since the full auto-mode dispatch loop
- * requires the @gsd/pi-coding-agent runtime.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, realpathSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  isInAutoWorktree,
-  getAutoWorktreeOriginalBase,
-  mergeMilestoneToMain,
-} from "../auto-worktree.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-function run(command: string, cwd: string): string {
-  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-function createTempRepo(): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-mt-wt-test-")));
-  run("git init", dir);
-  run("git config user.email test@test.com", dir);
-  run("git config user.name Test", dir);
-  writeFileSync(join(dir, "README.md"), "# test\n");
-  // Mirror production: .gsd/worktrees/ is gitignored so autoCommitDirtyState
-  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
-  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
-  run("git add .", dir);
-  run("git commit -m init", dir);
-  run("git branch -M main", dir);
-  return dir;
-}
-
-function createMilestoneArtifacts(dir: string, mid: string): void {
-  const msDir = join(dir, ".gsd", "milestones", mid);
-  mkdirSync(msDir, { recursive: true });
-  writeFileSync(join(msDir, "CONTEXT.md"), `# ${mid} Context\n`);
-  const roadmap = [
-    `# ${mid}: Test Milestone`,
-    "**Vision**: testing",
-    "## Success Criteria",
-    "- It works",
-    "## Slices",
-    "- [x] S01 — First slice",
-  ].join("\n");
-  writeFileSync(join(msDir, `${mid}-ROADMAP.md`), roadmap);
-}
-
-// ─── Milestone transition: worktree swap ─────────────────────────────────────
-
-test("worktree swap on milestone transition: merge old, create new", () => {
-  const savedCwd = process.cwd();
-  let tempDir = "";
-
-  try {
-    tempDir = createTempRepo();
-
-    // Set up M001 and M002 milestone artifacts
-    createMilestoneArtifacts(tempDir, "M001");
-    createMilestoneArtifacts(tempDir, "M002");
-    run("git add .", tempDir);
-    run("git commit -m \"add milestones\"", tempDir);
-
-    // Phase 1: Create worktree for M001 (simulates auto-mode start)
-    const wt1 = createAutoWorktree(tempDir, "M001");
-    assert.equal(process.cwd(), wt1, "cwd should be in M001 worktree");
-    assert.ok(isInAutoWorktree(tempDir), "should be in auto-worktree");
-    assert.equal(getAutoWorktreeOriginalBase(), tempDir, "original base preserved");
-
-    // Add a commit in M001 worktree to simulate work
-    writeFileSync(join(wt1, "feature-m001.txt"), "M001 work\n");
-    run("git add .", wt1);
-    run("git commit -m \"feat(M001): add feature\"", wt1);
-
-    // Phase 2: Simulate milestone transition — merge M001, exit worktree
-    const roadmapPath = join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
-    const roadmapContent = readFileSync(roadmapPath, "utf-8");
-    mergeMilestoneToMain(tempDir, "M001", roadmapContent);
-
-    // After merge: cwd should be back at project root
-    assert.equal(process.cwd(), tempDir, "cwd restored to project root after merge");
-    assert.ok(!isInAutoWorktree(tempDir), "no longer in auto-worktree after merge");
-
-    // Verify M001 work was merged to main
-    const mainLog = run("git log --oneline -3", tempDir);
-    assert.ok(mainLog.includes("M001"), "M001 squash commit should be on main");
-
-    // Phase 3: Create new worktree for M002 (simulates new milestone)
-    const wt2 = createAutoWorktree(tempDir, "M002");
-    assert.equal(process.cwd(), wt2, "cwd should be in M002 worktree");
-    assert.ok(isInAutoWorktree(tempDir), "should be in M002 auto-worktree");
-
-    // The new worktree should have the M001 feature file (merged to main)
-    assert.ok(existsSync(join(wt2, "feature-m001.txt")), "M002 worktree inherits M001 merged work");
-
-    // Verify branch is correct
-    const branch = run("git branch --show-current", wt2);
-    assert.equal(branch, "milestone/M002", "M002 worktree on correct branch");
-
-    // Cleanup
-    teardownAutoWorktree(tempDir, "M002");
-  } finally {
-    process.chdir(savedCwd);
-    if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  }
-});
-
-// ─── Verify the transition code path exists in auto.ts ──────────────────────
-
-test("auto.ts milestone transition block contains worktree lifecycle", () => {
-  const autoSrc = readFileSync(
-    join(__dirname, "..", "auto.ts"),
-    "utf-8",
-  );
-
-  // The fix adds worktree merge + create inside the milestone transition block
-  assert.ok(
-    autoSrc.includes("Worktree lifecycle on milestone transition"),
-    "auto.ts should contain the worktree lifecycle comment marker",
-  );
-  assert.ok(
-    autoSrc.includes("mergeMilestoneToMain") && autoSrc.includes("mid !== s.currentMilestoneId"),
-    "auto.ts should call mergeMilestoneToMain during milestone transition",
-  );
-  assert.ok(
-    autoSrc.includes("createAutoWorktree") && autoSrc.includes("Created auto-worktree for"),
-    "auto.ts should create new worktree for incoming milestone",
-  );
-});

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

@@ -1,69 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { lookupModelCost, compareModelCost, BUNDLED_COST_TABLE } from "../model-cost-table.js";
-
-// ─── lookupModelCost ─────────────────────────────────────────────────────────
-
-test("lookupModelCost finds exact match", () => {
-  const entry = lookupModelCost("claude-opus-4-6");
-  assert.ok(entry);
-  assert.equal(entry.id, "claude-opus-4-6");
-  assert.ok(entry.inputPer1k > 0);
-  assert.ok(entry.outputPer1k > 0);
-});
-
-test("lookupModelCost strips provider prefix", () => {
-  const entry = lookupModelCost("anthropic/claude-opus-4-6");
-  assert.ok(entry);
-  assert.equal(entry.id, "claude-opus-4-6");
-});
-
-test("lookupModelCost returns undefined for unknown model", () => {
-  const entry = lookupModelCost("totally-unknown-model");
-  assert.equal(entry, undefined);
-});
-
-test("lookupModelCost finds haiku", () => {
-  const entry = lookupModelCost("claude-haiku-4-5");
-  assert.ok(entry);
-  assert.ok(entry.inputPer1k < 0.001, "haiku should be cheap");
-});
-
-// ─── compareModelCost ────────────────────────────────────────────────────────
-
-test("haiku is cheaper than opus", () => {
-  assert.ok(compareModelCost("claude-haiku-4-5", "claude-opus-4-6") < 0);
-});
-
-test("opus is more expensive than sonnet", () => {
-  assert.ok(compareModelCost("claude-opus-4-6", "claude-sonnet-4-6") > 0);
-});
-
-test("same model has equal cost", () => {
-  assert.equal(compareModelCost("claude-opus-4-6", "claude-opus-4-6"), 0);
-});
-
-// ─── BUNDLED_COST_TABLE ──────────────────────────────────────────────────────
-
-test("cost table has entries for all major providers", () => {
-  const ids = BUNDLED_COST_TABLE.map(e => e.id);
-  // Anthropic
-  assert.ok(ids.includes("claude-opus-4-6"));
-  assert.ok(ids.includes("claude-sonnet-4-6"));
-  assert.ok(ids.includes("claude-haiku-4-5"));
-  // OpenAI
-  assert.ok(ids.includes("gpt-4o"));
-  assert.ok(ids.includes("gpt-4o-mini"));
-  // Google
-  assert.ok(ids.includes("gemini-2.0-flash"));
-});
-
-test("all cost table entries have valid data", () => {
-  for (const entry of BUNDLED_COST_TABLE) {
-    assert.ok(entry.id, `entry missing id`);
-    assert.ok(entry.inputPer1k >= 0, `${entry.id} inputPer1k should be >= 0`);
-    assert.ok(entry.outputPer1k >= 0, `${entry.id} outputPer1k should be >= 0`);
-    assert.ok(entry.updatedAt, `${entry.id} missing updatedAt`);
-  }
-});