@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/extension/src/__tests__/process-scanner.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect, vi } from "vitest";
+import { parseEtime, scanChildProcesses, captureChildPgids, scanTrackedProcesses, killProcessByPgid, scanWindowsProcesses, type SpawnSyncFn } from "../process-scanner.js";
+import type { SpawnSyncReturns } from "node:child_process";
+
+function mockResult(stdout: string, status = 0): SpawnSyncReturns<string> {
+  return { status, stdout, stderr: "", pid: 0, output: [], signal: null };
+}
+
+function fail(): SpawnSyncReturns<string> {
+  return mockResult("", 1);
+}
+
+/** Helper: ps -eo pid=,ppid= output for a set of pid→ppid pairs */
+function psChildOutput(pairs: [number, number][]): string {
+  return pairs.map(([pid, ppid]) => `  ${pid}  ${ppid}`).join("\n") + "\n";
+}
+
+describe("parseEtime", () => {
+  it("parses mm:ss format", () => expect(parseEtime("02:15")).toBe(135000));
+  it("parses hh:mm:ss format", () => expect(parseEtime("01:30:00")).toBe(5400000));
+  it("parses dd-hh:mm:ss format", () => expect(parseEtime("2-03:00:00")).toBe(183600000));
+  it("parses 00:05 as 5 seconds", () => expect(parseEtime("00:05")).toBe(5000));
+  it("parses 1-00:00:00 as 1 day", () => expect(parseEtime("1-00:00:00")).toBe(86400000));
+  it("returns 0 for empty string", () => expect(parseEtime("")).toBe(0));
+  it("returns 0 for invalid format", () => expect(parseEtime("garbage")).toBe(0));
+});
+
+describe("captureChildPgids", () => {
+  it("captures PGIDs of leaf children", () => {
+    const mock: SpawnSyncFn = (cmd, args) => {
+      // getChildPids for parent 100: finds child 200
+      if (cmd === "ps" && args[0] === "-eo" && args[1] === "pid=,ppid=") {
+        return mockResult(psChildOutput([[200, 100], [300, 999]]));
+      }
+      // getChildPids for child 200: no grandchildren (same ps call, no match)
+      // ps -p 200 -o pgid=
+      if (cmd === "ps" && args[0] === "-p" && args[1] === "200") {
+        return mockResult("  200\n");
+      }
+      return fail();
+    };
+    const tracked = new Set<number>();
+    captureChildPgids(100, tracked, { _spawnSync: mock });
+    expect(tracked.has(200)).toBe(true);
+  });
+
+  it("does nothing on Windows", () => {
+    const origPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+    Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+    try {
+      const tracked = new Set<number>();
+      captureChildPgids(100, tracked);
+      expect(tracked.size).toBe(0);
+    } finally {
+      if (origPlatform) Object.defineProperty(process, "platform", origPlatform);
+    }
+  });
+});
+
+describe("scanTrackedProcesses", () => {
+  it("returns alive processes matching tracked PGIDs", () => {
+    const mock: SpawnSyncFn = (cmd) => {
+      if (cmd === "ps") {
+        return mockResult(
+          "  300  200 02:00 node vitest\n  200  200 02:00 /bin/bash -c npm test\n  400  400 01:00 node vite\n"
+        );
+      }
+      return fail();
+    };
+    const tracked = new Set([200]);
+    const result = scanTrackedProcesses(tracked, 0, { _spawnSync: mock });
+    expect(result.some((p) => p.command === "node vitest")).toBe(true);
+    expect(result.some((p) => p.command.includes("bash"))).toBe(false);
+    expect(result.some((p) => p.pgid === 400)).toBe(false);
+  });
+
+  it("removes dead PGIDs from tracked set", () => {
+    const mock: SpawnSyncFn = (cmd) => {
+      if (cmd === "ps") return mockResult("  500  500 01:00 node other\n");
+      return fail();
+    };
+    const tracked = new Set([300]);
+    scanTrackedProcesses(tracked, 0, { _spawnSync: mock });
+    expect(tracked.has(300)).toBe(false);
+  });
+
+  it("filters by minElapsedMs", () => {
+    const mock: SpawnSyncFn = (cmd) => {
+      if (cmd === "ps") return mockResult("  300  200 00:05 node vitest\n");
+      return fail();
+    };
+    const tracked = new Set([200]);
+    const result = scanTrackedProcesses(tracked, 30000, { _spawnSync: mock });
+    expect(result).toHaveLength(0);
+  });
+
+  it("returns empty on Windows", () => {
+    const origPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+    Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+    try {
+      const tracked = new Set([200]);
+      expect(scanTrackedProcesses(tracked, 0)).toEqual([]);
+    } finally {
+      if (origPlatform) Object.defineProperty(process, "platform", origPlatform);
+    }
+  });
+});
+
+describe("scanChildProcesses (combined)", () => {
+  it("captures and returns processes in one call", () => {
+    let callCount = 0;
+    const mock: SpawnSyncFn = (cmd, args) => {
+      // Phase 1 (capture): getChildPids finds child 200 of parent 100
+      if (cmd === "ps" && args[0] === "-eo" && args[1] === "pid=,ppid=") {
+        callCount++;
+        // First call: find children of 100 → 200
+        // Second call: find children of 200 → none (leaf)
+        if (callCount === 1) return mockResult(psChildOutput([[200, 100], [999, 888]]));
+        if (callCount === 2) return mockResult(psChildOutput([[999, 888]])); // no children of 200
+        // Phase 2: full process list
+        return mockResult("  200  200 02:00 node vitest\n  999  888 01:00 unrelated\n");
+      }
+      // Phase 1: get PGID for captured PID 200
+      if (cmd === "ps" && args[0] === "-p" && args[1] === "200" && args[2] === "-o" && args[3] === "pgid=") {
+        return mockResult("  200\n");
+      }
+      // Phase 2: full scan
+      if (cmd === "ps" && args[0] === "-eo" && args[1] === "pid=,pgid=,etime=,args=") {
+        return mockResult("  200  200 02:00 node vitest\n  999  888 01:00 unrelated\n");
+      }
+      return fail();
+    };
+
+    const tracked = new Set<number>();
+    const result = scanChildProcesses(100, tracked, 0, { _spawnSync: mock });
+    expect(tracked.has(200)).toBe(true);
+    expect(result.some(p => p.command === "node vitest")).toBe(true);
+    expect(result.some(p => p.pgid === 888)).toBe(false); // unrelated PGID not tracked
+  });
+
+  it("returns empty on Windows", () => {
+    const origPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+    Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+    try {
+      const tracked = new Set<number>();
+      expect(scanChildProcesses(100, tracked, 0)).toEqual([]);
+    } finally {
+      if (origPlatform) Object.defineProperty(process, "platform", origPlatform);
+    }
+  });
+});
+
+describe("killProcessByPgid", () => {
+  it("returns false for non-existent process group", () => {
+    expect(killProcessByPgid(99999)).toBe(false);
+  });
+
+  it("uses taskkill on Windows", () => {
+    const mockSpawn = vi.fn().mockReturnValue({ status: 0, stdout: "" });
+    expect(killProcessByPgid(1234, { _spawnSync: mockSpawn, _platform: "win32" } as any)).toBe(true);
+    expect(mockSpawn).toHaveBeenCalledWith(
+      "taskkill",
+      ["/PID", "1234", "/T", "/F"],
+      expect.any(Object),
+    );
+  });
+});
+
+describe("Windows process scanning", () => {
+  it("scanChildProcesses delegates to scanWindowsProcesses on win32", () => {
+    const wmicOutput = [
+      "CommandLine=node server.js",
+      "CreationDate=20260410220000.000000+000",
+      "ParentProcessId=100",
+      "ProcessId=200",
+      "",
+    ].join("\n");
+    const mockSpawn = vi.fn().mockReturnValue({ status: 0, stdout: wmicOutput });
+    const tracked = new Set<number>();
+    const result = scanChildProcesses(100, tracked, 0, { _spawnSync: mockSpawn, _platform: "win32" } as any);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result[0].pid).toBe(200);
+  });
+
+  it("falls back to PowerShell when wmic fails", () => {
+    const psOutput = JSON.stringify([{ ProcessId: 300, CommandLine: "npm test", CreationDate: new Date(Date.now() - 60000).toISOString() }]);
+    const mockSpawn = vi.fn()
+      .mockReturnValueOnce({ status: 1, stdout: "" }) // wmic fails
+      .mockReturnValueOnce({ status: 0, stdout: psOutput }); // powershell succeeds
+    const tracked = new Set<number>();
+    const result = scanChildProcesses(100, tracked, 0, { _spawnSync: mockSpawn, _platform: "win32" } as any);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result[0].pid).toBe(300);
+  });
+
+  it("returns empty when both wmic and PowerShell fail", () => {
+    const mockSpawn = vi.fn().mockReturnValue({ status: 1, stdout: "" });
+    const tracked = new Set<number>();
+    const result = scanChildProcesses(100, tracked, 0, { _spawnSync: mockSpawn, _platform: "win32" } as any);
+    expect(result).toEqual([]);
+  });
+});

