gsd-pi 2.63.0 → 2.64.0-dev.9c14bd0

package/src/resources/extensions/gsd/tests/forensics-stuck-loops.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Forensics detectStuckLoops tests — #1943
+ *
+ * Verifies that detectStuckLoops counts distinct dispatches (unique startedAt
+ * values per type/id) instead of raw entry count, which produces false-positive
+ * stuck-loop anomalies when idle-watchdog duplicate metrics entries exist.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import type { UnitMetrics } from "../metrics.js";
+import { detectStuckLoops, type ForensicAnomaly } from "../forensics.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,
+  };
+}
+
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+test("#1943 detectStuckLoops does not flag idle-watchdog duplicates as stuck loops", () => {
+  const anomalies: ForensicAnomaly[] = [];
+  const startedAt = 1774011016218;
+
+  // 20 entries with the SAME startedAt — these are idle-watchdog duplicates,
+  // not real re-dispatches. They should count as 1 dispatch.
+  const units: UnitMetrics[] = [];
+  for (let i = 0; i < 20; i++) {
+    units.push(makeUnit({
+      type: "research-slice",
+      id: "M009/S02",
+      startedAt,
+      finishedAt: startedAt + (i + 1) * 15000,
+      cost: 1.50 + i * 0.05,
+      toolCalls: 0,
+    }));
+  }
+
+  detectStuckLoops(units, anomalies);
+
+  // A single dispatch (same startedAt) should NOT trigger a stuck-loop anomaly
+  assert.equal(
+    anomalies.length, 0,
+    `expected 0 anomalies for 20 watchdog snapshots of the same dispatch, got ${anomalies.length}: ${anomalies.map(a => a.summary).join(", ")}`,
+  );
+});
+
+test("#1943 detectStuckLoops correctly flags real re-dispatches", () => {
+  const anomalies: ForensicAnomaly[] = [];
+
+  // 3 entries with DIFFERENT startedAt values — these are real re-dispatches
+  const units: UnitMetrics[] = [
+    makeUnit({ type: "execute-task", id: "M001/S01/T01", startedAt: 1000, finishedAt: 2000, cost: 0.05 }),
+    makeUnit({ type: "execute-task", id: "M001/S01/T01", startedAt: 3000, finishedAt: 4000, cost: 0.06 }),
+    makeUnit({ type: "execute-task", id: "M001/S01/T01", startedAt: 5000, finishedAt: 6000, cost: 0.07 }),
+  ];
+
+  detectStuckLoops(units, anomalies);
+
+  assert.equal(anomalies.length, 1, "3 distinct dispatches of the same unit should flag 1 anomaly");
+  assert.equal(anomalies[0].type, "stuck-loop");
+  assert.ok(anomalies[0].summary.includes("3 times"), `summary should mention 3 dispatches: ${anomalies[0].summary}`);
+});
+
+test("#1943 detectStuckLoops ignores watchdog duplicates but flags real re-dispatches in mixed data", () => {
+  const anomalies: ForensicAnomaly[] = [];
+
+  const units: UnitMetrics[] = [
+    // 5 watchdog duplicates for dispatch 1 (same startedAt = 1000)
+    ...Array.from({ length: 5 }, (_, i) =>
+      makeUnit({ type: "execute-task", id: "M001/S01/T01", startedAt: 1000, finishedAt: 1000 + (i + 1) * 15000, cost: 0.05 + i * 0.01 }),
+    ),
+    // 3 watchdog duplicates for dispatch 2 (same startedAt = 100000)
+    ...Array.from({ length: 3 }, (_, i) =>
+      makeUnit({ type: "execute-task", id: "M001/S01/T01", startedAt: 100000, finishedAt: 100000 + (i + 1) * 15000, cost: 0.08 + i * 0.01 }),
+    ),
+    // 1 entry for dispatch 3 (startedAt = 200000)
+    makeUnit({ type: "execute-task", id: "M001/S01/T01", startedAt: 200000, finishedAt: 260000, cost: 0.10 }),
+    // Different unit — only 1 dispatch, should NOT be flagged
+    makeUnit({ type: "plan-slice", id: "M001/S01", startedAt: 500, finishedAt: 1500, cost: 0.02 }),
+  ];
+
+  detectStuckLoops(units, anomalies);
+
+  // M001/S01/T01 has 3 distinct dispatches (startedAt: 1000, 100000, 200000) — should be flagged
+  // M001/S01 has 1 dispatch — should NOT be flagged
+  assert.equal(anomalies.length, 1, `expected 1 anomaly (for the 3x dispatched task), got ${anomalies.length}`);
+  assert.ok(anomalies[0].summary.includes("3 times"));
+});

