talon-agent 1.0.0 → 1.2.0

package/src/__tests__/prompt-builder.test.ts

@@ -5,9 +5,8 @@ vi.mock("../storage/history.js", () => ({
 }));
 
 const { getRecentBySenderId } = await import("../storage/history.js");
-const { enrichDMPrompt, enrichGroupPrompt } = await import(
-  "../core/prompt-builder.js"
-);
+const { enrichDMPrompt, enrichGroupPrompt } =
+  await import("../core/prompt-builder.js");
 
 describe("enrichDMPrompt", () => {
   it("prepends DM metadata", () => {
@@ -39,7 +38,13 @@ describe("enrichGroupPrompt", () => {
 
   it("returns prompt unchanged when only one message (current)", () => {
     vi.mocked(getRecentBySenderId).mockReturnValue([
-      { msgId: 1, senderId: 42, senderName: "Alice", text: "hello", timestamp: Date.now() },
+      {
+        msgId: 1,
+        senderId: 42,
+        senderName: "Alice",
+        text: "hello",
+        timestamp: Date.now(),
+      },
     ]);
     const result = enrichGroupPrompt("hello", "chat1", 42);
     expect(result).toBe("hello");
@@ -47,9 +52,27 @@ describe("enrichGroupPrompt", () => {
 
   it("prepends prior messages for threading context", () => {
     vi.mocked(getRecentBySenderId).mockReturnValue([
-      { msgId: 1, senderId: 42, senderName: "Alice", text: "first message", timestamp: new Date("2025-01-01T10:00:00Z").getTime() },
-      { msgId: 2, senderId: 42, senderName: "Alice", text: "second message", timestamp: new Date("2025-01-01T10:01:00Z").getTime() },
-      { msgId: 3, senderId: 42, senderName: "Alice", text: "current", timestamp: new Date("2025-01-01T10:02:00Z").getTime() },
+      {
+        msgId: 1,
+        senderId: 42,
+        senderName: "Alice",
+        text: "first message",
+        timestamp: new Date("2025-01-01T10:00:00Z").getTime(),
+      },
+      {
+        msgId: 2,
+        senderId: 42,
+        senderName: "Alice",
+        text: "second message",
+        timestamp: new Date("2025-01-01T10:01:00Z").getTime(),
+      },
+      {
+        msgId: 3,
+        senderId: 42,
+        senderName: "Alice",
+        text: "current",
+        timestamp: new Date("2025-01-01T10:02:00Z").getTime(),
+      },
     ]);
     const result = enrichGroupPrompt("current", "chat1", 42);
     expect(result).toContain("Alice's recent messages");
@@ -61,8 +84,20 @@ describe("enrichGroupPrompt", () => {
   it("truncates long messages to 200 chars", () => {
     const longText = "x".repeat(300);
     vi.mocked(getRecentBySenderId).mockReturnValue([
-      { msgId: 1, senderId: 42, senderName: "Bob", text: longText, timestamp: Date.now() },
-      { msgId: 2, senderId: 42, senderName: "Bob", text: "current", timestamp: Date.now() },
+      {
+        msgId: 1,
+        senderId: 42,
+        senderName: "Bob",
+        text: longText,
+        timestamp: Date.now(),
+      },
+      {
+        msgId: 2,
+        senderId: 42,
+        senderName: "Bob",
+        text: "current",
+        timestamp: Date.now(),
+      },
     ]);
     const result = enrichGroupPrompt("current", "chat1", 42);
     expect(result).not.toContain(longText); // full text shouldn't appear

package/src/__tests__/sessions.test.ts

@@ -494,10 +494,10 @@ describe("sessions", () => {
       //         cacheRead * pricing.cacheRead + output * pricing.output) / 1_000_000
       // Sonnet: input=$3/M, output=$15/M, cacheRead=$0.3/M, cacheWrite=$3.75/M
       recordUsage(chatId, {
-        inputTokens: 500_000,   // 500k * 3 / 1M = $1.50
-        outputTokens: 100_000,  // 100k * 15 / 1M = $1.50
-        cacheRead: 200_000,     // 200k * 0.3 / 1M = $0.06
-        cacheWrite: 100_000,    // 100k * 3.75 / 1M = $0.375
+        inputTokens: 500_000, // 500k * 3 / 1M = $1.50
+        outputTokens: 100_000, // 100k * 15 / 1M = $1.50
+        cacheRead: 200_000, // 200k * 0.3 / 1M = $0.06
+        cacheWrite: 100_000, // 100k * 3.75 / 1M = $0.375
         model: "claude-sonnet-4-6",
       });
 
@@ -592,3 +592,257 @@ describe("sessions", () => {
     });
   });
 });
+
+describe("sessions — migration of legacy field formats", () => {
+  it("adds missing usage object to legacy session", () => {
+    // Simulate a session loaded without usage (old format)
+    // We do this by calling loadSessions with a mocked file that has no usage field
+    vi.mocked(existsSync).mockReturnValueOnce(true);
+    vi.mocked(readFileSync).mockReturnValueOnce(
+      JSON.stringify({
+        "migrate-chat-1": {
+          sessionId: undefined,
+          turns: 5,
+          lastActive: 1000,
+          createdAt: 1000,
+        },
+      }),
+    );
+    loadSessions();
+    const session = getSession("migrate-chat-1");
+    expect(session.usage).toBeDefined();
+    expect(session.usage.totalInputTokens).toBe(0);
+    expect(session.usage.fastestResponseMs).toBe(Infinity);
+  });
+
+  it("fixes missing createdAt by using lastActive", () => {
+    vi.mocked(existsSync).mockReturnValueOnce(true);
+    vi.mocked(readFileSync).mockReturnValueOnce(
+      JSON.stringify({
+        "migrate-chat-2": {
+          sessionId: undefined,
+          turns: 3,
+          lastActive: 9999999,
+          usage: {
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalCacheRead: 0,
+            totalCacheWrite: 0,
+            lastPromptTokens: 0,
+            estimatedCostUsd: 0,
+            totalResponseMs: 0,
+            lastResponseMs: 0,
+            fastestResponseMs: Infinity,
+          },
+        },
+      }),
+    );
+    loadSessions();
+    const session = getSession("migrate-chat-2");
+    expect(session.createdAt).toBe(9999999);
+  });
+
+  it("fixes fastestResponseMs of 0 to Infinity", () => {
+    vi.mocked(existsSync).mockReturnValueOnce(true);
+    vi.mocked(readFileSync).mockReturnValueOnce(
+      JSON.stringify({
+        "migrate-chat-3": {
+          sessionId: undefined,
+          turns: 2,
+          lastActive: 1000,
+          createdAt: 1000,
+          usage: {
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalCacheRead: 0,
+            totalCacheWrite: 0,
+            lastPromptTokens: 0,
+            estimatedCostUsd: 0,
+            totalResponseMs: 0,
+            lastResponseMs: 0,
+            fastestResponseMs: 0,
+          },
+        },
+      }),
+    );
+    loadSessions();
+    const session = getSession("migrate-chat-3");
+    expect(session.usage.fastestResponseMs).toBe(Infinity);
+  });
+});
+
+describe("sessions — loadSessions backup recovery", () => {
+  it("loads from backup when primary is corrupt", () => {
+    vi.mocked(existsSync)
+      .mockReturnValueOnce(true) // primary exists
+      .mockReturnValueOnce(true); // backup exists
+    vi.mocked(readFileSync)
+      .mockReturnValueOnce("{not valid json}") // primary corrupt
+      .mockReturnValueOnce(
+        JSON.stringify({
+          "backup-chat": {
+            sessionId: "bak-sid",
+            turns: 7,
+            lastActive: 1,
+            createdAt: 1,
+            usage: {
+              totalInputTokens: 0,
+              totalOutputTokens: 0,
+              totalCacheRead: 0,
+              totalCacheWrite: 0,
+              lastPromptTokens: 0,
+              estimatedCostUsd: 0,
+              totalResponseMs: 0,
+              lastResponseMs: 0,
+              fastestResponseMs: Infinity,
+            },
+          },
+        }),
+      );
+    loadSessions();
+    const s = getSession("backup-chat");
+    expect(s.turns).toBe(7);
+  });
+
+  it("starts fresh when both primary and backup are corrupt", () => {
+    vi.mocked(existsSync)
+      .mockReturnValueOnce(true) // primary exists
+      .mockReturnValueOnce(true); // backup exists
+    vi.mocked(readFileSync)
+      .mockReturnValueOnce("BAD PRIMARY")
+      .mockReturnValueOnce("BAD BACKUP");
+    // Should not throw
+    expect(() => loadSessions()).not.toThrow();
+  });
+});
+
+describe("sessions — edge cases for branch coverage", () => {
+  it("resetSession includes session name in log when name is set", () => {
+    const chatId = "reset-named-session";
+    getSession(chatId);
+    setSessionName(chatId, "Work Chat");
+    // Does not throw; covers the `name ? ` "${name}"` branch in resetSession
+    expect(() => resetSession(chatId)).not.toThrow();
+    // Session should be gone
+    const fresh = getSession(chatId);
+    expect(fresh.turns).toBe(0);
+  });
+
+  it("getAllSessions falls back to empty usage for sessions without usage field", () => {
+    // Directly inject a session without usage to cover the ?? branch (line 304)
+    // The store is accessed via loadSessions with a raw mock
+    vi.mocked(existsSync).mockReturnValueOnce(true);
+    vi.mocked(readFileSync).mockReturnValueOnce(
+      JSON.stringify({
+        "no-usage-chat": {
+          sessionId: undefined,
+          turns: 3,
+          lastActive: 1_000_000,
+          createdAt: 1_000_000,
+          // usage deliberately omitted to trigger the ?? fallback
+        },
+      }),
+    );
+    loadSessions();
+    const all = getAllSessions();
+    const entry = all.find((s) => s.chatId === "no-usage-chat");
+    expect(entry).toBeDefined();
+    expect(entry!.info.usage).toBeDefined();
+    expect(entry!.info.usage.totalInputTokens).toBe(0);
+  });
+
+  it("resetSession on nonexistent chat defaults turns to 0", () => {
+    // session?.turns ?? 0 — the ?? 0 fallback (session is undefined)
+    expect(() => resetSession("never-created-session-xyz")).not.toThrow();
+  });
+
+  it("saveSessions logs error when atomic write throws", async () => {
+    const { logError } = await import("../util/log.js");
+    writeFileAtomicSync.mockImplementationOnce(() => {
+      throw new Error("disk full");
+    });
+    // resetSession sets dirty=true then calls saveSessions
+    getSession("throw-on-save-xyz");
+    expect(() => resetSession("throw-on-save-xyz")).not.toThrow();
+    expect(logError).toHaveBeenCalled();
+  });
+
+  it("fastestResponseMs ?? 0 defaults to Infinity on first duration record", () => {
+    const chatId = "fastest-first-call-xyz";
+    // Fresh session has fastestResponseMs=Infinity (from emptyUsage)
+    // Calling recordUsage sets current = Infinity || Infinity... actually Infinity is truthy
+    // so we need to exercise the case where fastestResponseMs is already set > durationMs
+    recordUsage(chatId, {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      durationMs: 500,
+    });
+    const session = getSession(chatId);
+    expect(session.usage.fastestResponseMs).toBe(500);
+    // Second call with LONGER duration — fastestResponseMs stays at 500 (not updated)
+    recordUsage(chatId, {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      durationMs: 1000,
+    });
+    expect(session.usage.fastestResponseMs).toBe(500);
+  });
+
+  it("placeholder test removed", () => {
+    // placeholder - actual test moved to end of file to avoid module isolation issues
+    expect(true).toBe(true);
+  });
+
+  it("saveSessions logs error with non-Error object thrown by writeFileAtomic", async () => {
+    const { logError } = await import("../util/log.js");
+    // Throw a plain string instead of an Error to cover the `err instanceof Error ? ... : err` false branch
+    writeFileAtomicSync.mockImplementationOnce(() => {
+      throw "plain string error";
+    }); // eslint-disable-line @typescript-eslint/no-throw-literal
+    getSession("throw-string-on-save-xyz");
+    expect(() => resetSession("throw-string-on-save-xyz")).not.toThrow();
+    expect(logError).toHaveBeenCalled();
+  });
+});
+
+// ── saveSessions dirty=false early return ─────────────────────────────────
+
+describe("sessions — saveSessions dirty=false early return (line 98 TRUE branch)", () => {
+  it("does not write when auto-save fires with dirty=false", async () => {
+    vi.resetModules();
+    vi.useFakeTimers();
+    const wfaMock = vi.fn();
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: vi.fn(),
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/watchdog.js", () => ({ recordError: vi.fn() }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => false),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => "{}"),
+    }));
+    vi.doMock("write-file-atomic", () => ({ default: { sync: wfaMock } }));
+    vi.doMock("../util/paths.js", () => ({
+      files: { sessions: "/fake/sessions.json" },
+      dirs: { root: "/fake/.talon", data: "/fake/.talon/data" },
+    }));
+    vi.doMock("../util/cleanup-registry.js", () => ({
+      registerCleanup: vi.fn(),
+    }));
+
+    // Fresh import: dirty=false (nothing modified yet)
+    await import("../storage/sessions.js");
+
+    // Advance 11 seconds → auto-save timer fires → saveSessions() with dirty=false → early return
+    await vi.advanceTimersByTimeAsync(11_000);
+    expect(wfaMock).not.toHaveBeenCalled();
+
+    vi.useRealTimers();
+  });
+});

package/src/__tests__/storage-save-errors.test.ts

@@ -0,0 +1,342 @@
+/**
+ * Tests that cover the logError + recordError paths triggered when
+ * write-file-atomic throws during save() in cron-store, chat-settings,
+ * and sessions.
+ *
+ * Each module must be re-imported in isolation (vi.resetModules) so the
+ * mocks apply to the fresh module instance.
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ── cron-store save failure ───────────────────────────────────────────────
+
+describe("cron-store — save failure logs error", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("calls logError and recordError when writeFileAtomic throws", async () => {
+    const logErrorMock = vi.fn();
+    const recordErrorMock = vi.fn();
+
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: logErrorMock,
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/watchdog.js", () => ({
+      recordError: recordErrorMock,
+    }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      readFileSync: vi.fn(() => "{}"),
+      mkdirSync: vi.fn(),
+      readdirSync: vi.fn(() => []),
+    }));
+    vi.doMock("write-file-atomic", () => ({
+      default: {
+        sync: vi.fn(() => {
+          throw new Error("disk full");
+        }),
+      },
+    }));
+    vi.doMock("../util/paths.js", () => ({
+      files: { cron: "/fake/cron.json" },
+      dirs: { root: "/fake/.talon" },
+    }));
+    vi.doMock("../util/cleanup-registry.js", () => ({
+      registerCleanup: vi.fn(),
+    }));
+
+    const { addCronJob, generateCronId, flushCronJobs } =
+      await import("../storage/cron-store.js");
+
+    const job = {
+      id: generateCronId(),
+      chatId: "chat1",
+      schedule: "0 * * * *",
+      type: "message" as const,
+      content: "hello",
+      name: "test",
+      enabled: true,
+      createdAt: Date.now(),
+      runCount: 0,
+    };
+
+    // addCronJob marks dirty and calls save() which will throw
+    addCronJob(job);
+
+    expect(logErrorMock).toHaveBeenCalledWith(
+      "cron",
+      expect.stringContaining("Failed to persist"),
+      expect.any(Error),
+    );
+    expect(recordErrorMock).toHaveBeenCalledWith(
+      expect.stringContaining("Cron save failed"),
+    );
+
+    clearInterval(((await import("../storage/cron-store.js")) as any)._timer);
+  });
+});
+
+// ── chat-settings save failure ────────────────────────────────────────────
+
+describe("chat-settings — save failure logs error", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("calls logError and recordError when writeFileAtomic throws", async () => {
+    const logErrorMock = vi.fn();
+    const recordErrorMock = vi.fn();
+
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: logErrorMock,
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/watchdog.js", () => ({
+      recordError: recordErrorMock,
+    }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      readFileSync: vi.fn(() => "{}"),
+      mkdirSync: vi.fn(),
+    }));
+    vi.doMock("write-file-atomic", () => ({
+      default: {
+        sync: vi.fn(() => {
+          throw new Error("readonly fs");
+        }),
+      },
+    }));
+    vi.doMock("../util/paths.js", () => ({
+      files: { chatSettings: "/fake/chat-settings.json" },
+      dirs: { root: "/fake/.talon" },
+    }));
+    vi.doMock("../util/cleanup-registry.js", () => ({
+      registerCleanup: vi.fn(),
+    }));
+
+    const { setChatModel } = await import("../storage/chat-settings.js");
+
+    // setChatModel marks dirty and calls save()
+    setChatModel("chat99", "claude-opus-4-6");
+
+    expect(logErrorMock).toHaveBeenCalledWith(
+      "settings",
+      expect.stringContaining("Failed to persist"),
+      expect.any(Error),
+    );
+    expect(recordErrorMock).toHaveBeenCalledWith(
+      expect.stringContaining("Settings save failed"),
+    );
+  });
+});
+
+describe("chat-settings — non-Error thrown in save (line 96 FALSE branch)", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("records error with String(err) when non-Error is thrown", async () => {
+    const recordErrorMock = vi.fn();
+
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: vi.fn(),
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/watchdog.js", () => ({
+      recordError: recordErrorMock,
+    }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      readFileSync: vi.fn(() => "{}"),
+      mkdirSync: vi.fn(),
+    }));
+    vi.doMock("write-file-atomic", () => ({
+      default: {
+        sync: vi.fn(() => {
+          throw "plain string chat-settings error";
+        }),
+      },
+    }));
+    vi.doMock("../util/paths.js", () => ({
+      files: { chatSettings: "/fake/chat-settings.json" },
+      dirs: { root: "/fake/.talon" },
+    }));
+    vi.doMock("../util/cleanup-registry.js", () => ({
+      registerCleanup: vi.fn(),
+    }));
+
+    const { setChatModel } = await import("../storage/chat-settings.js");
+    setChatModel("chat-nonError", "claude-opus-4-6");
+
+    expect(recordErrorMock).toHaveBeenCalledWith(
+      expect.stringContaining("plain string chat-settings error"),
+    );
+  });
+});
+
+// ── sessions save failure ─────────────────────────────────────────────────
+
+describe("sessions — save failure logs error", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("calls logError and recordError when writeFileAtomic throws", async () => {
+    const logErrorMock = vi.fn();
+    const recordErrorMock = vi.fn();
+
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: logErrorMock,
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/watchdog.js", () => ({
+      recordError: recordErrorMock,
+    }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      readFileSync: vi.fn(() => "{}"),
+      mkdirSync: vi.fn(),
+    }));
+    vi.doMock("write-file-atomic", () => ({
+      default: {
+        sync: vi.fn(() => {
+          throw new Error("ENOSPC: no space left");
+        }),
+      },
+    }));
+    vi.doMock("../util/paths.js", () => ({
+      files: { sessions: "/fake/sessions.json" },
+      dirs: { root: "/fake/.talon", data: "/fake/.talon/data" },
+    }));
+    vi.doMock("../util/cleanup-registry.js", () => ({
+      registerCleanup: vi.fn(),
+    }));
+
+    const { getSession, flushSessions } =
+      await import("../storage/sessions.js");
+
+    // getSession creates a new session (marks dirty) then flushSessions forces save
+    getSession("chat-save-fail");
+    flushSessions();
+
+    expect(logErrorMock).toHaveBeenCalledWith(
+      "sessions",
+      expect.stringContaining("Failed to persist"),
+      expect.any(Error),
+    );
+    expect(recordErrorMock).toHaveBeenCalledWith(
+      expect.stringContaining("Session save failed"),
+    );
+  });
+});
+
+// ── sessions — migration of totalResponseMs / lastResponseMs ─────────────
+
+describe("sessions — migration paths for usage fields", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("sets totalResponseMs to 0 when undefined in stored session", async () => {
+    const partialUsage = {
+      totalInputTokens: 10,
+      totalOutputTokens: 5,
+      totalCacheRead: 0,
+      totalCacheWrite: 0,
+      lastPromptTokens: 0,
+      estimatedCostUsd: 0,
+      // totalResponseMs intentionally omitted
+      lastResponseMs: 0,
+      fastestResponseMs: Infinity,
+    };
+    const stored = {
+      "mig-chat": {
+        sessionId: undefined,
+        turns: 1,
+        lastActive: Date.now(),
+        createdAt: Date.now(),
+        usage: partialUsage,
+      },
+    };
+
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: vi.fn(),
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/watchdog.js", () => ({ recordError: vi.fn() }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      readFileSync: vi.fn(() => JSON.stringify(stored)),
+      mkdirSync: vi.fn(),
+    }));
+    vi.doMock("write-file-atomic", () => ({ default: { sync: vi.fn() } }));
+    vi.doMock("../util/paths.js", () => ({
+      files: { sessions: "/fake/sessions.json" },
+      dirs: { root: "/fake/.talon", data: "/fake/.talon/data" },
+    }));
+    vi.doMock("../util/cleanup-registry.js", () => ({
+      registerCleanup: vi.fn(),
+    }));
+
+    const { loadSessions, getSession } = await import("../storage/sessions.js");
+    loadSessions();
+    const session = getSession("mig-chat");
+    expect(session.usage.totalResponseMs).toBe(0);
+  });
+
+  it("sets lastResponseMs to 0 when undefined in stored session", async () => {
+    const partialUsage = {
+      totalInputTokens: 10,
+      totalOutputTokens: 5,
+      totalCacheRead: 0,
+      totalCacheWrite: 0,
+      lastPromptTokens: 0,
+      estimatedCostUsd: 0,
+      totalResponseMs: 100,
+      // lastResponseMs intentionally omitted
+      fastestResponseMs: Infinity,
+    };
+    const stored = {
+      "mig-chat-2": {
+        sessionId: undefined,
+        turns: 1,
+        lastActive: Date.now(),
+        createdAt: Date.now(),
+        usage: partialUsage,
+      },
+    };
+
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: vi.fn(),
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/watchdog.js", () => ({ recordError: vi.fn() }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      readFileSync: vi.fn(() => JSON.stringify(stored)),
+      mkdirSync: vi.fn(),
+    }));
+    vi.doMock("write-file-atomic", () => ({ default: { sync: vi.fn() } }));
+    vi.doMock("../util/paths.js", () => ({
+      files: { sessions: "/fake/sessions.json" },
+      dirs: { root: "/fake/.talon", data: "/fake/.talon/data" },
+    }));
+    vi.doMock("../util/cleanup-registry.js", () => ({
+      registerCleanup: vi.fn(),
+    }));
+
+    const { loadSessions, getSession } = await import("../storage/sessions.js");
+    loadSessions();
+    const session = getSession("mig-chat-2");
+    expect(session.usage.lastResponseMs).toBe(0);
+  });
+});