@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/server/src/__tests__/package-manager-wrapper.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { PackageManagerWrapper, PackageOperationBusyError } from "../package-manager-wrapper.js";
+
+// Track mock functions
+const installAndPersist = vi.fn().mockResolvedValue(undefined);
+const removeAndPersist = vi.fn().mockResolvedValue(undefined);
+const update = vi.fn().mockResolvedValue(undefined);
+const listConfiguredPackages = vi.fn().mockReturnValue([
+  { source: "npm:pi-doom", scope: "user", filtered: false },
+  { source: "npm:pi-local", scope: "project", filtered: false },
+]);
+const checkForAvailableUpdates = vi.fn().mockResolvedValue([
+  { source: "npm:pi-doom", displayName: "pi-doom", type: "npm" },
+]);
+const setProgressCallback = vi.fn();
+
+vi.mock("@mariozechner/pi-coding-agent", () => {
+  const MockPM = function() {
+    return {
+      installAndPersist,
+      removeAndPersist,
+      update,
+      listConfiguredPackages,
+      checkForAvailableUpdates,
+      setProgressCallback,
+    };
+  };
+  return {
+    DefaultPackageManager: MockPM,
+    SettingsManager: { create: () => ({}) },
+    default: undefined,
+  };
+});
+
+describe("PackageManagerWrapper", () => {
+  let wrapper: PackageManagerWrapper;
+
+  beforeEach(() => {
+    installAndPersist.mockReset().mockResolvedValue(undefined);
+    removeAndPersist.mockReset().mockResolvedValue(undefined);
+    update.mockReset().mockResolvedValue(undefined);
+    listConfiguredPackages.mockReset().mockReturnValue([
+      { source: "npm:pi-doom", scope: "user", filtered: false },
+      { source: "npm:pi-local", scope: "project", filtered: false },
+    ]);
+    checkForAvailableUpdates.mockReset().mockResolvedValue([
+      { source: "npm:pi-doom", displayName: "pi-doom", type: "npm" },
+    ]);
+    setProgressCallback.mockReset();
+    wrapper = new PackageManagerWrapper();
+  });
+
+  it("returns operationId on run", async () => {
+    const id = await wrapper.run({ action: "install", source: "npm:test", scope: "global" });
+    expect(id).toMatch(/^[0-9a-f-]+$/);
+  });
+
+  it("throws PackageOperationBusyError on concurrent operations", async () => {
+    let resolveInstall!: () => void;
+    installAndPersist.mockImplementation(() => new Promise<void>((r) => { resolveInstall = r; }));
+
+    await wrapper.run({ action: "install", source: "npm:a", scope: "global" });
+    // Wait for the dynamic import + installAndPersist to be called
+    await vi.waitFor(() => expect(installAndPersist).toHaveBeenCalled());
+
+    await expect(
+      wrapper.run({ action: "install", source: "npm:b", scope: "global" }),
+    ).rejects.toThrow(PackageOperationBusyError);
+
+    resolveInstall();
+    await vi.waitFor(() => expect(wrapper.isBusy()).toBe(false));
+  });
+
+  it("forwards progress events via listener", async () => {
+    const progressEvents: any[] = [];
+
+    let capturedCallback: any;
+    setProgressCallback.mockImplementation((cb: any) => { capturedCallback = cb; });
+    installAndPersist.mockImplementation(async () => {
+      capturedCallback?.({ type: "start", action: "install", source: "npm:test" });
+      capturedCallback?.({ type: "complete", action: "install", source: "npm:test" });
+    });
+
+    wrapper.setProgressListener((opId, event) => {
+      progressEvents.push({ opId, event });
+    });
+
+    const opId = await wrapper.run({ action: "install", source: "npm:test", scope: "global" });
+    await vi.waitFor(() => expect(wrapper.isBusy()).toBe(false));
+
+    expect(progressEvents.length).toBe(2);
+    expect(progressEvents[0].opId).toBe(opId);
+    expect(progressEvents[0].event.type).toBe("start");
+    expect(progressEvents[1].event.type).toBe("complete");
+  });
+
+  it("calls reloadSessions on success", async () => {
+    const reloadFn = vi.fn().mockResolvedValue(3);
+    wrapper.setReloadSessions(reloadFn);
+
+    const completions: any[] = [];
+    wrapper.setCompleteListener((result) => completions.push(result));
+
+    await wrapper.run({ action: "install", source: "npm:test", scope: "global" });
+    await vi.waitFor(() => expect(wrapper.isBusy()).toBe(false));
+
+    expect(reloadFn).toHaveBeenCalledOnce();
+    expect(completions[0].success).toBe(true);
+    expect(completions[0].sessionsReloaded).toBe(3);
+  });
+
+  it("does NOT call reloadSessions on failure", async () => {
+    installAndPersist.mockRejectedValue(new Error("npm exploded"));
+
+    const reloadFn = vi.fn().mockResolvedValue(0);
+    wrapper.setReloadSessions(reloadFn);
+
+    const completions: any[] = [];
+    wrapper.setCompleteListener((result) => completions.push(result));
+
+    await wrapper.run({ action: "install", source: "npm:test", scope: "global" });
+    await vi.waitFor(() => expect(wrapper.isBusy()).toBe(false));
+
+    expect(reloadFn).not.toHaveBeenCalled();
+    expect(completions[0].success).toBe(false);
+    expect(completions[0].error).toBe("npm exploded");
+  });
+
+  it("listInstalled filters by scope", async () => {
+    const global = await wrapper.listInstalled("global");
+    expect(global).toEqual([{ source: "npm:pi-doom", scope: "user", filtered: false }]);
+
+    const local = await wrapper.listInstalled("local");
+    expect(local).toEqual([{ source: "npm:pi-local", scope: "project", filtered: false }]);
+  });
+
+  it("checkUpdates delegates to PackageManager", async () => {
+    const updates = await wrapper.checkUpdates();
+    expect(updates).toEqual([{ source: "npm:pi-doom", displayName: "pi-doom", type: "npm" }]);
+  });
+
+  it("calls remove for remove action", async () => {
+    const completions: any[] = [];
+    wrapper.setCompleteListener((result) => completions.push(result));
+
+    await wrapper.run({ action: "remove", source: "npm:test", scope: "local", cwd: "/tmp" });
+    await vi.waitFor(() => expect(wrapper.isBusy()).toBe(false));
+
+    expect(removeAndPersist).toHaveBeenCalledWith("npm:test", { local: true });
+    expect(completions[0].success).toBe(true);
+  });
+
+  it("calls update for update action", async () => {
+    const completions: any[] = [];
+    wrapper.setCompleteListener((result) => completions.push(result));
+
+    await wrapper.run({ action: "update", source: "npm:test", scope: "global" });
+    await vi.waitFor(() => expect(wrapper.isBusy()).toBe(false));
+
+    expect(update).toHaveBeenCalledWith("npm:test");
+    expect(completions[0].success).toBe(true);
+  });
+});