package/packages/extension/src/__tests__/prompt-expander.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { expandPromptTemplateFromDisk } from "../prompt-expander.js";
+
+const tmpDir = join(import.meta.dirname ?? __dirname, "__tmp_prompt_test__");
+const promptsDir = join(tmpDir, ".pi", "prompts");
+
+beforeEach(() => {
+  mkdirSync(promptsDir, { recursive: true });
+  writeFileSync(join(promptsDir, "opsx-continue.md"), "---\ndescription: continue\n---\nContinue the change");
+  writeFileSync(join(promptsDir, "opsx-apply.md"), "Apply the change");
+  writeFileSync(join(promptsDir, "hello.md"), "Hello world");
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("expandPromptTemplateFromDisk", () => {
+  it("expands hyphen form /opsx-continue", () => {
+    const result = expandPromptTemplateFromDisk("/opsx-continue my-change", tmpDir);
+    expect(result).toContain("Continue the change");
+    expect(result).toContain("my-change");
+  });
+
+  it("expands colon form /opsx:continue as alias for /opsx-continue", () => {
+    const result = expandPromptTemplateFromDisk("/opsx:continue my-change", tmpDir);
+    expect(result).toContain("Continue the change");
+    expect(result).toContain("my-change");
+  });
+
+  it("expands colon form /opsx:apply without args", () => {
+    const result = expandPromptTemplateFromDisk("/opsx:apply", tmpDir);
+    expect(result).toBe("Apply the change");
+  });
+
+  it("does not affect non-opsx colon commands", () => {
+    // /hello has no colon, should work as before
+    const result = expandPromptTemplateFromDisk("/hello", tmpDir);
+    expect(result).toBe("Hello world");
+  });
+
+  it("returns original text when no template found", () => {
+    const result = expandPromptTemplateFromDisk("/nonexistent", tmpDir);
+    expect(result).toBe("/nonexistent");
+  });
+
+  it("strips YAML frontmatter from colon form too", () => {
+    const result = expandPromptTemplateFromDisk("/opsx:continue", tmpDir);
+    expect(result).toBe("Continue the change");
+    expect(result).not.toContain("---");
+  });
+});

package/packages/extension/src/__tests__/server-auto-start.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, vi } from "vitest";
+import { autoStartServer, type AutoStartDeps, type DiscoveredServer } from "../server-auto-start.js";
+
+function makeDeps(overrides: Partial<AutoStartDeps> = {}): AutoStartDeps {
+  return {
+    discoverDashboard: vi.fn().mockResolvedValue([]),
+    isDashboardRunning: vi.fn().mockResolvedValue({ running: false }),
+    launchServer: vi.fn().mockResolvedValue({ success: true, message: "Server started" }),
+    notify: vi.fn(),
+    ...overrides,
+  };
+}
+
+const baseConfig = { piPort: 9999, port: 8000, autoStart: true };
+
+describe("autoStartServer", () => {
+  it("returns server from mDNS when local server is discovered", async () => {
+    const localServer: DiscoveredServer = {
+      host: "myhost.local", port: 8000, piPort: 9999,
+      isLocal: true, source: "mdns",
+    };
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockResolvedValue([localServer]),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(result.server).toEqual({ host: "myhost.local", port: 8000, piPort: 9999 });
+    expect(deps.isDashboardRunning).not.toHaveBeenCalled();
+    expect(deps.launchServer).not.toHaveBeenCalled();
+  });
+
+  it("falls back to health check when mDNS finds no local server", async () => {
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockResolvedValue([]),
+      isDashboardRunning: vi.fn().mockResolvedValue({ running: true }),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(result.server).toEqual({ host: "localhost", port: 8000, piPort: 9999 });
+    expect(deps.launchServer).not.toHaveBeenCalled();
+  });
+
+  it("falls back to health check when mDNS throws", async () => {
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockRejectedValue(new Error("mDNS failed")),
+      isDashboardRunning: vi.fn().mockResolvedValue({ running: true }),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(result.server).toEqual({ host: "localhost", port: 8000, piPort: 9999 });
+  });
+
+  it("auto-starts server and returns config defaults when mDNS fails after launch", async () => {
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockResolvedValue([]),
+      isDashboardRunning: vi.fn().mockResolvedValue({ running: false }),
+      launchServer: vi.fn().mockResolvedValue({ success: true, message: "ok" }),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(deps.launchServer).toHaveBeenCalled();
+    expect(deps.notify).toHaveBeenCalledWith(
+      "🌐 Dashboard started at http://localhost:8000",
+      "info",
+    );
+    expect(result.server).toEqual({ host: "localhost", port: 8000, piPort: 9999 });
+  });
+
+  it("uses mDNS-discovered piPort after auto-start", async () => {
+    const localServer: DiscoveredServer = {
+      host: "myhost.local", port: 8000, piPort: 9998,
+      isLocal: true, source: "mdns",
+    };
+    const deps = makeDeps({
+      discoverDashboard: vi.fn()
+        .mockResolvedValueOnce([])      // First call: nothing found
+        .mockResolvedValueOnce([localServer]), // After launch: found
+      isDashboardRunning: vi.fn().mockResolvedValue({ running: false }),
+      launchServer: vi.fn().mockResolvedValue({ success: true, message: "ok" }),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(result.server).toEqual({ host: "myhost.local", port: 8000, piPort: 9998 });
+  });
+
+  it("suppresses warning when launch fails but health check succeeds on recheck", async () => {
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockResolvedValue([]),
+      isDashboardRunning: vi.fn()
+        .mockResolvedValueOnce({ running: false })  // initial check
+        .mockResolvedValueOnce({ running: true }),   // recheck after failure
+      launchServer: vi.fn().mockResolvedValue({ success: false, message: "exited" }),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(deps.notify).not.toHaveBeenCalled();
+    expect(result.server).toEqual({ host: "localhost", port: 8000, piPort: 9999 });
+  });
+
+  it("shows warning when launch fails and recheck also fails", async () => {
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockResolvedValue([]),
+      isDashboardRunning: vi.fn().mockResolvedValue({ running: false }),
+      launchServer: vi.fn().mockResolvedValue({ success: false, message: "exited" }),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(deps.notify).toHaveBeenCalledWith(
+      "Dashboard server failed to start: exited",
+      "warning",
+    );
+    expect(result.server).toBeUndefined();
+  });
+
+  it("does nothing when autoStart is disabled and no server found", async () => {
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockResolvedValue([]),
+      isDashboardRunning: vi.fn().mockResolvedValue({ running: false }),
+    });
+
+    const result = await autoStartServer({ ...baseConfig, autoStart: false }, deps);
+
+    expect(deps.launchServer).not.toHaveBeenCalled();
+    expect(result.server).toBeUndefined();
+  });
+
+  it("shows port conflict warning when port is occupied by another service", async () => {
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockResolvedValue([]),
+      isDashboardRunning: vi.fn().mockResolvedValue({ running: false, portConflict: true }),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(deps.launchServer).not.toHaveBeenCalled();
+    expect(deps.notify).toHaveBeenCalledWith(
+      "Port 8000 is occupied by another service",
+      "warning",
+    );
+    expect(result.server).toBeUndefined();
+  });
+
+  it("prefers local server over remote when both discovered via mDNS", async () => {
+    const remote: DiscoveredServer = {
+      host: "remote.local", port: 8000, piPort: 9999,
+      isLocal: false, source: "mdns",
+    };
+    const local: DiscoveredServer = {
+      host: "myhost.local", port: 8000, piPort: 9999,
+      isLocal: true, source: "mdns",
+    };
+    const deps = makeDeps({
+      discoverDashboard: vi.fn().mockResolvedValue([remote, local]),
+    });
+
+    const result = await autoStartServer(baseConfig, deps);
+
+    expect(result.server).toEqual({ host: "myhost.local", port: 8000, piPort: 9999 });
+  });
+});

package/packages/extension/src/__tests__/server-launcher.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi } from "vitest";
+import { resolveServerCliPath } from "../server-launcher.js";
+import path from "node:path";
+
+describe("server-launcher", () => {
+  it("should resolve server CLI path relative to extension", () => {
+    const cliPath = resolveServerCliPath();
+    // From src/extension/server-launcher.ts → ../../server/cli.ts
+    expect(cliPath).toContain("server");
+    expect(cliPath).toContain("cli.ts");
+    expect(path.isAbsolute(cliPath)).toBe(true);
+  });
+
+  it("should build correct spawn args from config", async () => {
+    // We test the arg building logic, not the actual spawn
+    const { buildSpawnArgs } = await import("../server-launcher.js");
+    const args = buildSpawnArgs({
+      port: 3000,
+      piPort: 4000,
+      autoStart: true,
+      autoShutdown: true,
+      shutdownIdleSeconds: 300,
+      spawnStrategy: "tmux",
+      tunnel: { enabled: true },
+      devBuildOnReload: false,
+      memoryLimits: { maxEventsPerSession: 5000, maxStringFieldSize: 0, maxWsBufferBytes: 4194304 },
+      editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+    });
+
+    expect(args).toContain("--port");
+    expect(args).toContain("3000");
+    expect(args).toContain("--pi-port");
+    expect(args).toContain("4000");
+  });
+
+  it("should use resolveJitiImport in launchServer spawn args", async () => {
+    // Verify server-launcher imports resolveJitiImport (compile-time check).
+    // At runtime inside pi, resolveJitiImport returns the jiti path.
+    // In test context (no pi), it throws — which confirms the tsx fallback is gone.
+    const mod = await import("../server-launcher.js");
+    expect(mod.resolveServerCliPath).toBeDefined();
+    expect(mod.buildSpawnArgs).toBeDefined();
+  });
+});