package/src/resources/extensions/gsd/tests/git-checkpoint.test.ts

@@ -0,0 +1,94 @@
+// GSD2 — Regression tests for git-checkpoint rollback (#3576)
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+import { createCheckpoint, rollbackToCheckpoint, cleanupCheckpoint } from "../safety/git-checkpoint.js";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "ckpt-test-"));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  writeFileSync(join(dir, "file.txt"), "initial\n");
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  return dir;
+}
+
+describe("git-checkpoint rollback", () => {
+  it("rolls back to checkpoint on checked-out branch", (t) => {
+    const repo = createTempRepo();
+    t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+    // Create checkpoint at initial commit
+    const sha = createCheckpoint(repo, "unit-1");
+    assert.ok(sha, "checkpoint should return a SHA");
+
+    // Make a second commit
+    writeFileSync(join(repo, "file.txt"), "modified\n");
+    git(["add", "."], repo);
+    git(["commit", "-m", "second"], repo);
+
+    const headBefore = git(["rev-parse", "HEAD"], repo);
+    assert.notEqual(headBefore, sha, "HEAD should have advanced");
+
+    // Rollback — this must work on the checked-out branch
+    const result = rollbackToCheckpoint(repo, "unit-1", sha);
+    assert.equal(result, true, "rollback should succeed");
+
+    const headAfter = git(["rev-parse", "HEAD"], repo);
+    assert.equal(headAfter, sha, "HEAD should match checkpoint SHA after rollback");
+  });
+
+  it("returns false on detached HEAD", (t) => {
+    const repo = createTempRepo();
+    t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+    const sha = git(["rev-parse", "HEAD"], repo);
+    git(["checkout", "--detach", sha], repo);
+
+    const result = rollbackToCheckpoint(repo, "unit-2", sha);
+    assert.equal(result, false, "rollback should fail on detached HEAD");
+  });
+
+  it("cleans up checkpoint ref after rollback", (t) => {
+    const repo = createTempRepo();
+    t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+    const sha = createCheckpoint(repo, "unit-3");
+    assert.ok(sha);
+
+    // Ref should exist
+    const refBefore = git(["for-each-ref", "refs/gsd/checkpoints/unit-3", "--format=%(objectname)"], repo);
+    assert.equal(refBefore, sha);
+
+    rollbackToCheckpoint(repo, "unit-3", sha);
+
+    // Ref should be cleaned up
+    const refAfter = git(["for-each-ref", "refs/gsd/checkpoints/unit-3", "--format=%(objectname)"], repo);
+    assert.equal(refAfter, "", "checkpoint ref should be removed after rollback");
+  });
+
+  it("cleanupCheckpoint removes the ref without error", (t) => {
+    const repo = createTempRepo();
+    t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+    const sha = createCheckpoint(repo, "unit-4");
+    assert.ok(sha);
+
+    cleanupCheckpoint(repo, "unit-4");
+
+    const ref = git(["for-each-ref", "refs/gsd/checkpoints/unit-4", "--format=%(objectname)"], repo);
+    assert.equal(ref, "", "ref should be gone");
+  });
+});

