ashlrcode 1.0.0

package/src/__tests__/cost-tracker.test.ts

@@ -0,0 +1,274 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { CostTracker } from "../providers/cost-tracker.ts";
+
+describe("CostTracker", () => {
+  let tracker: CostTracker;
+
+  beforeEach(() => {
+    tracker = new CostTracker();
+  });
+
+  // ── Basic recording ──────────────────────────────────────────────────
+
+  test("records usage for a single provider/model", () => {
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514", {
+      inputTokens: 1000,
+      outputTokens: 500,
+    });
+
+    expect(tracker.totalInputTokens).toBe(1000);
+    expect(tracker.totalOutputTokens).toBe(500);
+    expect(tracker.totalReasoningTokens).toBe(0);
+  });
+
+  test("accumulates usage across multiple calls to same model", () => {
+    tracker.record("xai", "grok-3-fast", { inputTokens: 500, outputTokens: 200 });
+    tracker.record("xai", "grok-3-fast", { inputTokens: 500, outputTokens: 300 });
+
+    expect(tracker.totalInputTokens).toBe(1000);
+    expect(tracker.totalOutputTokens).toBe(500);
+
+    const breakdown = tracker.getBreakdown();
+    expect(breakdown).toHaveLength(1);
+    expect(breakdown[0]!.calls).toBe(2);
+  });
+
+  test("handles partial usage (only inputTokens)", () => {
+    tracker.record("xai", "grok-3-fast", { inputTokens: 100 });
+    expect(tracker.totalInputTokens).toBe(100);
+    expect(tracker.totalOutputTokens).toBe(0);
+  });
+
+  test("handles empty usage object", () => {
+    tracker.record("xai", "grok-3-fast", {});
+    expect(tracker.totalInputTokens).toBe(0);
+    expect(tracker.totalOutputTokens).toBe(0);
+    expect(tracker.totalCostUSD).toBe(0);
+    expect(tracker.getBreakdown()[0]!.calls).toBe(1);
+  });
+
+  // ── Pricing calculations ──────────────────────────────────────────────
+
+  test("calculates Anthropic Sonnet pricing correctly", () => {
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514", {
+      inputTokens: 1000,
+      outputTokens: 500,
+    });
+    // (1000/1M)*3 + (500/1M)*15 = 0.003 + 0.0075 = 0.0105
+    expect(tracker.totalCostUSD).toBeCloseTo(0.0105, 6);
+  });
+
+  test("calculates Anthropic Opus pricing correctly", () => {
+    tracker.record("anthropic", "claude-opus-4-6-20250514", {
+      inputTokens: 1_000_000,
+      outputTokens: 0,
+    });
+    // $15/M input
+    expect(tracker.totalCostUSD).toBeCloseTo(15.0, 2);
+  });
+
+  test("calculates xAI grok-3-fast pricing correctly", () => {
+    tracker.record("xai", "grok-3-fast", {
+      inputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+    });
+    // $0.1/M input + $0.3/M output = $0.4
+    expect(tracker.totalCostUSD).toBeCloseTo(0.4, 2);
+  });
+
+  test("calculates GPT-4o pricing correctly", () => {
+    tracker.record("openai", "gpt-4o", {
+      inputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+    });
+    // $2.5/M input + $10/M output = $12.5
+    expect(tracker.totalCostUSD).toBeCloseTo(12.5, 2);
+  });
+
+  test("free-tier models cost zero", () => {
+    tracker.record("groq", "llama-3.3-70b-versatile", {
+      inputTokens: 10_000_000,
+      outputTokens: 5_000_000,
+    });
+    expect(tracker.totalCostUSD).toBe(0);
+  });
+
+  // ── Reasoning token pricing ───────────────────────────────────────────
+
+  test("reasoning tokens use separate pricing when available (o1)", () => {
+    tracker.record("openai", "o1", {
+      inputTokens: 1000,
+      outputTokens: 500,
+      reasoningTokens: 200,
+    });
+    // (1000/1M)*15 + (500/1M)*60 + (200/1M)*60 = 0.015 + 0.030 + 0.012 = 0.057
+    expect(tracker.totalCostUSD).toBeCloseTo(0.057, 6);
+    expect(tracker.totalTokens.reasoningTokens).toBe(200);
+  });
+
+  test("reasoning tokens use output rate when no separate rate (sonnet)", () => {
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514", {
+      inputTokens: 0,
+      outputTokens: 0,
+      reasoningTokens: 1_000_000,
+    });
+    // No reasoningPerMillion defined, falls back to outputPerMillion = $15/M
+    expect(tracker.totalCostUSD).toBeCloseTo(15.0, 2);
+  });
+
+  test("deepseek-reasoner reasoning pricing", () => {
+    tracker.record("deepseek", "deepseek-reasoner", {
+      inputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+      reasoningTokens: 1_000_000,
+    });
+    // $0.55 + $2.19 + $2.19 = $4.93
+    expect(tracker.totalCostUSD).toBeCloseTo(4.93, 2);
+  });
+
+  // ── Partial model name matching ───────────────────────────────────────
+
+  test("matches model with date suffix", () => {
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514-latest", {
+      inputTokens: 1_000_000,
+      outputTokens: 0,
+    });
+    // Should match claude-sonnet-4-6-20250514 pricing: $3/M input
+    expect(tracker.totalCostUSD).toBeCloseTo(3.0, 2);
+  });
+
+  test("matches shorter model name to longer key via key.startsWith(model)", () => {
+    // "grok-3-fast" starts with "grok-3" — getPricing iterates and finds the first match
+    tracker.record("xai", "grok-3", {
+      inputTokens: 1_000_000,
+      outputTokens: 0,
+    });
+    // grok-3-fast pricing: $0.1/M input
+    expect(tracker.totalCostUSD).toBeCloseTo(0.1, 2);
+  });
+
+  // ── Unknown model fallback ────────────────────────────────────────────
+
+  test("unknown models get default pricing ($1/M in, $3/M out)", () => {
+    tracker.record("custom", "unknown-model-v2", {
+      inputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+    });
+    // Default: $1/M input + $3/M output = $4 total
+    expect(tracker.totalCostUSD).toBeCloseTo(4.0, 2);
+  });
+
+  test("unknown model reasoning tokens use output rate ($3/M)", () => {
+    tracker.record("custom", "mystery-model", {
+      inputTokens: 0,
+      outputTokens: 0,
+      reasoningTokens: 1_000_000,
+    });
+    // Default fallback: no reasoningPerMillion, so uses outputPerMillion = $3/M
+    expect(tracker.totalCostUSD).toBeCloseTo(3.0, 2);
+  });
+
+  // ── formatSummary ─────────────────────────────────────────────────────
+
+  test("formatSummary contains cost and token counts", () => {
+    tracker.record("xai", "grok-3-fast", { inputTokens: 1000, outputTokens: 500 });
+
+    const summary = tracker.formatSummary();
+    expect(summary).toContain("Cost:");
+    expect(summary).toContain("1K in");
+    expect(summary).toContain("500 out");
+  });
+
+  test("formatSummary includes reasoning when present", () => {
+    tracker.record("openai", "o1", {
+      inputTokens: 10000,
+      outputTokens: 5000,
+      reasoningTokens: 3000,
+    });
+
+    const summary = tracker.formatSummary();
+    expect(summary).toContain("reasoning");
+    expect(summary).toContain("10K in");
+    expect(summary).toContain("5K out");
+    expect(summary).toContain("3K reasoning");
+  });
+
+  test("formatSummary omits reasoning when zero", () => {
+    tracker.record("xai", "grok-3-fast", { inputTokens: 1000, outputTokens: 500 });
+
+    const summary = tracker.formatSummary();
+    expect(summary).not.toContain("reasoning");
+  });
+
+  test("formatSummary formats millions correctly", () => {
+    tracker.record("xai", "grok-3-fast", {
+      inputTokens: 2_500_000,
+      outputTokens: 1_200_000,
+    });
+
+    const summary = tracker.formatSummary();
+    expect(summary).toContain("2.5M in");
+    expect(summary).toContain("1.2M out");
+  });
+
+  // ── Multi-provider breakdown ──────────────────────────────────────────
+
+  test("formatSummary shows per-provider breakdown when multiple providers", () => {
+    tracker.record("xai", "grok-3-fast", { inputTokens: 1000, outputTokens: 500 });
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514", { inputTokens: 2000, outputTokens: 1000 });
+
+    const summary = tracker.formatSummary();
+    expect(summary).toContain("Per provider:");
+    expect(summary).toContain("xai:grok-3-fast");
+    expect(summary).toContain("anthropic:claude-sonnet-4-6-20250514");
+  });
+
+  test("formatSummary does not show breakdown for single provider", () => {
+    tracker.record("xai", "grok-3-fast", { inputTokens: 1000, outputTokens: 500 });
+
+    const summary = tracker.formatSummary();
+    expect(summary).not.toContain("Per provider:");
+  });
+
+  test("multi-provider breakdown includes call counts", () => {
+    tracker.record("xai", "grok-3-fast", { inputTokens: 100, outputTokens: 50 });
+    tracker.record("xai", "grok-3-fast", { inputTokens: 100, outputTokens: 50 });
+    tracker.record("openai", "gpt-4o", { inputTokens: 200, outputTokens: 100 });
+
+    const summary = tracker.formatSummary();
+    expect(summary).toContain("2 calls");
+    expect(summary).toContain("1 calls");
+  });
+
+  test("getBreakdown returns correct number of entries", () => {
+    tracker.record("xai", "grok-3-fast", { inputTokens: 100, outputTokens: 50 });
+    tracker.record("openai", "gpt-4o", { inputTokens: 200, outputTokens: 100 });
+    tracker.record("anthropic", "claude-sonnet-4-6-20250514", { inputTokens: 300, outputTokens: 150 });
+
+    const breakdown = tracker.getBreakdown();
+    expect(breakdown).toHaveLength(3);
+  });
+
+  test("totalCostUSD sums across all providers", () => {
+    // xai grok-3-fast: (1M/1M)*0.1 + (1M/1M)*0.3 = 0.4
+    tracker.record("xai", "grok-3-fast", { inputTokens: 1_000_000, outputTokens: 1_000_000 });
+    // openai gpt-4o: (1M/1M)*2.5 + (1M/1M)*10 = 12.5
+    tracker.record("openai", "gpt-4o", { inputTokens: 1_000_000, outputTokens: 1_000_000 });
+
+    expect(tracker.totalCostUSD).toBeCloseTo(12.9, 2);
+  });
+
+  // ── Legacy compat getters ─────────────────────────────────────────────
+
+  test("legacy getters match totalTokens", () => {
+    tracker.record("openai", "o1", {
+      inputTokens: 100,
+      outputTokens: 200,
+      reasoningTokens: 50,
+    });
+
+    expect(tracker.totalInputTokens).toBe(tracker.totalTokens.inputTokens);
+    expect(tracker.totalOutputTokens).toBe(tracker.totalTokens.outputTokens);
+    expect(tracker.totalReasoningTokens).toBe(tracker.totalTokens.reasoningTokens);
+  });
+});