package/packages/server/src/__tests__/package-routes.test.ts

@@ -0,0 +1,172 @@
+/**
+ * Tests for package management REST routes.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import Fastify from "fastify";
+import type { FastifyInstance } from "fastify";
+import { registerPackageRoutes } from "../routes/package-routes.js";
+import { PackageOperationBusyError } from "../package-manager-wrapper.js";
+
+// Mock pi dependency (pulled transitively by package-manager-wrapper)
+vi.mock("@mariozechner/pi-coding-agent", () => ({
+  DefaultPackageManager: function() { return {}; },
+  SettingsManager: { create: () => ({}) },
+}));
+
+// Mock npm-search-proxy
+vi.mock("../npm-search-proxy.js", () => ({
+  searchPackages: vi.fn().mockResolvedValue({ packages: [{ name: "pi-doom", types: ["extension"] }], total: 1 }),
+  fetchReadme: vi.fn().mockResolvedValue({ readme: "# Test", name: "pi-doom", version: "1.0.0" }),
+  PackageNotFoundError: class PackageNotFoundError extends Error {
+    constructor(name: string) { super(`Package not found: ${name}`); this.name = "PackageNotFoundError"; }
+  },
+}));
+
+import { searchPackages, fetchReadme, PackageNotFoundError } from "../npm-search-proxy.js";
+
+function createMockWrapper() {
+  return {
+    run: vi.fn().mockResolvedValue("op-123"),
+    listInstalled: vi.fn().mockReturnValue([{ source: "npm:pi-doom", scope: "user", filtered: false }]),
+    checkUpdates: vi.fn().mockResolvedValue([]),
+    isBusy: vi.fn().mockReturnValue(false),
+    setProgressListener: vi.fn(),
+    setCompleteListener: vi.fn(),
+    setReloadSessions: vi.fn(),
+  } as any;
+}
+
+describe("package-routes", () => {
+  let app: FastifyInstance;
+  let wrapper: ReturnType<typeof createMockWrapper>;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    wrapper = createMockWrapper();
+    app = Fastify();
+    registerPackageRoutes(app, { packageManagerWrapper: wrapper });
+    await app.ready();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  describe("GET /api/packages/search", () => {
+    it("returns search results", async () => {
+      const res = await app.inject({ method: "GET", url: "/api/packages/search?q=doom" });
+      expect(res.statusCode).toBe(200);
+      const body = JSON.parse(res.body);
+      expect(body.success).toBe(true);
+      expect(body.data.packages[0].name).toBe("pi-doom");
+    });
+
+    it("passes type filter", async () => {
+      await app.inject({ method: "GET", url: "/api/packages/search?type=extension" });
+      expect(searchPackages).toHaveBeenCalledWith({ query: undefined, type: "extension" });
+    });
+  });
+
+  describe("GET /api/packages/readme", () => {
+    it("returns readme", async () => {
+      const res = await app.inject({ method: "GET", url: "/api/packages/readme?pkg=pi-doom" });
+      expect(res.statusCode).toBe(200);
+      const body = JSON.parse(res.body);
+      expect(body.data.readme).toBe("# Test");
+    });
+
+    it("returns 400 without pkg param", async () => {
+      const res = await app.inject({ method: "GET", url: "/api/packages/readme" });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it("returns 404 for missing package", async () => {
+      vi.mocked(fetchReadme).mockRejectedValueOnce(new PackageNotFoundError("x"));
+      const res = await app.inject({ method: "GET", url: "/api/packages/readme?pkg=x" });
+      expect(res.statusCode).toBe(404);
+    });
+  });
+
+  describe("GET /api/packages/installed", () => {
+    it("returns installed packages", async () => {
+      const res = await app.inject({ method: "GET", url: "/api/packages/installed?scope=global" });
+      expect(res.statusCode).toBe(200);
+      const body = JSON.parse(res.body);
+      expect(body.data[0].source).toBe("npm:pi-doom");
+    });
+  });
+
+  describe("POST /api/packages/install", () => {
+    it("returns 202 with operationId", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/packages/install",
+        payload: { source: "npm:test", scope: "global" },
+      });
+      expect(res.statusCode).toBe(202);
+      const body = JSON.parse(res.body);
+      expect(body.data.operationId).toBe("op-123");
+    });
+
+    it("returns 400 without source", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/packages/install",
+        payload: { scope: "global" },
+      });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it("returns 409 when busy", async () => {
+      wrapper.run.mockRejectedValueOnce(new PackageOperationBusyError());
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/packages/install",
+        payload: { source: "npm:test", scope: "global" },
+      });
+      expect(res.statusCode).toBe(409);
+    });
+  });
+
+  describe("POST /api/packages/remove", () => {
+    it("returns 202", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/packages/remove",
+        payload: { source: "npm:test", scope: "local", cwd: "/tmp" },
+      });
+      expect(res.statusCode).toBe(202);
+      expect(wrapper.run).toHaveBeenCalledWith({
+        action: "remove",
+        source: "npm:test",
+        scope: "local",
+        cwd: "/tmp",
+      });
+    });
+  });
+
+  describe("POST /api/packages/update", () => {
+    it("returns 202", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/packages/update",
+        payload: { scope: "global" },
+      });
+      expect(res.statusCode).toBe(202);
+    });
+  });
+
+  describe("POST /api/packages/check-updates", () => {
+    it("returns updates list", async () => {
+      wrapper.checkUpdates.mockResolvedValueOnce([{ source: "npm:pi-doom", displayName: "pi-doom", type: "npm" }]);
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/packages/check-updates",
+        payload: {},
+      });
+      expect(res.statusCode).toBe(200);
+      const body = JSON.parse(res.body);
+      expect(body.data[0].source).toBe("npm:pi-doom");
+    });
+  });
+});

package/packages/server/src/__tests__/pending-fork-registry.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createPendingForkRegistry } from "../pending-fork-registry.js";
+
+describe("PendingForkRegistry", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("records and consumes a fork", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("/project", "parent-1");
+    const result = reg.consumeFork("/project");
+    expect(result).toBe("parent-1");
+  });
+
+  it("returns undefined when no fork pending", () => {
+    const reg = createPendingForkRegistry();
+    expect(reg.consumeFork("/project")).toBeUndefined();
+  });
+
+  it("consume clears the entry", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("/project", "parent-1");
+    reg.consumeFork("/project");
+    expect(reg.consumeFork("/project")).toBeUndefined();
+  });
+
+  it("expires after 30 seconds", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("/project", "parent-1");
+    vi.advanceTimersByTime(30_001);
+    expect(reg.consumeFork("/project")).toBeUndefined();
+  });
+
+  it("does not expire before 30 seconds", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("/project", "parent-1");
+    vi.advanceTimersByTime(29_999);
+    expect(reg.consumeFork("/project")).toBe("parent-1");
+  });
+
+  it("latest fork overwrites previous for same cwd", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("/project", "parent-1");
+    reg.recordFork("/project", "parent-2");
+    expect(reg.consumeFork("/project")).toBe("parent-2");
+  });
+
+  it("different cwds are independent", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("/a", "parent-a");
+    reg.recordFork("/b", "parent-b");
+    expect(reg.consumeFork("/a")).toBe("parent-a");
+    expect(reg.consumeFork("/b")).toBe("parent-b");
+  });
+
+  it("dispose clears all timers", () => {
+    const reg = createPendingForkRegistry();
+    reg.recordFork("/a", "parent-a");
+    reg.recordFork("/b", "parent-b");
+    reg.dispose();
+    expect(reg.consumeFork("/a")).toBeUndefined();
+    expect(reg.consumeFork("/b")).toBeUndefined();
+  });
+});

package/packages/server/src/__tests__/pending-load-manager.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createPendingLoadManager } from "../pending-load-manager.js";
+
+// Minimal WebSocket mock
+function mockWs(): any {
+  return { readyState: 1 };
+}
+
+describe("pending-load-manager", () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  it("starts and completes a load", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout);
+    const ws = mockWs();
+
+    expect(plm.start("s1", ws, "bridge1")).toBe(true);
+    expect(plm.isPending("s1")).toBe(true);
+
+    const browsers = plm.complete("s1");
+    expect(browsers).toBeDefined();
+    expect(browsers!.has(ws)).toBe(true);
+    expect(plm.isPending("s1")).toBe(false);
+    plm.dispose();
+  });
+
+  it("deduplicates — second start returns false", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout);
+
+    plm.start("s1", mockWs(), "bridge1");
+    expect(plm.start("s1", mockWs(), "bridge1")).toBe(false);
+    plm.dispose();
+  });
+
+  it("addBrowser adds to existing pending load", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout);
+    const ws1 = mockWs();
+    const ws2 = mockWs();
+
+    plm.start("s1", ws1, "bridge1");
+    expect(plm.addBrowser("s1", ws2)).toBe(true);
+
+    const browsers = plm.complete("s1");
+    expect(browsers!.size).toBe(2);
+    expect(browsers!.has(ws1)).toBe(true);
+    expect(browsers!.has(ws2)).toBe(true);
+    plm.dispose();
+  });
+
+  it("addBrowser returns false when no pending load", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout);
+    expect(plm.addBrowser("s1", mockWs())).toBe(false);
+    plm.dispose();
+  });
+
+  it("fires timeout callback after timeout", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout, 5000);
+    const ws = mockWs();
+
+    plm.start("s1", ws, "bridge1");
+    vi.advanceTimersByTime(5100);
+
+    expect(onTimeout).toHaveBeenCalledWith("s1", expect.any(Set));
+    expect(plm.isPending("s1")).toBe(false);
+    plm.dispose();
+  });
+
+  it("complete cancels timeout", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout, 5000);
+
+    plm.start("s1", mockWs(), "bridge1");
+    plm.complete("s1");
+    vi.advanceTimersByTime(6000);
+
+    expect(onTimeout).not.toHaveBeenCalled();
+    plm.dispose();
+  });
+
+  it("cancelForBridge cancels all loads for that bridge", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout);
+    const ws1 = mockWs();
+    const ws2 = mockWs();
+
+    plm.start("s1", ws1, "bridge-a");
+    plm.start("s2", ws2, "bridge-a");
+    plm.start("s3", mockWs(), "bridge-b");
+
+    const cancelled = plm.cancelForBridge("bridge-a");
+    expect(cancelled.size).toBe(2);
+    expect(cancelled.has("s1")).toBe(true);
+    expect(cancelled.has("s2")).toBe(true);
+    expect(plm.isPending("s1")).toBe(false);
+    expect(plm.isPending("s2")).toBe(false);
+    expect(plm.isPending("s3")).toBe(true);
+
+    plm.dispose();
+  });
+
+  it("cancel removes a specific pending load", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout);
+    const ws = mockWs();
+
+    plm.start("s1", ws, "bridge1");
+    const browsers = plm.cancel("s1");
+    expect(browsers).toBeDefined();
+    expect(browsers!.has(ws)).toBe(true);
+    expect(plm.isPending("s1")).toBe(false);
+    plm.dispose();
+  });
+
+  it("cancel returns null for nonexistent load", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout);
+    expect(plm.cancel("s1")).toBeNull();
+    plm.dispose();
+  });
+
+  it("complete returns null for nonexistent load", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout);
+    expect(plm.complete("nonexistent")).toBeNull();
+    plm.dispose();
+  });
+
+  it("dispose clears all pending loads and timers", () => {
+    const onTimeout = vi.fn();
+    const plm = createPendingLoadManager(onTimeout, 5000);
+
+    plm.start("s1", mockWs(), "bridge1");
+    plm.start("s2", mockWs(), "bridge1");
+    plm.dispose();
+
+    vi.advanceTimersByTime(6000);
+    expect(onTimeout).not.toHaveBeenCalled();
+  });
+});

package/packages/server/src/__tests__/pending-resume-registry.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createPendingResumeRegistry } from "../pending-resume-registry.js";
+
+describe("PendingResumeRegistry", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("records and consumes a pending resume", () => {
+    const reg = createPendingResumeRegistry();
+    reg.record("/project", {
+      text: "fix the bug",
+      oldSessionId: "old-1",
+      sessionFile: "session.jsonl",
+    });
+    const result = reg.consume("/project");
+    expect(result).toEqual({
+      text: "fix the bug",
+      oldSessionId: "old-1",
+      sessionFile: "session.jsonl",
+    });
+  });
+
+  it("returns undefined when no pending resume", () => {
+    const reg = createPendingResumeRegistry();
+    expect(reg.consume("/project")).toBeUndefined();
+  });
+
+  it("consume clears the entry", () => {
+    const reg = createPendingResumeRegistry();
+    reg.record("/project", {
+      text: "fix it",
+      oldSessionId: "old-1",
+      sessionFile: "session.jsonl",
+    });
+    reg.consume("/project");
+    expect(reg.consume("/project")).toBeUndefined();
+  });
+
+  it("expires after 30 seconds", () => {
+    const onTimeout = vi.fn();
+    const reg = createPendingResumeRegistry({ onTimeout });
+    reg.record("/project", {
+      text: "fix it",
+      oldSessionId: "old-1",
+      sessionFile: "session.jsonl",
+    });
+    vi.advanceTimersByTime(30_001);
+    expect(reg.consume("/project")).toBeUndefined();
+    expect(onTimeout).toHaveBeenCalledWith("old-1");
+  });
+
+  it("does not expire before 30 seconds", () => {
+    const reg = createPendingResumeRegistry();
+    reg.record("/project", {
+      text: "fix it",
+      oldSessionId: "old-1",
+      sessionFile: "session.jsonl",
+    });
+    vi.advanceTimersByTime(29_999);
+    expect(reg.consume("/project")).toBeDefined();
+  });
+
+  it("latest entry overwrites previous for same cwd", () => {
+    const reg = createPendingResumeRegistry();
+    reg.record("/project", {
+      text: "first prompt",
+      oldSessionId: "old-1",
+      sessionFile: "session.jsonl",
+    });
+    reg.record("/project", {
+      text: "second prompt",
+      oldSessionId: "old-2",
+      sessionFile: "session2.jsonl",
+    });
+    const result = reg.consume("/project");
+    expect(result?.text).toBe("second prompt");
+    expect(result?.oldSessionId).toBe("old-2");
+  });
+
+  it("different cwds are independent", () => {
+    const reg = createPendingResumeRegistry();
+    reg.record("/a", { text: "prompt-a", oldSessionId: "old-a", sessionFile: "a.jsonl" });
+    reg.record("/b", { text: "prompt-b", oldSessionId: "old-b", sessionFile: "b.jsonl" });
+    expect(reg.consume("/a")?.text).toBe("prompt-a");
+    expect(reg.consume("/b")?.text).toBe("prompt-b");
+  });
+
+  it("preserves images in pending resume", () => {
+    const reg = createPendingResumeRegistry();
+    const images = [{ type: "image" as const, data: "base64data", mimeType: "image/png" }];
+    reg.record("/project", {
+      text: "look at this",
+      images,
+      oldSessionId: "old-1",
+      sessionFile: "session.jsonl",
+    });
+    const result = reg.consume("/project");
+    expect(result?.images).toEqual(images);
+  });
+
+  it("dispose clears all entries and timers", () => {
+    const onTimeout = vi.fn();
+    const reg = createPendingResumeRegistry({ onTimeout });
+    reg.record("/a", { text: "a", oldSessionId: "old-a", sessionFile: "a.jsonl" });
+    reg.record("/b", { text: "b", oldSessionId: "old-b", sessionFile: "b.jsonl" });
+    reg.dispose();
+    expect(reg.consume("/a")).toBeUndefined();
+    expect(reg.consume("/b")).toBeUndefined();
+    // Timers should not fire after dispose
+    vi.advanceTimersByTime(31_000);
+    expect(onTimeout).not.toHaveBeenCalled();
+  });
+
+  it("overwrite clears previous timer", () => {
+    const onTimeout = vi.fn();
+    const reg = createPendingResumeRegistry({ onTimeout });
+    reg.record("/project", { text: "first", oldSessionId: "old-1", sessionFile: "s.jsonl" });
+    vi.advanceTimersByTime(20_000);
+    reg.record("/project", { text: "second", oldSessionId: "old-2", sessionFile: "s.jsonl" });
+    vi.advanceTimersByTime(15_000); // 35s from first, 15s from second
+    // First timer would have fired at 30s, but was cleared by overwrite
+    expect(onTimeout).not.toHaveBeenCalled();
+    expect(reg.consume("/project")?.text).toBe("second");
+  });
+});