package/packages/extension/src/__tests__/server-probe.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { isPortOpen } from "../server-probe.js";
+import net from "node:net";
+
+describe("isPortOpen", () => {
+  it("should return true when a server is listening", async () => {
+    // Start a temporary server
+    const server = net.createServer();
+    await new Promise<void>((resolve) => server.listen(0, resolve));
+    const port = (server.address() as net.AddressInfo).port;
+
+    try {
+      const result = await isPortOpen(port);
+      expect(result).toBe(true);
+    } finally {
+      server.close();
+    }
+  });
+
+  it("should return false when no server is listening", async () => {
+    // Use a port that's almost certainly not in use
+    const result = await isPortOpen(59321);
+    expect(result).toBe(false);
+  });
+});

package/packages/extension/src/__tests__/session-switch.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Tests for session switch/fork behavior in the bridge extension.
+ * These test the helper functions and logic used during session changes.
+ */
+import { describe, it, expect } from "vitest";
+
+// We test the extractFirstMessage logic inline since it's a local function in bridge.ts.
+// Replicate the logic here to verify behavior.
+
+function extractFirstMessage(ctx: any): string | undefined {
+  try {
+    const entries = ctx.sessionManager?.getEntries?.();
+    if (!entries || !Array.isArray(entries)) return undefined;
+    for (const entry of entries) {
+      if (entry.role === "user" && typeof entry.content === "string") {
+        return entry.content.slice(0, 200);
+      }
+      if (entry.role === "user" && Array.isArray(entry.content)) {
+        for (const part of entry.content) {
+          if (part.type === "text" && typeof part.text === "string") {
+            return part.text.slice(0, 200);
+          }
+        }
+      }
+    }
+  } catch { /* ignore */ }
+  return undefined;
+}
+
+describe("extractFirstMessage", () => {
+  it("should extract first user message as string content", () => {
+    const ctx = {
+      sessionManager: {
+        getEntries: () => [
+          { role: "system", content: "You are a helpful assistant" },
+          { role: "user", content: "Help me fix the auth module" },
+          { role: "assistant", content: "Sure, I'll help" },
+        ],
+      },
+    };
+    expect(extractFirstMessage(ctx)).toBe("Help me fix the auth module");
+  });
+
+  it("should extract first user message from array content", () => {
+    const ctx = {
+      sessionManager: {
+        getEntries: () => [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: "Look at this image and fix the bug" },
+              { type: "image", data: "base64..." },
+            ],
+          },
+        ],
+      },
+    };
+    expect(extractFirstMessage(ctx)).toBe("Look at this image and fix the bug");
+  });
+
+  it("should truncate long messages to 200 chars", () => {
+    const longMessage = "a".repeat(300);
+    const ctx = {
+      sessionManager: {
+        getEntries: () => [{ role: "user", content: longMessage }],
+      },
+    };
+    expect(extractFirstMessage(ctx)).toBe("a".repeat(200));
+  });
+
+  it("should return undefined when no entries exist", () => {
+    const ctx = {
+      sessionManager: {
+        getEntries: () => [],
+      },
+    };
+    expect(extractFirstMessage(ctx)).toBeUndefined();
+  });
+
+  it("should return undefined when getEntries is not available", () => {
+    const ctx = { sessionManager: {} };
+    expect(extractFirstMessage(ctx)).toBeUndefined();
+  });
+
+  it("should return undefined when sessionManager is not available", () => {
+    expect(extractFirstMessage({})).toBeUndefined();
+  });
+
+  it("should handle errors gracefully", () => {
+    const ctx = {
+      sessionManager: {
+        getEntries: () => { throw new Error("fail"); },
+      },
+    };
+    expect(extractFirstMessage(ctx)).toBeUndefined();
+  });
+});
+
+describe("session switch flow", () => {
+  it("should produce unregister for old ID and register for new ID", () => {
+    // This tests the expected message sequence during a session switch.
+    // The actual bridge sends these messages; here we verify the logic.
+    const messages: any[] = [];
+    const send = (msg: any) => messages.push(msg);
+
+    const oldSessionId = "old-uuid";
+    let sessionId = oldSessionId;
+
+    // Simulate handleSessionChange
+    send({ type: "session_unregister", sessionId });
+
+    sessionId = "new-uuid"; // ctx.sessionManager.getSessionId() returns new ID
+
+    send({
+      type: "session_register",
+      sessionId,
+      cwd: "/project",
+      source: "tui",
+    });
+
+    expect(messages).toHaveLength(2);
+    expect(messages[0]).toEqual({ type: "session_unregister", sessionId: "old-uuid" });
+    expect(messages[1]).toMatchObject({ type: "session_register", sessionId: "new-uuid" });
+  });
+
+  it("should handle fork identically to switch", () => {
+    // Fork produces same message pattern: unregister old, register new
+    const messages: any[] = [];
+    const send = (msg: any) => messages.push(msg);
+
+    let sessionId = "original-uuid";
+    send({ type: "session_unregister", sessionId });
+    sessionId = "forked-uuid";
+    send({ type: "session_register", sessionId, cwd: "/project", source: "tui" });
+
+    expect(messages[0].sessionId).toBe("original-uuid");
+    expect(messages[1].sessionId).toBe("forked-uuid");
+  });
+});