package/src/__tests__/cron.test.ts

@@ -0,0 +1,197 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { setConfigDirForTests } from "../config/settings.ts";
+import {
+  createTrigger,
+  listTriggers,
+  deleteTrigger,
+  getDueTriggers,
+  markRun,
+  toggleTrigger,
+  type CronTrigger,
+} from "../agent/cron.ts";
+
+describe("Cron Triggers", () => {
+  let configDir: string;
+
+  beforeEach(() => {
+    configDir = mkdtempSync(join(tmpdir(), "ashlrcode-cron-test-"));
+    setConfigDirForTests(configDir);
+  });
+
+  afterEach(() => {
+    setConfigDirForTests(null);
+    if (existsSync(configDir)) rmSync(configDir, { recursive: true, force: true });
+  });
+
+  describe("parseDuration (via createTrigger)", () => {
+    test("handles '30s' — seconds", async () => {
+      const trigger = await createTrigger("test-s", "30s", "echo hi", "/tmp");
+      expect(trigger.schedule).toBe("30s");
+      // nextRun should be ~30 seconds from now
+      const nextMs = new Date(trigger.nextRun!).getTime();
+      const expectedMs = Date.now() + 30_000;
+      expect(Math.abs(nextMs - expectedMs)).toBeLessThan(2000);
+    });
+
+    test("handles '5m' — minutes", async () => {
+      const trigger = await createTrigger("test-m", "5m", "echo hi", "/tmp");
+      const nextMs = new Date(trigger.nextRun!).getTime();
+      const expectedMs = Date.now() + 5 * 60_000;
+      expect(Math.abs(nextMs - expectedMs)).toBeLessThan(2000);
+    });
+
+    test("handles '1h' — hours", async () => {
+      const trigger = await createTrigger("test-h", "1h", "echo hi", "/tmp");
+      const nextMs = new Date(trigger.nextRun!).getTime();
+      const expectedMs = Date.now() + 3_600_000;
+      expect(Math.abs(nextMs - expectedMs)).toBeLessThan(2000);
+    });
+
+    test("handles '2d' — days", async () => {
+      const trigger = await createTrigger("test-d", "2d", "echo hi", "/tmp");
+      const nextMs = new Date(trigger.nextRun!).getTime();
+      const expectedMs = Date.now() + 2 * 86_400_000;
+      expect(Math.abs(nextMs - expectedMs)).toBeLessThan(2000);
+    });
+
+    test("rejects invalid schedule format", async () => {
+      expect(createTrigger("bad", "5x", "echo", "/tmp")).rejects.toThrow(
+        /Invalid schedule/,
+      );
+    });
+  });
+
+  describe("createTrigger", () => {
+    test("saves trigger to disk", async () => {
+      const trigger = await createTrigger("my-task", "10m", "run tests", "/projects/foo");
+      expect(trigger.id).toMatch(/^trigger-/);
+      expect(trigger.name).toBe("my-task");
+      expect(trigger.prompt).toBe("run tests");
+      expect(trigger.cwd).toBe("/projects/foo");
+      expect(trigger.enabled).toBe(true);
+      expect(trigger.runCount).toBe(0);
+
+      // Verify file exists on disk
+      const filePath = join(configDir, "triggers", `${trigger.id}.json`);
+      expect(existsSync(filePath)).toBe(true);
+    });
+  });
+
+  describe("listTriggers", () => {
+    test("returns saved triggers", async () => {
+      await createTrigger("a", "1m", "do a", "/tmp");
+      // Small delay to ensure unique IDs (based on Date.now())
+      await new Promise((r) => setTimeout(r, 5));
+      await createTrigger("b", "2m", "do b", "/tmp");
+
+      const triggers = await listTriggers();
+      expect(triggers.length).toBe(2);
+      const names = triggers.map((t) => t.name);
+      expect(names).toContain("a");
+      expect(names).toContain("b");
+    });
+
+    test("returns empty when no triggers exist", async () => {
+      const triggers = await listTriggers();
+      expect(triggers).toEqual([]);
+    });
+  });
+
+  describe("deleteTrigger", () => {
+    test("removes trigger file", async () => {
+      const trigger = await createTrigger("delete-me", "1m", "x", "/tmp");
+      expect(await deleteTrigger(trigger.id)).toBe(true);
+
+      const filePath = join(configDir, "triggers", `${trigger.id}.json`);
+      expect(existsSync(filePath)).toBe(false);
+
+      const remaining = await listTriggers();
+      expect(remaining.length).toBe(0);
+    });
+
+    test("returns false for non-existent trigger", async () => {
+      expect(await deleteTrigger("trigger-doesnt-exist")).toBe(false);
+    });
+  });
+
+  describe("getDueTriggers", () => {
+    test("returns only due triggers", () => {
+      const now = Date.now();
+      const triggers: CronTrigger[] = [
+        {
+          id: "t1", name: "due", schedule: "1m", prompt: "x", cwd: "/",
+          enabled: true, runCount: 0, createdAt: new Date().toISOString(),
+          nextRun: new Date(now - 60_000).toISOString(), // 1 min ago — due
+        },
+        {
+          id: "t2", name: "not-yet", schedule: "1m", prompt: "x", cwd: "/",
+          enabled: true, runCount: 0, createdAt: new Date().toISOString(),
+          nextRun: new Date(now + 60_000).toISOString(), // 1 min future — not due
+        },
+        {
+          id: "t3", name: "disabled-due", schedule: "1m", prompt: "x", cwd: "/",
+          enabled: false, runCount: 0, createdAt: new Date().toISOString(),
+          nextRun: new Date(now - 60_000).toISOString(), // due but disabled
+        },
+      ];
+
+      const due = getDueTriggers(triggers);
+      expect(due.length).toBe(1);
+      expect(due[0]!.id).toBe("t1");
+    });
+
+    test("returns empty when none are due", () => {
+      const triggers: CronTrigger[] = [
+        {
+          id: "t1", name: "future", schedule: "1h", prompt: "x", cwd: "/",
+          enabled: true, runCount: 0, createdAt: new Date().toISOString(),
+          nextRun: new Date(Date.now() + 3_600_000).toISOString(),
+        },
+      ];
+      expect(getDueTriggers(triggers)).toEqual([]);
+    });
+  });
+
+  describe("markRun", () => {
+    test("updates lastRun, runCount, and nextRun", async () => {
+      const trigger = await createTrigger("mark-test", "5m", "x", "/tmp");
+      expect(trigger.runCount).toBe(0);
+      expect(trigger.lastRun).toBeUndefined();
+
+      await markRun(trigger.id);
+
+      // Re-read from disk via listTriggers
+      const triggers = await listTriggers();
+      const updated = triggers.find((t) => t.id === trigger.id)!;
+      expect(updated.runCount).toBe(1);
+      expect(updated.lastRun).toBeDefined();
+      expect(updated.nextRun).toBeDefined();
+
+      // nextRun should be ~5 min from now
+      const nextMs = new Date(updated.nextRun!).getTime();
+      const expectedMs = Date.now() + 5 * 60_000;
+      expect(Math.abs(nextMs - expectedMs)).toBeLessThan(2000);
+    });
+  });
+
+  describe("toggleTrigger", () => {
+    test("flips enabled flag", async () => {
+      const trigger = await createTrigger("toggle-test", "1m", "x", "/tmp");
+      expect(trigger.enabled).toBe(true);
+
+      const toggled = await toggleTrigger(trigger.id);
+      expect(toggled!.enabled).toBe(false);
+
+      const toggledBack = await toggleTrigger(trigger.id);
+      expect(toggledBack!.enabled).toBe(true);
+    });
+
+    test("returns null for non-existent trigger", async () => {
+      const result = await toggleTrigger("trigger-nope");
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/__tests__/dream.test.ts

@@ -0,0 +1,204 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { writeFile, mkdir } from "fs/promises";
+import {
+  generateDream,
+  loadRecentDreams,
+  formatDreamsForPrompt,
+  pruneOldDreams,
+  IdleDetector,
+} from "../agent/dream.ts";
+import { setConfigDirForTests } from "../config/settings.ts";
+import type { Message } from "../providers/types.ts";
+
+let configDir: string;
+
+beforeEach(() => {
+  configDir = mkdtempSync(join(tmpdir(), "ashlrcode-dream-test-"));
+  setConfigDirForTests(configDir);
+});
+
+afterEach(() => {
+  setConfigDirForTests(null);
+  if (existsSync(configDir)) rmSync(configDir, { recursive: true, force: true });
+});
+
+describe("generateDream", () => {
+  test("creates a dream file on disk", async () => {
+    const messages: Message[] = [
+      { role: "user", content: "Hello world" },
+      { role: "assistant", content: "Hi there!" },
+    ];
+
+    const dream = await generateDream(messages, "test-session-1");
+
+    expect(dream.id).toMatch(/^dream-/);
+    expect(dream.sessionId).toBe("test-session-1");
+    expect(dream.turnCount).toBe(1); // 1 user message
+    expect(dream.summary).toContain("user: Hello world");
+
+    // File should exist on disk
+    const dreamPath = join(configDir, "dreams", `${dream.id}.json`);
+    expect(existsSync(dreamPath)).toBe(true);
+  });
+
+  test("extracts tool names from content blocks", async () => {
+    const messages: Message[] = [
+      { role: "user", content: "Do something" },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Running a command" },
+          { type: "tool_use", id: "t1", name: "Bash", input: { command: "ls" } },
+        ],
+      },
+      {
+        role: "tool",
+        content: [
+          { type: "tool_result", tool_use_id: "t1", content: "file.txt" },
+        ],
+      },
+    ];
+
+    const dream = await generateDream(messages, "test-session-2");
+    expect(dream.toolsUsed).toContain("Bash");
+  });
+});
+
+describe("loadRecentDreams", () => {
+  test("loads saved dreams", async () => {
+    // Generate a couple of dreams
+    const msgs: Message[] = [{ role: "user", content: "Test" }];
+    await generateDream(msgs, "s1");
+    // Small delay so filenames differ
+    await new Promise((r) => setTimeout(r, 5));
+    await generateDream(msgs, "s2");
+
+    const dreams = await loadRecentDreams(10);
+    expect(dreams.length).toBe(2);
+  });
+
+  test("respects limit parameter", async () => {
+    const msgs: Message[] = [{ role: "user", content: "Test" }];
+    for (let i = 0; i < 5; i++) {
+      await generateDream(msgs, `s${i}`);
+      await new Promise((r) => setTimeout(r, 5));
+    }
+
+    const dreams = await loadRecentDreams(2);
+    expect(dreams.length).toBe(2);
+  });
+
+  test("returns empty array when no dreams dir exists", async () => {
+    const dreams = await loadRecentDreams();
+    expect(dreams).toEqual([]);
+  });
+});
+
+describe("formatDreamsForPrompt", () => {
+  test("returns empty string for no dreams", () => {
+    expect(formatDreamsForPrompt([])).toBe("");
+  });
+
+  test("formats dreams with header and content", () => {
+    const dreams = [
+      {
+        id: "dream-1",
+        timestamp: "2026-01-15T10:00:00.000Z",
+        summary: "user: Did some work\nassistant: Completed task",
+        sessionId: "s1",
+        turnCount: 3,
+        toolsUsed: ["Bash", "Read"],
+      },
+    ];
+
+    const result = formatDreamsForPrompt(dreams);
+    expect(result).toContain("## Recent Session Dreams");
+    expect(result).toContain("3 turns");
+    expect(result).toContain("tools: Bash, Read");
+    expect(result).toContain("user: Did some work");
+  });
+
+  test("omits tools section when no tools used", () => {
+    const dreams = [
+      {
+        id: "dream-2",
+        timestamp: "2026-01-15T10:00:00.000Z",
+        summary: "conversation summary",
+        sessionId: "s2",
+        turnCount: 1,
+        toolsUsed: [],
+      },
+    ];
+
+    const result = formatDreamsForPrompt(dreams);
+    expect(result).not.toContain("tools:");
+  });
+});
+
+describe("pruneOldDreams", () => {
+  test("keeps only recent N dreams", async () => {
+    const msgs: Message[] = [{ role: "user", content: "Test" }];
+    for (let i = 0; i < 5; i++) {
+      await generateDream(msgs, `s${i}`);
+      await new Promise((r) => setTimeout(r, 5));
+    }
+
+    const deleted = await pruneOldDreams(2);
+    expect(deleted).toBe(3);
+
+    const remaining = await loadRecentDreams(10);
+    expect(remaining.length).toBe(2);
+  });
+
+  test("returns 0 when no dreams dir exists", async () => {
+    const deleted = await pruneOldDreams(5);
+    expect(deleted).toBe(0);
+  });
+});
+
+describe("IdleDetector", () => {
+  test("fires callback after threshold", async () => {
+    let fired = false;
+    const detector = new IdleDetector(() => { fired = true; }, 50);
+    detector.ping();
+
+    await new Promise((r) => setTimeout(r, 100));
+    expect(fired).toBe(true);
+    detector.stop();
+  });
+
+  test("resets on ping", async () => {
+    let fireCount = 0;
+    const detector = new IdleDetector(() => { fireCount++; }, 80);
+
+    detector.ping();
+    await new Promise((r) => setTimeout(r, 40));
+    // Reset before it fires
+    detector.ping();
+    await new Promise((r) => setTimeout(r, 40));
+    // Reset again
+    detector.ping();
+    await new Promise((r) => setTimeout(r, 40));
+
+    // Should not have fired yet (each ping resets the 80ms timer)
+    expect(fireCount).toBe(0);
+
+    // Now wait for it to fire
+    await new Promise((r) => setTimeout(r, 100));
+    expect(fireCount).toBe(1);
+    detector.stop();
+  });
+
+  test("stop prevents callback from firing", async () => {
+    let fired = false;
+    const detector = new IdleDetector(() => { fired = true; }, 50);
+    detector.ping();
+    detector.stop();
+
+    await new Promise((r) => setTimeout(r, 100));
+    expect(fired).toBe(false);
+  });
+});