gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/tests/memory-store.test.ts

@@ -1,345 +0,0 @@
-import { createTestContext } from './test-helpers.ts';
-import {
-  openDatabase,
-  closeDatabase,
-  isDbAvailable,
-  _getAdapter,
-} from '../gsd-db.ts';
-import {
-  getActiveMemories,
-  getActiveMemoriesRanked,
-  nextMemoryId,
-  createMemory,
-  updateMemoryContent,
-  reinforceMemory,
-  supersedeMemory,
-  isUnitProcessed,
-  markUnitProcessed,
-  decayStaleMemories,
-  enforceMemoryCap,
-  applyMemoryActions,
-  formatMemoriesForPrompt,
-} from '../memory-store.ts';
-import type { MemoryAction } from '../memory-store.ts';
-
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: fallback when DB not open
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: fallback returns empty when DB not open ===');
-{
-  closeDatabase();
-  assertTrue(!isDbAvailable(), 'DB should not be available');
-
-  assertEq(getActiveMemories(), [], 'getActiveMemories returns [] when DB closed');
-  assertEq(getActiveMemoriesRanked(), [], 'getActiveMemoriesRanked returns [] when DB closed');
-  assertEq(nextMemoryId(), 'MEM001', 'nextMemoryId returns MEM001 when DB closed');
-  assertEq(createMemory({ category: 'test', content: 'test' }), null, 'createMemory returns null when DB closed');
-  assertTrue(!reinforceMemory('MEM001'), 'reinforceMemory returns false when DB closed');
-  assertTrue(!isUnitProcessed('test/key'), 'isUnitProcessed returns false when DB closed');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: CRUD operations
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: create and query memories ===');
-{
-  openDatabase(':memory:');
-
-  // Create memories
-  const id1 = createMemory({ category: 'gotcha', content: 'esbuild drops .node binaries' });
-  assertTrue(id1 !== null, 'createMemory should return an ID');
-  assertEq(id1, 'MEM001', 'first memory ID should be MEM001');
-
-  const id2 = createMemory({ category: 'convention', content: 'use :memory: for tests', confidence: 0.9 });
-  assertEq(id2, 'MEM002', 'second memory ID should be MEM002');
-
-  const id3 = createMemory({ category: 'architecture', content: 'extensions discovered from src/resources/' });
-  assertEq(id3, 'MEM003', 'third memory ID should be MEM003');
-
-  // Query all active
-  const active = getActiveMemories();
-  assertEq(active.length, 3, 'should have 3 active memories');
-  assertEq(active[0].category, 'gotcha', 'first memory category');
-  assertEq(active[0].content, 'esbuild drops .node binaries', 'first memory content');
-  assertEq(active[1].confidence, 0.9, 'second memory confidence');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: update and reinforce
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: update and reinforce ===');
-{
-  openDatabase(':memory:');
-
-  createMemory({ category: 'gotcha', content: 'original content' });
-
-  // Update content
-  const updated = updateMemoryContent('MEM001', 'revised content', 0.95);
-  assertTrue(updated, 'updateMemoryContent should return true');
-
-  const active = getActiveMemories();
-  assertEq(active[0].content, 'revised content', 'content should be updated');
-  assertEq(active[0].confidence, 0.95, 'confidence should be updated');
-
-  // Reinforce
-  const reinforced = reinforceMemory('MEM001');
-  assertTrue(reinforced, 'reinforceMemory should return true');
-
-  const after = getActiveMemories();
-  assertEq(after[0].hit_count, 1, 'hit_count should be 1 after reinforce');
-
-  // Reinforce again
-  reinforceMemory('MEM001');
-  const after2 = getActiveMemories();
-  assertEq(after2[0].hit_count, 2, 'hit_count should be 2 after second reinforce');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: supersede
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: supersede ===');
-{
-  openDatabase(':memory:');
-
-  createMemory({ category: 'convention', content: 'old convention' });
-  createMemory({ category: 'convention', content: 'new convention' });
-
-  supersedeMemory('MEM001', 'MEM002');
-
-  const active = getActiveMemories();
-  assertEq(active.length, 1, 'should have 1 active memory after supersede');
-  assertEq(active[0].id, 'MEM002', 'active memory should be MEM002');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: ranked query ordering
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: ranked query ordering ===');
-{
-  openDatabase(':memory:');
-
-  // Low confidence, no hits
-  createMemory({ category: 'pattern', content: 'low ranking', confidence: 0.5 });
-  // High confidence, no hits
-  createMemory({ category: 'gotcha', content: 'high confidence', confidence: 0.95 });
-  // Medium confidence, many hits
-  createMemory({ category: 'convention', content: 'frequently used', confidence: 0.7 });
-
-  // Reinforce MEM003 multiple times to boost its ranking
-  for (let i = 0; i < 10; i++) reinforceMemory('MEM003');
-
-  const ranked = getActiveMemoriesRanked(10);
-  assertEq(ranked.length, 3, 'should have 3 ranked memories');
-  // MEM003: 0.7 * (1 + 10*0.1) = 0.7 * 2.0 = 1.4
-  // MEM002: 0.95 * (1 + 0*0.1) = 0.95
-  // MEM001: 0.5 * (1 + 0*0.1) = 0.5
-  assertEq(ranked[0].id, 'MEM003', 'highest ranked should be MEM003 (reinforced)');
-  assertEq(ranked[1].id, 'MEM002', 'second ranked should be MEM002 (high confidence)');
-  assertEq(ranked[2].id, 'MEM001', 'lowest ranked should be MEM001');
-
-  // Test limit
-  const limited = getActiveMemoriesRanked(2);
-  assertEq(limited.length, 2, 'limit should cap results');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: processed unit tracking
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: processed unit tracking ===');
-{
-  openDatabase(':memory:');
-
-  assertTrue(!isUnitProcessed('execute-task/M001/S01/T01'), 'should not be processed initially');
-
-  markUnitProcessed('execute-task/M001/S01/T01', '/path/to/activity.jsonl');
-
-  assertTrue(isUnitProcessed('execute-task/M001/S01/T01'), 'should be processed after marking');
-  assertTrue(!isUnitProcessed('execute-task/M001/S01/T02'), 'different key should not be processed');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: enforce memory cap
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: enforce memory cap ===');
-{
-  openDatabase(':memory:');
-
-  // Create 5 memories with varying confidence
-  createMemory({ category: 'gotcha', content: 'mem 1', confidence: 0.9 });
-  createMemory({ category: 'gotcha', content: 'mem 2', confidence: 0.5 });
-  createMemory({ category: 'gotcha', content: 'mem 3', confidence: 0.3 });
-  createMemory({ category: 'gotcha', content: 'mem 4', confidence: 0.95 });
-  createMemory({ category: 'gotcha', content: 'mem 5', confidence: 0.7 });
-
-  // Enforce cap of 3
-  enforceMemoryCap(3);
-
-  const active = getActiveMemories();
-  assertEq(active.length, 3, 'should have 3 active memories after cap enforcement');
-
-  // The 2 lowest-ranked (MEM003=0.3 and MEM002=0.5) should be superseded
-  const ids = active.map(m => m.id).sort();
-  assertTrue(ids.includes('MEM001'), 'MEM001 (0.9) should survive');
-  assertTrue(ids.includes('MEM004'), 'MEM004 (0.95) should survive');
-  assertTrue(ids.includes('MEM005'), 'MEM005 (0.7) should survive');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: applyMemoryActions transaction
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: applyMemoryActions ===');
-{
-  openDatabase(':memory:');
-
-  const actions: MemoryAction[] = [
-    { action: 'CREATE', category: 'gotcha', content: 'first gotcha', confidence: 0.8 },
-    { action: 'CREATE', category: 'convention', content: 'first convention', confidence: 0.9 },
-  ];
-
-  applyMemoryActions(actions, 'execute-task', 'M001/S01/T01');
-
-  let active = getActiveMemories();
-  assertEq(active.length, 2, 'should have 2 memories after CREATE actions');
-
-  // Now apply UPDATE + REINFORCE
-  const updateActions: MemoryAction[] = [
-    { action: 'UPDATE', id: 'MEM001', content: 'updated gotcha' },
-    { action: 'REINFORCE', id: 'MEM002' },
-  ];
-
-  applyMemoryActions(updateActions, 'execute-task', 'M001/S01/T02');
-
-  active = getActiveMemories();
-  assertEq(active.find(m => m.id === 'MEM001')?.content, 'updated gotcha', 'MEM001 should be updated');
-  assertEq(active.find(m => m.id === 'MEM002')?.hit_count, 1, 'MEM002 should be reinforced');
-
-  // SUPERSEDE
-  const supersedeActions: MemoryAction[] = [
-    { action: 'CREATE', category: 'gotcha', content: 'better gotcha', confidence: 0.95 },
-    { action: 'SUPERSEDE', id: 'MEM001', superseded_by: 'MEM003' },
-  ];
-
-  applyMemoryActions(supersedeActions, 'execute-task', 'M001/S01/T03');
-
-  active = getActiveMemories();
-  assertEq(active.length, 2, 'should have 2 active after supersede');
-  assertTrue(!active.find(m => m.id === 'MEM001'), 'MEM001 should be superseded');
-  assertTrue(!!active.find(m => m.id === 'MEM003'), 'MEM003 should be active');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: formatMemoriesForPrompt
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: formatMemoriesForPrompt ===');
-{
-  openDatabase(':memory:');
-
-  createMemory({ category: 'gotcha', content: 'esbuild drops .node binaries' });
-  createMemory({ category: 'convention', content: 'use :memory: for tests' });
-  createMemory({ category: 'architecture', content: 'extensions in src/resources/' });
-  createMemory({ category: 'gotcha', content: 'TypeScript path aliases need .js' });
-
-  const memories = getActiveMemoriesRanked(30);
-  const formatted = formatMemoriesForPrompt(memories);
-
-  assertTrue(formatted.includes('## Project Memory (auto-learned)'), 'should have header');
-  assertTrue(formatted.includes('### Gotcha'), 'should have gotcha category');
-  assertTrue(formatted.includes('### Convention'), 'should have convention category');
-  assertTrue(formatted.includes('### Architecture'), 'should have architecture category');
-  assertTrue(formatted.includes('- esbuild drops .node binaries'), 'should have gotcha content');
-  assertTrue(formatted.includes('- use :memory: for tests'), 'should have convention content');
-
-  // Test empty memories
-  closeDatabase();
-  openDatabase(':memory:');
-  const emptyFormatted = formatMemoriesForPrompt([]);
-  assertEq(emptyFormatted, '', 'empty memories should return empty string');
-
-  // Test token budget truncation
-  closeDatabase();
-  openDatabase(':memory:');
-  for (let i = 0; i < 20; i++) {
-    createMemory({ category: 'pattern', content: `A very long memory entry that takes up space #${i}: ${'x'.repeat(200)}` });
-  }
-  const budgetMemories = getActiveMemoriesRanked(30);
-  const truncated = formatMemoriesForPrompt(budgetMemories, 500);
-  assertTrue(truncated.length < 2500, `formatted length ${truncated.length} should be under budget`);
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: ID generation
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: ID generation ===');
-{
-  openDatabase(':memory:');
-
-  assertEq(nextMemoryId(), 'MEM001', 'first ID should be MEM001');
-
-  createMemory({ category: 'test', content: 'test' });
-  assertEq(nextMemoryId(), 'MEM002', 'after first create, next should be MEM002');
-
-  // Create several more
-  for (let i = 0; i < 98; i++) createMemory({ category: 'test', content: `test ${i}` });
-  assertEq(nextMemoryId(), 'MEM100', 'after 99 creates, next should be MEM100');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-store: schema migration (v2 → v3)
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-store: schema includes memories table ===');
-{
-  openDatabase(':memory:');
-
-  const adapter = _getAdapter()!;
-
-  // Verify memories table exists
-  const memCount = adapter.prepare('SELECT count(*) as cnt FROM memories').get();
-  assertEq(memCount?.['cnt'], 0, 'memories table should exist and be empty');
-
-  // Verify memory_processed_units table exists
-  const procCount = adapter.prepare('SELECT count(*) as cnt FROM memory_processed_units').get();
-  assertEq(procCount?.['cnt'], 0, 'memory_processed_units table should exist and be empty');
-
-  // Verify active_memories view exists
-  const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
-  assertEq(viewCount?.['cnt'], 0, 'active_memories view should exist');
-
-  // Verify schema version is 3
-  const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(version?.['v'], 3, 'schema version should be 3');
-
-  closeDatabase();
-}
-
-report();

package/dist/resources/extensions/gsd/tests/metrics.test.ts

@@ -1,253 +0,0 @@
-/**
- * Metrics tests — consolidated from:
- *   - metrics.test.ts (pure aggregation functions, formatting)
- *   - metrics-io.test.ts (disk I/O, init, snapshot, persistence)
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  type UnitMetrics,
-  type MetricsLedger,
-  classifyUnitPhase,
-  aggregateByPhase,
-  aggregateBySlice,
-  aggregateByModel,
-  getProjectTotals,
-  formatCost,
-  formatTokenCount,
-  initMetrics,
-  resetMetrics,
-  getLedger,
-  snapshotUnitMetrics,
-} from "../metrics.js";
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-function makeUnit(overrides: Partial<UnitMetrics> = {}): UnitMetrics {
-  return {
-    type: "execute-task",
-    id: "M001/S01/T01",
-    model: "claude-sonnet-4-20250514",
-    startedAt: 1000,
-    finishedAt: 2000,
-    tokens: { input: 1000, output: 500, cacheRead: 200, cacheWrite: 100, total: 1800 },
-    cost: 0.05,
-    toolCalls: 3,
-    assistantMessages: 2,
-    userMessages: 1,
-    ...overrides,
-  };
-}
-
-function mockCtx(messages: any[] = []): any {
-  const entries = messages.map((msg, i) => ({
-    type: "message", id: `entry-${i}`,
-    parentId: i > 0 ? `entry-${i - 1}` : null,
-    timestamp: new Date().toISOString(), message: msg,
-  }));
-  return { sessionManager: { getEntries: () => entries }, model: { id: "claude-sonnet-4-20250514" } };
-}
-
-// ── Phase classification ─────────────────────────────────────────────────────
-
-test("classifyUnitPhase maps unit types to phases", () => {
-  assert.equal(classifyUnitPhase("research-milestone"), "research");
-  assert.equal(classifyUnitPhase("research-slice"), "research");
-  assert.equal(classifyUnitPhase("plan-milestone"), "planning");
-  assert.equal(classifyUnitPhase("plan-slice"), "planning");
-  assert.equal(classifyUnitPhase("execute-task"), "execution");
-  assert.equal(classifyUnitPhase("complete-slice"), "completion");
-  assert.equal(classifyUnitPhase("reassess-roadmap"), "reassessment");
-  assert.equal(classifyUnitPhase("unknown-thing"), "execution");
-});
-
-// ── getProjectTotals ─────────────────────────────────────────────────────────
-
-test("getProjectTotals aggregates tokens, cost, duration, and tool calls", () => {
-  const units = [
-    makeUnit({ tokens: { input: 1000, output: 500, cacheRead: 200, cacheWrite: 100, total: 1800 }, cost: 0.05, toolCalls: 3, startedAt: 1000, finishedAt: 2000 }),
-    makeUnit({ tokens: { input: 2000, output: 1000, cacheRead: 400, cacheWrite: 200, total: 3600 }, cost: 0.10, toolCalls: 5, startedAt: 2000, finishedAt: 4000 }),
-  ];
-  const totals = getProjectTotals(units);
-  assert.equal(totals.units, 2);
-  assert.equal(totals.tokens.input, 3000);
-  assert.equal(totals.tokens.output, 1500);
-  assert.equal(totals.tokens.total, 5400);
-  assert.ok(Math.abs(totals.cost - 0.15) < 0.001);
-  assert.equal(totals.toolCalls, 8);
-  assert.equal(totals.duration, 3000);
-});
-
-test("getProjectTotals handles empty input", () => {
-  const totals = getProjectTotals([]);
-  assert.equal(totals.units, 0);
-  assert.equal(totals.cost, 0);
-  assert.equal(totals.tokens.total, 0);
-});
-
-test("getProjectTotals aggregates budget fields", () => {
-  const units = [
-    makeUnit({ truncationSections: 3, continueHereFired: true }),
-    makeUnit({ truncationSections: 2, continueHereFired: false }),
-    makeUnit({ truncationSections: 1, continueHereFired: true }),
-  ];
-  const totals = getProjectTotals(units);
-  assert.equal(totals.totalTruncationSections, 6);
-  assert.equal(totals.continueHereFiredCount, 2);
-});
-
-test("getProjectTotals defaults budget fields to 0 for old units", () => {
-  const totals = getProjectTotals([makeUnit(), makeUnit()]);
-  assert.equal(totals.totalTruncationSections, 0);
-  assert.equal(totals.continueHereFiredCount, 0);
-});
-
-// ── aggregateByPhase ─────────────────────────────────────────────────────────
-
-test("aggregateByPhase groups units by phase and sums costs", () => {
-  const units = [
-    makeUnit({ type: "research-milestone", cost: 0.02 }),
-    makeUnit({ type: "research-slice", cost: 0.03 }),
-    makeUnit({ type: "plan-milestone", cost: 0.01 }),
-    makeUnit({ type: "plan-slice", cost: 0.02 }),
-    makeUnit({ type: "execute-task", cost: 0.10 }),
-    makeUnit({ type: "execute-task", cost: 0.08 }),
-    makeUnit({ type: "complete-slice", cost: 0.01 }),
-    makeUnit({ type: "reassess-roadmap", cost: 0.005 }),
-  ];
-  const phases = aggregateByPhase(units);
-  assert.equal(phases.length, 5);
-  assert.equal(phases[0].phase, "research");
-  assert.equal(phases[0].units, 2);
-  assert.ok(Math.abs(phases[0].cost - 0.05) < 0.001);
-  assert.equal(phases[2].phase, "execution");
-  assert.ok(Math.abs(phases[2].cost - 0.18) < 0.001);
-});
-
-// ── aggregateBySlice ─────────────────────────────────────────────────────────
-
-test("aggregateBySlice groups units by slice ID", () => {
-  const units = [
-    makeUnit({ id: "M001/S01/T01", cost: 0.05 }),
-    makeUnit({ id: "M001/S01/T02", cost: 0.04 }),
-    makeUnit({ id: "M001/S02/T01", cost: 0.10 }),
-    makeUnit({ id: "M001", type: "research-milestone", cost: 0.02 }),
-  ];
-  const slices = aggregateBySlice(units);
-  assert.equal(slices.length, 3);
-  const s01 = slices.find(s => s.sliceId === "M001/S01");
-  assert.ok(s01);
-  assert.equal(s01!.units, 2);
-  assert.ok(Math.abs(s01!.cost - 0.09) < 0.001);
-});
-
-// ── aggregateByModel ─────────────────────────────────────────────────────────
-
-test("aggregateByModel groups by model sorted by cost desc", () => {
-  const units = [
-    makeUnit({ model: "claude-sonnet-4-20250514", cost: 0.05 }),
-    makeUnit({ model: "claude-sonnet-4-20250514", cost: 0.04 }),
-    makeUnit({ model: "claude-opus-4-20250514", cost: 0.30 }),
-  ];
-  const models = aggregateByModel(units);
-  assert.equal(models.length, 2);
-  assert.equal(models[0].model, "claude-opus-4-20250514");
-  assert.equal(models[1].units, 2);
-});
-
-test("aggregateByModel picks first defined contextWindowTokens", () => {
-  const units = [
-    makeUnit({ model: "claude-sonnet-4-20250514", contextWindowTokens: 200000, cost: 0.05 }),
-    makeUnit({ model: "claude-sonnet-4-20250514", contextWindowTokens: 150000, cost: 0.04 }),
-  ];
-  const models = aggregateByModel(units);
-  assert.equal(models[0].contextWindowTokens, 200000);
-});
-
-// ── Formatting ───────────────────────────────────────────────────────────────
-
-test("formatCost formats dollar amounts correctly", () => {
-  assert.equal(formatCost(0), "$0.0000");
-  assert.equal(formatCost(0.001), "$0.0010");
-  assert.equal(formatCost(0.05), "$0.050");
-  assert.equal(formatCost(1.50), "$1.50");
-  assert.equal(formatCost(14.20), "$14.20");
-});
-
-test("formatTokenCount uses k/M suffixes", () => {
-  assert.equal(formatTokenCount(0), "0");
-  assert.equal(formatTokenCount(500), "500");
-  assert.equal(formatTokenCount(1500), "1.5k");
-  assert.equal(formatTokenCount(150000), "150.0k");
-  assert.equal(formatTokenCount(1500000), "1.50M");
-});
-
-// ── Backward compatibility ───────────────────────────────────────────────────
-
-test("old UnitMetrics without budget fields work with all aggregation functions", () => {
-  const oldUnit = makeUnit();
-  assert.equal(aggregateByPhase([oldUnit]).length, 1);
-  assert.equal(aggregateBySlice([oldUnit]).length, 1);
-  assert.equal(aggregateByModel([oldUnit]).length, 1);
-  assert.equal(getProjectTotals([oldUnit]).units, 1);
-  assert.equal(oldUnit.contextWindowTokens, undefined);
-});
-
-// ── Disk I/O ─────────────────────────────────────────────────────────────────
-
-test("initMetrics creates ledger, snapshotUnitMetrics persists across resets", () => {
-  const tmpBase = mkdtempSync(join(tmpdir(), "gsd-metrics-test-"));
-  mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
-
-  try {
-    resetMetrics();
-    assert.equal(getLedger(), null);
-
-    initMetrics(tmpBase);
-    const ledger = getLedger();
-    assert.ok(ledger);
-    assert.equal(ledger!.version, 1);
-    assert.equal(ledger!.units.length, 0);
-
-    // Snapshot a unit
-    const ctx = mockCtx([
-      { role: "user", content: "Do the thing" },
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "Done" }],
-        usage: {
-          input: 5000, output: 2000, cacheRead: 3000, cacheWrite: 500, totalTokens: 10500,
-          cost: { input: 0.015, output: 0.03, cacheRead: 0.003, cacheWrite: 0.002, total: 0.05 },
-        },
-      },
-    ]);
-    const unit = snapshotUnitMetrics(ctx, "execute-task", "M001/S01/T01", Date.now() - 5000, "claude-sonnet-4-20250514");
-    assert.ok(unit);
-    assert.equal(unit!.type, "execute-task");
-    assert.equal(unit!.tokens.input, 5000);
-
-    // Persist and reload
-    resetMetrics();
-    initMetrics(tmpBase);
-    assert.equal(getLedger()!.units.length, 1);
-    assert.equal(getLedger()!.units[0].id, "M001/S01/T01");
-
-    // Verify file content
-    const raw = readFileSync(join(tmpBase, ".gsd", "metrics.json"), "utf-8");
-    const parsed: MetricsLedger = JSON.parse(raw);
-    assert.equal(parsed.version, 1);
-    assert.equal(parsed.units.length, 1);
-
-    // Empty session returns null
-    const emptyUnit = snapshotUnitMetrics(mockCtx([]), "plan-slice", "M001/S01", Date.now(), "test-model");
-    assert.equal(emptyUnit, null);
-    assert.equal(getLedger()!.units.length, 1);
-  } finally {
-    resetMetrics();
-    rmSync(tmpBase, { recursive: true, force: true });
-  }
-});