package/packages/extension/src/__tests__/session-sync.test.ts

@@ -0,0 +1,55 @@
+/**
+ * Tests for session-sync: sendStateSync and handleSessionSwitch.
+ */
+import { describe, it, expect, vi } from "vitest";
+import { sendStateSync } from "../session-sync.js";
+import type { BridgeContext } from "../bridge-context.js";
+
+function createMockBridgeContext(overrides?: Partial<BridgeContext>): BridgeContext {
+  const sent: any[] = [];
+  return {
+    pi: {
+      getSessionName: () => "test-session",
+      getCommands: () => [],
+    } as any,
+    connection: {
+      send: (msg: any) => sent.push(msg),
+    } as any,
+    sessionId: "sess-123",
+    cachedCtx: {
+      sessionManager: {
+        getSessionFile: () => "/path/to/session.json",
+        getSessionDir: () => "/path/to/session",
+        getBranch: () => [{ role: "user", content: "hello" }],
+        getEntries: () => [{ role: "user", content: "hello" }],
+      },
+    },
+    cachedModelRegistry: null,
+    cachedHasUI: true,
+    lastModel: undefined,
+    lastThinkingLevel: undefined,
+    lastSessionFile: undefined,
+    lastSessionDir: undefined,
+    lastFirstMessage: undefined,
+    lastGitBranch: undefined,
+    lastGitPrNumber: undefined,
+    lastSessionName: undefined,
+    ...overrides,
+    // Expose sent messages for assertions
+    _sent: sent,
+  } as any;
+}
+
+describe("sendStateSync", () => {
+  it("should include pid in session_register message", () => {
+    const bc = createMockBridgeContext();
+    sendStateSync(bc, () => []);
+
+    const sent = (bc as any)._sent;
+    const registerMsg = sent.find((m: any) => m.type === "session_register");
+    expect(registerMsg).toBeDefined();
+    expect(registerMsg.pid).toBe(process.pid);
+    expect(typeof registerMsg.pid).toBe("number");
+    expect(registerMsg.pid).toBeGreaterThan(0);
+  });
+});