package/src/resources/extensions/gsd/tests/insert-slice-no-wipe.test.ts

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice } from '../gsd-db.ts';
+
+test('insertSlice with minimal args does not wipe populated fields', (t) => {
+  t.after(() => { try { closeDatabase(); } catch { /* noop */ } });
+  openDatabase(":memory:");
+
+  insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+
+  // First insert: full data
+  insertSlice({
+    id: 'S01',
+    milestoneId: 'M001',
+    title: 'Auth flow',
+    status: 'in-progress',
+    risk: 'high',
+    demo: 'Login page renders.',
+    sequence: 3,
+    planning: {
+      goal: 'Secure authentication',
+      successCriteria: 'All tests pass',
+      proofLevel: 'integration',
+      integrationClosure: 'Fully integrated',
+      observabilityImpact: 'Metrics available',
+    },
+  });
+
+  const before = getSlice('M001', 'S01');
+  assert.ok(before, 'slice should exist after first insert');
+  assert.equal(before.title, 'Auth flow');
+  assert.equal(before.demo, 'Login page renders.');
+  assert.equal(before.risk, 'high');
+
+  // Second insert: minimal "ensure exists" call (mirrors complete-task.ts usage)
+  insertSlice({ id: 'S01', milestoneId: 'M001' });
+
+  const after = getSlice('M001', 'S01');
+  assert.ok(after, 'slice should still exist after second insert');
+
+  // These must NOT be wiped to empty strings
+  assert.equal(after.title, 'Auth flow', 'title must survive minimal re-insert');
+  assert.equal(after.demo, 'Login page renders.', 'demo must survive minimal re-insert');
+  assert.equal(after.risk, 'high', 'risk must survive minimal re-insert');
+  assert.equal(after.sequence, 3, 'sequence must survive minimal re-insert');
+
+  // Planning fields must also survive
+  assert.equal(after.goal, 'Secure authentication', 'goal must survive minimal re-insert');
+  assert.equal(after.success_criteria, 'All tests pass', 'success_criteria must survive');
+  assert.equal(after.proof_level, 'integration', 'proof_level must survive');
+  assert.equal(after.integration_closure, 'Fully integrated', 'integration_closure must survive');
+  assert.equal(after.observability_impact, 'Metrics available', 'observability_impact must survive');
+});
+
+test('insertSlice ON CONFLICT preserves completed status', (t) => {
+  t.after(() => { try { closeDatabase(); } catch { /* noop */ } });
+  openDatabase(":memory:");
+
+  insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Done slice', status: 'complete' });
+
+  // Re-insert with pending status (default) should NOT overwrite complete
+  insertSlice({ id: 'S01', milestoneId: 'M001' });
+
+  const after = getSlice('M001', 'S01');
+  assert.ok(after);
+  assert.equal(after.status, 'complete', 'completed status must not be overwritten');
+});
+
+test('insertSlice ON CONFLICT allows explicit updates to non-empty values', (t) => {
+  t.after(() => { try { closeDatabase(); } catch { /* noop */ } });
+  openDatabase(":memory:");
+
+  insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Original', demo: 'Old demo', risk: 'low' });
+
+  // Explicit update with real values should overwrite
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Updated', demo: 'New demo', risk: 'high' });
+
+  const after = getSlice('M001', 'S01');
+  assert.ok(after);
+  assert.equal(after.title, 'Updated', 'explicit title update should apply');
+  assert.equal(after.demo, 'New demo', 'explicit demo update should apply');
+  assert.equal(after.risk, 'high', 'explicit risk update should apply');
+});

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -1246,7 +1246,7 @@ describe('git-service', async () => {
   test('nativeAddAllWithExclusions: symlinked .gsd fallback', () => {
     // When .gsd is a symlink, git rejects `:!.gsd/...` pathspecs with
     // "fatal: pathspec '...' is beyond a symbolic link". The fix falls
-    // back to plain `git add -A`, which respects .gitignore.
+    // back to `git add -u` (tracked files only), NOT `git add -A`.
     const repo = initTempRepo();
 
     // Create the real .gsd directory outside the repo, then symlink it
@@ -1258,11 +1258,18 @@ describe('git-service', async () => {
     // Symlink .gsd -> external directory
     symlinkSync(externalGsd, join(repo, ".gsd"));
 
-    // Add .gitignore so git add -A fallback skips .gsd/
+    // Add .gitignore so .gsd/ is ignored
     writeFileSync(join(repo, ".gitignore"), ".gsd\n");
 
-    // Create a real file that should be staged
+    // Create a tracked file and commit it, then modify it
     createFile(repo, "src/app.ts", "export const x = 1;");
+    run("git add -A", repo);
+    run('git commit -m "add app"', repo);
+    writeFileSync(join(repo, "src/app.ts"), "export const x = 2;");
+
+    // Create an untracked file simulating large data (NOT in .gitignore)
+    // This is the key scenario: large untracked dirs that git add -A would traverse
+    createFile(repo, "data/large-model.bin", "pretend this is 10GB");
 
     // nativeAddAllWithExclusions should NOT throw despite .gsd being a symlink
     let threw = false;
@@ -1274,9 +1281,15 @@ describe('git-service', async () => {
     }
     assert.ok(!threw, "nativeAddAllWithExclusions does not throw with symlinked .gsd");
 
-    // Verify the real file was staged
+    // Verify the tracked modified file was staged
     const staged = run("git diff --cached --name-only", repo);
-    assert.ok(staged.includes("src/app.ts"), "real file staged despite symlinked .gsd");
+    assert.ok(staged.includes("src/app.ts"), "modified tracked file staged despite symlinked .gsd");
+
+    // CRITICAL: untracked files must NOT be staged — the symlink fallback
+    // should use `git add -u` (tracked only), not `git add -A` (all files).
+    // Using `git add -A` on a repo with large untracked data dirs hangs. (#1977)
+    assert.ok(!staged.includes("data/large-model.bin"),
+      "symlink fallback must not stage untracked files (would hang on large repos)");
     assert.ok(!staged.includes(".gsd"), ".gsd content not staged");
 
     rmSync(repo, { recursive: true, force: true });
@@ -1435,13 +1448,20 @@ describe('git-service', async () => {
     run('git add .gitignore', repo);
     run('git commit -m "add gitignore"', repo);
 
+    // Pre-commit a tracked source file so git add -u can stage modifications.
+    // The symlink fallback uses git add -u (tracked files only), so the file
+    // must be tracked before the autoCommit scenario runs.
+    createFile(repo, "src/feature.ts", "export const feature = true;");
+    run('git add src/feature.ts', repo);
+    run('git commit -m "add feature"', repo);
+
     // Simulate new milestone artifacts created during execution
     writeFileSync(join(externalGsd, "milestones", "M009", "M009-SUMMARY.md"), "# M009 Summary");
     writeFileSync(join(externalGsd, "milestones", "M009", "S01-SUMMARY.md"), "# S01 Summary");
     writeFileSync(join(externalGsd, "milestones", "M009", "T01-VERIFY.json"), '{"passed":true}');
 
-    // Also create a normal source file change
-    createFile(repo, "src/feature.ts", "export const feature = true;");
+    // Modify the tracked source file — git add -u will stage this change
+    writeFileSync(join(repo, "src/feature.ts"), "export const feature = false; // updated");
 
     const svc = new GitServiceImpl(repo);
     const msg = svc.autoCommit("complete-milestone", "M009");

package/src/resources/extensions/gsd/tests/integration/idle-recovery.test.ts

@@ -357,3 +357,37 @@ test('writeBlockerPlaceholder: does NOT update DB for non-execute-task types', a
     cleanup(base);
   }
 });
+
+test('writeBlockerPlaceholder: updates DB slice status for complete-slice (#2653)', async () => {
+  const base = createFixtureBase();
+  try {
+    const { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice, isDbAvailable } =
+      await import("../../gsd-db.ts");
+
+    const dbPath = join(base, ".gsd", "gsd.db");
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+    openDatabase(dbPath);
+    try {
+      insertMilestone({ id: "M001", title: "Test", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active" });
+
+      // complete-slice blocker should update slice DB status to "complete"
+      writeBlockerPlaceholder("complete-slice", "M001/S01", base, "context exhaustion recovery");
+
+      const slice = getSlice("M001", "S01");
+      assert.equal(slice?.status, "complete",
+        "writeBlockerPlaceholder must update DB slice status to 'complete' for complete-slice so dispatch guard unblocks downstream (#2653)");
+
+      // Verify the full chain works: verifyExpectedArtifact should return true
+      // (requires both UAT file and DB status = complete)
+      // Note: the placeholder writes a SUMMARY file, but complete-slice also needs UAT.
+      // The placeholder itself doesn't write UAT, so artifact verification may still fail
+      // for complete-slice — but the DB status is now correct, breaking the circular dep.
+    } finally {
+      if (isDbAvailable()) closeDatabase();
+    }
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -6,7 +6,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
@@ -382,3 +382,118 @@ test("snapshotUnitMetrics counts toolCall blocks correctly (#1713)", () => {
     rmSync(tmpBase, { recursive: true, force: true });
   }
 });
+
+// ── #1943 — Duplicate metrics entries from idle watchdog ──────────────────────
+
+test("#1943 initMetrics deduplicates entries loaded from a corrupted disk ledger", () => {
+  const tmpBase = mkdtempSync(join(tmpdir(), "gsd-metrics-dedup-load-"));
+  mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+
+  try {
+    resetMetrics();
+
+    // Simulate a corrupted metrics.json with duplicate entries on disk
+    // (same type+id+startedAt but different finishedAt — idle watchdog pattern)
+    const corruptedLedger: MetricsLedger = {
+      version: 1,
+      projectStartedAt: 1700000000000,
+      units: [
+        makeUnit({ type: "research-slice", id: "M009/S02", startedAt: 1774011016218, finishedAt: 1774011031218, cost: 1.50, tokens: { input: 6600000, output: 100000, cacheRead: 0, cacheWrite: 0, total: 6700000 } }),
+        makeUnit({ type: "research-slice", id: "M009/S02", startedAt: 1774011016218, finishedAt: 1774011046218, cost: 1.55, tokens: { input: 6800000, output: 110000, cacheRead: 0, cacheWrite: 0, total: 6910000 } }),
+        makeUnit({ type: "research-slice", id: "M009/S02", startedAt: 1774011016218, finishedAt: 1774011061218, cost: 1.60, tokens: { input: 7000000, output: 120000, cacheRead: 0, cacheWrite: 0, total: 7120000 } }),
+        makeUnit({ type: "research-slice", id: "M009/S02", startedAt: 1774011016218, finishedAt: 1774011076218, cost: 1.65, tokens: { input: 7200000, output: 130000, cacheRead: 0, cacheWrite: 0, total: 7330000 } }),
+        // A different unit — should be preserved
+        makeUnit({ type: "execute-task", id: "M001/S01/T01", startedAt: 1774012000000, finishedAt: 1774012060000, cost: 0.50 }),
+      ],
+    };
+    writeFileSync(
+      join(tmpBase, ".gsd", "metrics.json"),
+      JSON.stringify(corruptedLedger, null, 2),
+    );
+
+    // Load the corrupted ledger — duplicates should be collapsed on load
+    initMetrics(tmpBase);
+    const ledger = getLedger();
+    assert.ok(ledger);
+
+    // The 4 entries with identical (type, id, startedAt) should collapse to 1,
+    // keeping the latest (highest finishedAt). Plus the 1 different unit = 2 total.
+    assert.equal(
+      ledger!.units.length, 2,
+      `expected 2 entries after dedup (1 collapsed group + 1 unique), got ${ledger!.units.length}`,
+    );
+
+    // The surviving duplicate should be the one with the latest finishedAt
+    const researchEntry = ledger!.units.find(u => u.type === "research-slice");
+    assert.ok(researchEntry);
+    assert.equal(researchEntry!.finishedAt, 1774011076218, "should keep the latest finishedAt");
+    assert.equal(researchEntry!.cost, 1.65, "should keep the latest cost");
+
+    // The on-disk file should also be deduplicated
+    const diskRaw = readFileSync(join(tmpBase, ".gsd", "metrics.json"), "utf-8");
+    const diskLedger: MetricsLedger = JSON.parse(diskRaw);
+    assert.equal(diskLedger.units.length, 2, "disk should also have deduplicated entries");
+  } finally {
+    resetMetrics();
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test("#1943 getProjectTotals reports correct cost after dedup (no 35% inflation)", () => {
+  // Simulate the exact scenario from the issue: 20 entries for a single dispatch
+  // with monotonically increasing token counts and 15s-apart finishedAt values
+  const startedAt = 1774011016218;
+  const baseCost = 1.50;
+  const duplicateUnits: UnitMetrics[] = [];
+
+  for (let i = 0; i < 20; i++) {
+    duplicateUnits.push(makeUnit({
+      type: "research-slice",
+      id: "M009/S02",
+      startedAt,
+      finishedAt: startedAt + (i + 1) * 15000,
+      cost: baseCost + i * 0.05,
+      toolCalls: 0,
+      tokens: {
+        input: 6600000 + i * 200000,
+        output: 100000 + i * 10000,
+        cacheRead: 0,
+        cacheWrite: 0,
+        total: 6700000 + i * 210000,
+      },
+    }));
+  }
+
+  // Without dedup, getProjectTotals would sum all 20 entries' costs
+  const rawTotals = getProjectTotals(duplicateUnits);
+  // With dedup (only last entry should count), cost should be the last entry's cost
+  const lastEntryCost = duplicateUnits[duplicateUnits.length - 1].cost;
+
+  // This test documents the bug: raw totals inflate cost by summing duplicates
+  assert.ok(
+    rawTotals.cost > lastEntryCost * 2,
+    "raw totals with duplicates inflate cost (bug demonstration)",
+  );
+
+  // After loading through initMetrics (which should dedup), totals should be correct
+  const tmpBase = mkdtempSync(join(tmpdir(), "gsd-metrics-cost-inflation-"));
+  mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+  try {
+    resetMetrics();
+    writeFileSync(
+      join(tmpBase, ".gsd", "metrics.json"),
+      JSON.stringify({ version: 1, projectStartedAt: 1700000000000, units: duplicateUnits }, null, 2),
+    );
+    initMetrics(tmpBase);
+    const ledger = getLedger()!;
+    const dedupedTotals = getProjectTotals(ledger.units);
+    assert.equal(ledger.units.length, 1, "20 duplicates should collapse to 1 entry");
+    assert.equal(
+      dedupedTotals.cost, lastEntryCost,
+      `deduped cost should be ${lastEntryCost}, not ${dedupedTotals.cost}`,
+    );
+  } finally {
+    resetMetrics();
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
+});