@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/server/src/__tests__/session-diff.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect } from "vitest";
+import { extractFileChanges } from "../session-diff.js";
+import type { DashboardEvent } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+
+function makeEvent(eventType: string, timestamp: number, data: Record<string, unknown> = {}): DashboardEvent {
+  return { eventType, timestamp, data: { type: eventType, ...data } };
+}
+
+function makeToolStart(toolName: string, args: Record<string, unknown>, timestamp = 1000): DashboardEvent {
+  return makeEvent("tool_execution_start", timestamp, { toolName, toolCallId: `tc-${timestamp}`, args });
+}
+
+function makeMessageEnd(text: string, timestamp = 900): DashboardEvent {
+  return makeEvent("message_end", timestamp, {
+    message: { role: "assistant", content: [{ type: "text", text }] },
+  });
+}
+
+describe("extractFileChanges", () => {
+  const cwd = "/project";
+
+  it("should extract Write tool events", () => {
+    const events = [
+      makeToolStart("Write", { path: "src/foo.ts", content: "hello world" }, 1000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe("src/foo.ts");
+    expect(result[0].changes).toHaveLength(1);
+    expect(result[0].changes[0].type).toBe("write");
+    expect(result[0].changes[0].content).toBe("hello world");
+    expect(result[0].changes[0].timestamp).toBe(1000);
+  });
+
+  it("should extract Edit tool events", () => {
+    const edits = [{ oldText: "foo", newText: "bar" }];
+    const events = [
+      makeToolStart("Edit", { path: "src/bar.ts", edits }, 2000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe("src/bar.ts");
+    expect(result[0].changes[0].type).toBe("edit");
+    expect(result[0].changes[0].edits).toEqual(edits);
+  });
+
+  it("should be case-insensitive for tool names", () => {
+    const events = [
+      makeToolStart("write", { path: "a.ts", content: "x" }, 1000),
+      makeToolStart("EDIT", { path: "b.ts", edits: [{ oldText: "a", newText: "b" }] }, 2000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result).toHaveLength(2);
+  });
+
+  it("should support file_path arg alias", () => {
+    const events = [
+      makeToolStart("Write", { file_path: "src/alt.ts", content: "x" }, 1000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe("src/alt.ts");
+  });
+
+  it("should group multiple changes to same file", () => {
+    const events = [
+      makeToolStart("Write", { path: "src/foo.ts", content: "v1" }, 1000),
+      makeToolStart("Edit", { path: "src/foo.ts", edits: [{ oldText: "v1", newText: "v2" }] }, 2000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result).toHaveLength(1);
+    expect(result[0].changes).toHaveLength(2);
+    expect(result[0].changes[0].type).toBe("write");
+    expect(result[0].changes[1].type).toBe("edit");
+  });
+
+  it("should order changes by timestamp", () => {
+    const events = [
+      makeToolStart("Edit", { path: "src/foo.ts", edits: [{ oldText: "a", newText: "b" }] }, 3000),
+      makeToolStart("Write", { path: "src/foo.ts", content: "init" }, 1000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result[0].changes[0].timestamp).toBe(1000);
+    expect(result[0].changes[1].timestamp).toBe(3000);
+  });
+
+  it("should filter out absolute paths outside cwd", () => {
+    const events = [
+      makeToolStart("Write", { path: "/tmp/scratch.ts", content: "x" }, 1000),
+      makeToolStart("Write", { path: "/project/src/inside.ts", content: "y" }, 2000),
+      makeToolStart("Write", { path: "src/relative.ts", content: "z" }, 3000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result).toHaveLength(2);
+    expect(result.map((f) => f.path).sort()).toEqual(["src/inside.ts", "src/relative.ts"]);
+  });
+
+  it("should extract preceding assistant message as context", () => {
+    const events = [
+      makeMessageEnd("I'll create the file now", 900),
+      makeToolStart("Write", { path: "src/foo.ts", content: "hello" }, 1000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result[0].changes[0].message).toBe("I'll create the file now");
+  });
+
+  it("should truncate long context messages to 120 chars", () => {
+    const longMsg = "A".repeat(200);
+    const events = [
+      makeMessageEnd(longMsg, 900),
+      makeToolStart("Write", { path: "src/foo.ts", content: "hello" }, 1000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result[0].changes[0].message!.length).toBeLessThanOrEqual(123); // 120 + "..."
+  });
+
+  it("should ignore non-Write/Edit tool events", () => {
+    const events = [
+      makeToolStart("Read", { path: "src/foo.ts" }, 1000),
+      makeToolStart("Bash", { command: "ls" }, 2000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result).toHaveLength(0);
+  });
+
+  it("should skip events with no path", () => {
+    const events = [
+      makeToolStart("Write", { content: "no path" }, 1000),
+    ];
+    const result = extractFileChanges(events, cwd);
+    expect(result).toHaveLength(0);
+  });
+
+  it("should return empty array for empty events", () => {
+    const result = extractFileChanges([], cwd);
+    expect(result).toHaveLength(0);
+  });
+});

package/packages/server/src/__tests__/session-file-dedup.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Tests that when a new session registers with a sessionFile already used by
+ * another session, the old session's sessionFile is cleared.
+ * This prevents resuming a stale session from loading the wrong conversation.
+ */
+import { describe, it, expect, afterAll } from "vitest";
+import { createServer, type DashboardServer } from "../server.js";
+import { WebSocket } from "ws";
+
+function waitForOpen(ws: WebSocket): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (ws.readyState === WebSocket.OPEN) return resolve();
+    ws.on("open", resolve);
+    ws.on("error", reject);
+    setTimeout(() => reject(new Error("open timeout")), 3000);
+  });
+}
+
+function collectMsgs(ws: WebSocket, ms: number): Promise<any[]> {
+  return new Promise((resolve) => {
+    const arr: any[] = [];
+    const h = (raw: any) => arr.push(JSON.parse(raw.toString()));
+    ws.on("message", h);
+    setTimeout(() => { ws.off("message", h); resolve(arr); }, ms);
+  });
+}
+
+const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
+const httpPort = 19090;
+const piPort = 19091;
+let server: DashboardServer;
+
+describe("session file deduplication", () => {
+  afterAll(async () => {
+    if (server) await server.stop();
+  });
+
+  it("clears sessionFile from old session when new session registers with same file", async () => {
+    server = await createServer({
+      port: httpPort, piPort, dev: true,
+      autoShutdown: false, shutdownIdleSeconds: 999, tunnel: false,
+    editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+    });
+    await server.start();
+
+    const sharedFile = "/tmp/sessions/test.jsonl";
+
+    // Bridge registers session A with a sessionFile
+    const bridge = new WebSocket(`ws://localhost:${piPort}`);
+    await waitForOpen(bridge);
+    bridge.send(JSON.stringify({
+      type: "session_register",
+      sessionId: "session-a",
+      cwd: "/tmp/project",
+      source: "tui",
+      name: "filesystem-browser",
+      sessionFile: sharedFile,
+    }));
+    await delay(100);
+
+    // Session A ends
+    bridge.send(JSON.stringify({
+      type: "session_unregister",
+      sessionId: "session-a",
+    }));
+    await delay(100);
+
+    // Browser connects to observe updates
+    const browser = new WebSocket(`ws://localhost:${httpPort}/ws`);
+    await waitForOpen(browser);
+    const msgs = collectMsgs(browser, 500);
+    await delay(50);
+
+    // Bridge registers session B (continued from same file) with same sessionFile
+    bridge.send(JSON.stringify({
+      type: "session_register",
+      sessionId: "session-b",
+      cwd: "/tmp/project",
+      source: "tui",
+      name: "fix-concurrent-server-launch",
+      sessionFile: sharedFile,
+    }));
+
+    const collected = await msgs;
+
+    // Should see session_updated for session-a clearing its sessionFile
+    const clearUpdate = collected.find(
+      (m: any) => m.type === "session_updated" && m.sessionId === "session-a" && "sessionFile" in (m.updates ?? {}) && m.updates.sessionFile === null,
+    );
+    expect(clearUpdate).toBeDefined();
+
+    // Session B should have the sessionFile
+    const addedB = collected.find(
+      (m: any) => m.type === "session_added" && m.session?.id === "session-b",
+    );
+    expect(addedB?.session?.sessionFile).toBe(sharedFile);
+
+    bridge.close();
+    browser.close();
+    await delay(50);
+  });
+});

package/packages/server/src/__tests__/session-file-reader.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createBranchedSessionFile } from "../session-file-reader.js";
+
+describe("createBranchedSessionFile", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "session-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function writeSession(entries: any[]): string {
+    const path = join(tmpDir, "test-session.jsonl");
+    writeFileSync(path, entries.map(e => JSON.stringify(e)).join("\n") + "\n");
+    return path;
+  }
+
+  it("should create a branched session file with root-to-target path", () => {
+    const sessionFile = writeSession([
+      { type: "session", id: "sess-1", timestamp: "2025-01-01T00:00:00Z", cwd: "/tmp" },
+      { type: "message", id: "e1", parentId: null, message: { role: "user", content: "Hello" } },
+      { type: "message", id: "e2", parentId: "e1", message: { role: "assistant", content: "Hi" } },
+      { type: "message", id: "e3", parentId: "e2", message: { role: "user", content: "More" } },
+      { type: "message", id: "e4", parentId: "e3", message: { role: "assistant", content: "Done" } },
+    ]);
+
+    const newPath = createBranchedSessionFile(sessionFile, "e2");
+    const lines = readFileSync(newPath, "utf-8").trim().split("\n").map(l => JSON.parse(l));
+
+    // Header + 2 entries (e1, e2)
+    expect(lines).toHaveLength(3);
+    expect(lines[0].type).toBe("session");
+    expect(lines[0].parentSession).toBe(sessionFile);
+    expect(lines[1].id).toBe("e1");
+    expect(lines[1].parentId).toBeNull();
+    expect(lines[2].id).toBe("e2");
+    expect(lines[2].parentId).toBe("e1");
+  });
+
+  it("should throw for non-existent entry ID", () => {
+    const sessionFile = writeSession([
+      { type: "session", id: "sess-1", timestamp: "2025-01-01T00:00:00Z", cwd: "/tmp" },
+      { type: "message", id: "e1", parentId: null, message: { role: "user", content: "Hello" } },
+    ]);
+
+    expect(() => createBranchedSessionFile(sessionFile, "nonexistent")).toThrow("Entry ID not found");
+  });
+
+  it("should throw for non-existent session file", () => {
+    expect(() => createBranchedSessionFile("/no/such/file.jsonl", "e1")).toThrow("Session file not found");
+  });
+
+  it("should handle single-entry branch (root entry)", () => {
+    const sessionFile = writeSession([
+      { type: "session", id: "sess-1", timestamp: "2025-01-01T00:00:00Z", cwd: "/tmp" },
+      { type: "message", id: "e1", parentId: null, message: { role: "user", content: "Hello" } },
+    ]);
+
+    const newPath = createBranchedSessionFile(sessionFile, "e1");
+    const lines = readFileSync(newPath, "utf-8").trim().split("\n").map(l => JSON.parse(l));
+
+    expect(lines).toHaveLength(2); // header + 1 entry
+    expect(lines[1].id).toBe("e1");
+    expect(lines[1].parentId).toBeNull();
+  });
+
+  it("should generate a new session ID for the branched file", () => {
+    const sessionFile = writeSession([
+      { type: "session", id: "original-id", timestamp: "2025-01-01T00:00:00Z", cwd: "/tmp" },
+      { type: "message", id: "e1", parentId: null, message: { role: "user", content: "Hello" } },
+    ]);
+
+    const newPath = createBranchedSessionFile(sessionFile, "e1");
+    const header = JSON.parse(readFileSync(newPath, "utf-8").split("\n")[0]);
+
+    expect(header.id).not.toBe("original-id");
+    expect(header.id).toMatch(/^[0-9a-f-]+$/); // UUID format
+  });
+});

package/packages/server/src/__tests__/session-lifecycle-logging.test.ts

@@ -0,0 +1,138 @@
+/**
+ * Tests for session lifecycle logging in pi-gateway.
+ */
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { createPiGateway } from "../pi-gateway.js";
+import { createMemorySessionManager } from "../memory-session-manager.js";
+import { WebSocket } from "ws";
+
+const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+function waitForOpen(ws: WebSocket): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (ws.readyState === WebSocket.OPEN) return resolve();
+    ws.on("open", resolve);
+    ws.on("error", reject);
+    setTimeout(() => reject(new Error("open timeout")), 3000);
+  });
+}
+
+const SHORT_HB = 300;
+let portCounter = 19600;
+
+describe("Session lifecycle logging", () => {
+  let gateway: ReturnType<typeof createPiGateway>;
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+
+  afterEach(() => {
+    gateway?.stop();
+    errorSpy?.mockRestore();
+  });
+
+  it("should log on session_register", async () => {
+    errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const sessionManager = createMemorySessionManager();
+    gateway = createPiGateway(sessionManager, { heartbeatTimeout: 5000 });
+    const port = portCounter++;
+    gateway.start(port);
+
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    await waitForOpen(ws);
+    ws.send(JSON.stringify({
+      type: "session_register", sessionId: "log-reg", cwd: "/tmp/test", source: "tui",
+    }));
+    await delay(100);
+
+    const logs = errorSpy.mock.calls.map((c) => c[0]);
+    expect(logs).toContainEqual(expect.stringContaining("[gateway] session registered: log-reg cwd=/tmp/test"));
+    ws.close();
+  }, 10000);
+
+  it("should log on explicit session_unregister", async () => {
+    errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const sessionManager = createMemorySessionManager();
+    gateway = createPiGateway(sessionManager, { heartbeatTimeout: 5000 });
+    const port = portCounter++;
+    gateway.start(port);
+
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    await waitForOpen(ws);
+    ws.send(JSON.stringify({
+      type: "session_register", sessionId: "log-unreg", cwd: "/tmp", source: "tui",
+    }));
+    await delay(100);
+    ws.send(JSON.stringify({ type: "session_unregister", sessionId: "log-unreg" }));
+    await delay(100);
+
+    const logs = errorSpy.mock.calls.map((c) => c[0]);
+    expect(logs).toContainEqual(expect.stringContaining("[gateway] session unregistered: log-unreg (explicit)"));
+    ws.close();
+  }, 10000);
+
+  it("should log on heartbeat timeout", async () => {
+    errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const sessionManager = createMemorySessionManager();
+    gateway = createPiGateway(sessionManager, { heartbeatTimeout: SHORT_HB, pingInterval: 60000 });
+    const port = portCounter++;
+    gateway.start(port);
+
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    await waitForOpen(ws);
+    ws.send(JSON.stringify({
+      type: "session_register", sessionId: "log-timeout", cwd: "/tmp", source: "tui",
+    }));
+    await delay(100);
+
+    // Close without unregister — triggers heartbeat timeout
+    ws.close();
+    await delay(SHORT_HB + 300);
+
+    const logs = errorSpy.mock.calls.map((c) => c[0]);
+    expect(logs).toContainEqual(expect.stringContaining("[gateway] session timed out: log-timeout (no heartbeat for"));
+  }, 10000);
+
+  it("should log on connection close", async () => {
+    errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const sessionManager = createMemorySessionManager();
+    gateway = createPiGateway(sessionManager, { heartbeatTimeout: 5000 });
+    const port = portCounter++;
+    gateway.start(port);
+
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    await waitForOpen(ws);
+    ws.send(JSON.stringify({
+      type: "session_register", sessionId: "log-close", cwd: "/tmp", source: "tui",
+    }));
+    await delay(100);
+    ws.close();
+    await delay(200);
+
+    const logs = errorSpy.mock.calls.map((c) => c[0]);
+    expect(logs).toContainEqual(expect.stringContaining("[gateway] connection closed: log-close"));
+  }, 10000);
+
+  it("should log on ping timeout", async () => {
+    errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const sessionManager = createMemorySessionManager();
+    gateway = createPiGateway(sessionManager, {
+      heartbeatTimeout: 60000,
+      pingInterval: 200,
+    });
+    const port = portCounter++;
+    gateway.start(port);
+
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    await waitForOpen(ws);
+    ws.send(JSON.stringify({
+      type: "session_register", sessionId: "log-ping", cwd: "/tmp", source: "tui",
+    }));
+    await delay(100);
+
+    // Pause socket to prevent pong — need 2 missed pings before kill
+    (ws as any)._socket?.pause();
+    await delay(200 * 4);
+
+    const logs = errorSpy.mock.calls.map((c) => c[0]);
+    expect(logs).toContainEqual(expect.stringContaining("[gateway] connection dead (ping timeout, 2 misses): log-ping"));
+  }, 10000);
+});

package/packages/server/src/__tests__/session-order-manager.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createSessionOrderManager } from "../session-order-manager.js";
+import type { PreferencesStore } from "../preferences-store.js";
+
+function createMockPreferencesStore(initialOrder: Record<string, string[]> = {}): PreferencesStore {
+  let order = { ...initialOrder };
+  return {
+    getSessionOrder: vi.fn(() => order),
+    setSessionOrder: vi.fn((o: Record<string, string[]>) => { order = o; }),
+    getPinnedDirectories: vi.fn(() => []),
+    setPinnedDirectories: vi.fn(),
+    pinDirectory: vi.fn(),
+    unpinDirectory: vi.fn(),
+    reorderPinnedDirs: vi.fn(),
+    flush: vi.fn(),
+    dispose: vi.fn(),
+  };
+}
+
+describe("SessionOrderManager", () => {
+  let stateStore: PreferencesStore;
+
+  beforeEach(() => {
+    stateStore = createMockPreferencesStore();
+  });
+
+  describe("insert", () => {
+    it("prepends session to empty order", () => {
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.insert("/project", "s1");
+      expect(mgr.getOrder("/project")).toEqual(["s1"]);
+    });
+
+    it("prepends session to existing order", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s2"] });
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.insert("/project", "s3");
+      expect(mgr.getOrder("/project")).toEqual(["s3", "s1", "s2"]);
+    });
+
+    it("inserts after parent when afterSessionId provided", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s3"] });
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.insert("/project", "s2", "s1");
+      expect(mgr.getOrder("/project")).toEqual(["s1", "s2", "s3"]);
+    });
+
+    it("prepends when afterSessionId not found in order", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s2"] });
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.insert("/project", "s3", "nonexistent");
+      expect(mgr.getOrder("/project")).toEqual(["s3", "s1", "s2"]);
+    });
+
+    it("does not duplicate if session already in order", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s2"] });
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.insert("/project", "s1");
+      expect(mgr.getOrder("/project")).toEqual(["s1", "s2"]);
+    });
+
+    it("persists after insert", () => {
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.insert("/project", "s1");
+      expect(stateStore.setSessionOrder).toHaveBeenCalled();
+    });
+  });
+
+  describe("reorder", () => {
+    it("replaces order for a cwd", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s2", "s3"] });
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.reorder("/project", ["s3", "s1", "s2"]);
+      expect(mgr.getOrder("/project")).toEqual(["s3", "s1", "s2"]);
+    });
+
+    it("persists after reorder", () => {
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.reorder("/project", ["s1", "s2"]);
+      expect(stateStore.setSessionOrder).toHaveBeenCalled();
+    });
+  });
+
+  describe("remove", () => {
+    it("removes session from order", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s2", "s3"] });
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.remove("/project", "s2");
+      expect(mgr.getOrder("/project")).toEqual(["s1", "s3"]);
+    });
+
+    it("no-op when session not in order", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s2"] });
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.remove("/project", "s99");
+      expect(mgr.getOrder("/project")).toEqual(["s1", "s2"]);
+    });
+
+    it("removes empty cwd entry", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1"] });
+      const mgr = createSessionOrderManager(stateStore);
+      mgr.remove("/project", "s1");
+      expect(mgr.getOrder("/project")).toEqual([]);
+    });
+  });
+
+  describe("getOrder with validIds filtering", () => {
+    it("filters out stale IDs", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s2", "s3"] });
+      const mgr = createSessionOrderManager(stateStore);
+      const validIds = new Set(["s1", "s3"]);
+      expect(mgr.getOrder("/project", validIds)).toEqual(["s1", "s3"]);
+    });
+
+    it("returns empty for unknown cwd", () => {
+      const mgr = createSessionOrderManager(stateStore);
+      expect(mgr.getOrder("/unknown")).toEqual([]);
+    });
+
+    it("returns all if no validIds filter", () => {
+      stateStore = createMockPreferencesStore({ "/project": ["s1", "s2"] });
+      const mgr = createSessionOrderManager(stateStore);
+      expect(mgr.getOrder("/project")).toEqual(["s1", "s2"]);
+    });
+  });
+
+  describe("getAllOrders", () => {
+    it("returns all cwd orders", () => {
+      stateStore = createMockPreferencesStore({ "/a": ["s1"], "/b": ["s2", "s3"] });
+      const mgr = createSessionOrderManager(stateStore);
+      const orders = mgr.getAllOrders();
+      expect(orders).toEqual({ "/a": ["s1"], "/b": ["s2", "s3"] });
+    });
+  });
+});