@blackbelt-technology/pi-agent-dashboard 0.5.2 → 0.5.4

package/packages/server/src/__tests__/cli-parse.test.ts

@@ -31,16 +31,15 @@ describe("parseArgs", () => {
     expect(result.subcommand).toBe("status");
   });
 
-  it("parses upgrade-pi subcommand (unified-bootstrap-install §8)", () => {
-    const result = parseArgs(["upgrade-pi"]);
-    expect(result.subcommand).toBe("upgrade-pi");
-  });
-
-  it("parses upgrade-pi with --port flag", () => {
-    const result = parseArgs(["upgrade-pi", "--port", "9090"]);
-    expect(result.subcommand).toBe("upgrade-pi");
-    expect(result.flags.port).toBe(9090);
-  });
+  // NOTE: `upgrade-pi` subcommand tests removed.
+  // The `upgrade-pi` subcommand was deliberately removed in change
+  // `eliminate-electron-runtime-install` (tasks 3.0.a + 3.5b, 2026-05-23)
+  // when bootstrap-install was deleted. `SUBCOMMANDS` is now
+  // `["start", "stop", "restart", "status"]`. The pi-core upgrade path
+  // survives via the `POST /api/pi-core/update` REST endpoint instead.
+  // These two tests were documented as deferred to a "Phase 3.9 sweep"
+  // in eliminate-electron-runtime-install/tasks.md task 5.9; this is
+  // that sweep.
 
   it("parses subcommand with flags", () => {
     const result = parseArgs(["start", "--port", "3000", "--pi-port", "4000"]);

package/packages/server/src/__tests__/cli-version.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Tests for `packages/server/bin/pi-dashboard.mjs` --version short-circuit.
+ *
+ * Bug B (see openspec/changes/fix-electron-cold-launch-probe-cascade):
+ * The wrapper previously resolved jiti BEFORE parsing argv, exiting 1
+ * with "cannot find jiti" even for metadata queries like --version.
+ * That killed `probeNpmGlobal` in launch-source.ts, which calls
+ * `pi-dashboard --version` and rejects null/empty/non-zero responses.
+ *
+ * Contract enforced by these tests:
+ *   - `--version` / `-v` / `version` SHALL print sibling package.json's
+ *     `version` to stdout and exit 0, EVEN when jiti is missing.
+ *   - Any other subcommand (start, status, no args) SHALL preserve the
+ *     pre-fix behaviour: exit 1 with "cannot find jiti" install hint
+ *     when the wrapper can't resolve jiti.
+ *   - When sibling package.json is unreadable / malformed, the short
+ *     circuit MUST NOT silently succeed with an empty string — it
+ *     SHALL fall through to the existing jiti-resolve path.
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, readFileSync, existsSync, rmSync, cpSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import url from "node:url";
+
+const here = path.dirname(url.fileURLToPath(import.meta.url));
+const wrapperPath = path.resolve(here, "..", "..", "bin", "pi-dashboard.mjs");
+const sibPkgJson = path.resolve(here, "..", "..", "package.json");
+
+beforeAll(() => {
+  if (!existsSync(wrapperPath)) throw new Error(`Wrapper missing at ${wrapperPath}`);
+  if (!existsSync(sibPkgJson))   throw new Error(`Sibling package.json missing at ${sibPkgJson}`);
+});
+
+const expectedVersion = JSON.parse(readFileSync(sibPkgJson, "utf-8")).version as string;
+
+/**
+ * Copy the wrapper + a chosen package.json into an isolated tmp dir with
+ * NO node_modules adjacency. createRequire from there cannot resolve
+ * jiti, so the jiti-miss path is exercised.
+ */
+function makeIsolatedWrapper(pkgJsonContent: string | null): { wrapper: string; cleanup: () => void } {
+  const tmp = mkdtempSync(path.join(tmpdir(), "pi-dashboard-cli-version-"));
+  // Wrapper has to live at .../bin/pi-dashboard.mjs because it computes
+  // sibling package.json as `../package.json` relative to itself.
+  const binDir = path.join(tmp, "bin");
+  cpSync(path.dirname(wrapperPath), binDir, { recursive: true });
+  if (pkgJsonContent !== null) {
+    writeFileSync(path.join(tmp, "package.json"), pkgJsonContent);
+  }
+  const wrapper = path.join(binDir, "pi-dashboard.mjs");
+  return { wrapper, cleanup: () => rmSync(tmp, { recursive: true, force: true }) };
+}
+
+describe("bin/pi-dashboard.mjs --version short-circuit (Bug B)", () => {
+  it("(a) --version with no jiti reachable → exit 0, stdout = pkg.version", () => {
+    const fakePkg = JSON.stringify({ name: "pi-dashboard-test", version: "9.9.9-isolated" });
+    const { wrapper, cleanup } = makeIsolatedWrapper(fakePkg);
+    try {
+      const result = spawnSync(process.execPath, [wrapper, "--version"], {
+        encoding: "utf-8",
+        env: { ...process.env, NODE_PATH: "" },
+        timeout: 10_000,
+      });
+      expect(result.status).toBe(0);
+      expect(result.stdout.trim()).toBe("9.9.9-isolated");
+      expect(result.stderr).not.toContain("cannot find jiti");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("(a') -v shortform behaves identically", () => {
+    const fakePkg = JSON.stringify({ name: "pi-dashboard-test", version: "1.2.3-short" });
+    const { wrapper, cleanup } = makeIsolatedWrapper(fakePkg);
+    try {
+      const result = spawnSync(process.execPath, [wrapper, "-v"], {
+        encoding: "utf-8",
+        env: { ...process.env, NODE_PATH: "" },
+        timeout: 10_000,
+      });
+      expect(result.status).toBe(0);
+      expect(result.stdout.trim()).toBe("1.2.3-short");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("(b) start with no jiti reachable → exit 1, stderr contains install-hint", () => {
+    const fakePkg = JSON.stringify({ name: "pi-dashboard-test", version: "9.9.9-isolated" });
+    const { wrapper, cleanup } = makeIsolatedWrapper(fakePkg);
+    try {
+      const result = spawnSync(process.execPath, [wrapper, "start"], {
+        encoding: "utf-8",
+        env: { ...process.env, NODE_PATH: "" },
+        timeout: 10_000,
+      });
+      expect(result.status).toBe(1);
+      expect(result.stderr).toContain("pi-dashboard: cannot find jiti");
+      expect(result.stderr).toContain("npm install -g @earendil-works/pi-coding-agent");
+      expect(result.stdout.trim()).not.toBe("9.9.9-isolated");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("(c) --version on healthy install → exit 0 without re-execing cli.ts", () => {
+    const result = spawnSync(process.execPath, [wrapperPath, "--version"], {
+      encoding: "utf-8",
+      timeout: 15_000,
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe(expectedVersion);
+    // No cli.ts startup banner — proves no re-exec.
+    expect(result.stdout).not.toMatch(/Dashboard server/i);
+    expect(result.stderr).not.toContain("cannot find jiti");
+  }, 30_000);
+
+  it("(d) --version with corrupt sibling package.json → falls through to jiti path", () => {
+    const { wrapper, cleanup } = makeIsolatedWrapper("{ this is not valid json");
+    try {
+      const result = spawnSync(process.execPath, [wrapper, "--version"], {
+        encoding: "utf-8",
+        env: { ...process.env, NODE_PATH: "" },
+        timeout: 10_000,
+      });
+      // Fall-through: jiti unreachable in tmp dir → legacy install-hint fires.
+      // Critically: NOT a silent exit 0 with empty version.
+      expect(result.status).toBe(1);
+      expect(result.stderr).toContain("pi-dashboard: cannot find jiti");
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("(d') --version with missing sibling package.json → falls through", () => {
+    const { wrapper, cleanup } = makeIsolatedWrapper(null);
+    try {
+      const result = spawnSync(process.execPath, [wrapper, "--version"], {
+        encoding: "utf-8",
+        env: { ...process.env, NODE_PATH: "" },
+        timeout: 10_000,
+      });
+      expect(result.status).toBe(1);
+      expect(result.stderr).toContain("pi-dashboard: cannot find jiti");
+    } finally {
+      cleanup();
+    }
+  });
+});

package/packages/server/src/__tests__/directory-service-openspec-enabled.test.ts

@@ -62,6 +62,15 @@ function makePrefs(pinnedDirs: string[] = []): PreferencesStore {
     pinDirectory: vi.fn(),
     unpinDirectory: vi.fn(),
     reorderPinnedDirs: vi.fn(),
+    getWorkspaces: vi.fn(() => []),
+    createWorkspace: vi.fn(() => null),
+    renameWorkspace: vi.fn(() => false),
+    deleteWorkspace: vi.fn(() => false),
+    setWorkspaceCollapsed: vi.fn(() => false),
+    addFolderToWorkspace: vi.fn(() => false),
+    removeFolderFromWorkspace: vi.fn(() => false),
+    reorderWorkspaceFolders: vi.fn(() => false),
+    reorderWorkspaces: vi.fn(() => false),
     flush: vi.fn(),
     dispose: vi.fn(),
   };

package/packages/server/src/__tests__/directory-service-refresh-force.test.ts

@@ -55,6 +55,15 @@ function createMockPreferencesStore(): PreferencesStore {
     pinDirectory: vi.fn(),
     unpinDirectory: vi.fn(),
     reorderPinnedDirs: vi.fn(),
+    getWorkspaces: vi.fn(() => []),
+    createWorkspace: vi.fn(() => null),
+    renameWorkspace: vi.fn(() => false),
+    deleteWorkspace: vi.fn(() => false),
+    setWorkspaceCollapsed: vi.fn(() => false),
+    addFolderToWorkspace: vi.fn(() => false),
+    removeFolderFromWorkspace: vi.fn(() => false),
+    reorderWorkspaceFolders: vi.fn(() => false),
+    reorderWorkspaces: vi.fn(() => false),
     flush: vi.fn(),
     dispose: vi.fn(),
   };

package/packages/server/src/__tests__/directory-service-specs-mtime.test.ts

@@ -63,6 +63,15 @@ function createMockPreferencesStore(): PreferencesStore {
     pinDirectory: vi.fn(),
     unpinDirectory: vi.fn(),
     reorderPinnedDirs: vi.fn(),
+    getWorkspaces: vi.fn(() => []),
+    createWorkspace: vi.fn(() => null),
+    renameWorkspace: vi.fn(() => false),
+    deleteWorkspace: vi.fn(() => false),
+    setWorkspaceCollapsed: vi.fn(() => false),
+    addFolderToWorkspace: vi.fn(() => false),
+    removeFolderFromWorkspace: vi.fn(() => false),
+    reorderWorkspaceFolders: vi.fn(() => false),
+    reorderWorkspaces: vi.fn(() => false),
     flush: vi.fn(),
     dispose: vi.fn(),
   };

package/packages/server/src/__tests__/directory-service-toctou.test.ts

@@ -62,6 +62,15 @@ function createMockPreferencesStore(): PreferencesStore {
     pinDirectory: vi.fn(),
     unpinDirectory: vi.fn(),
     reorderPinnedDirs: vi.fn(),
+    getWorkspaces: vi.fn(() => []),
+    createWorkspace: vi.fn(() => null),
+    renameWorkspace: vi.fn(() => false),
+    deleteWorkspace: vi.fn(() => false),
+    setWorkspaceCollapsed: vi.fn(() => false),
+    addFolderToWorkspace: vi.fn(() => false),
+    removeFolderFromWorkspace: vi.fn(() => false),
+    reorderWorkspaceFolders: vi.fn(() => false),
+    reorderWorkspaces: vi.fn(() => false),
     flush: vi.fn(),
     dispose: vi.fn(),
   };

package/packages/server/src/__tests__/directory-service.test.ts

@@ -60,6 +60,15 @@ function createMockPreferencesStore(pinnedDirs: string[] = []): PreferencesStore
     pinDirectory: vi.fn(),
     unpinDirectory: vi.fn(),
     reorderPinnedDirs: vi.fn(),
+    getWorkspaces: vi.fn(() => []),
+    createWorkspace: vi.fn(() => null),
+    renameWorkspace: vi.fn(() => false),
+    deleteWorkspace: vi.fn(() => false),
+    setWorkspaceCollapsed: vi.fn(() => false),
+    addFolderToWorkspace: vi.fn(() => false),
+    removeFolderFromWorkspace: vi.fn(() => false),
+    reorderWorkspaceFolders: vi.fn(() => false),
+    reorderWorkspaces: vi.fn(() => false),
     flush: vi.fn(),
     dispose: vi.fn(),
   };

package/packages/server/src/__tests__/doctor-route.test.ts

@@ -115,6 +115,59 @@ describe("/api/doctor", () => {
     }
   });
 
+  it("probeServer reads process state, never spawns a subprocess", async () => {
+    // Set the env vars the new probeServer reads directly.
+    const prev = {
+      DASHBOARD_STARTER: process.env.DASHBOARD_STARTER,
+      NODE_ENV: process.env.NODE_ENV,
+      DASHBOARD_INSTALLABLE_TOTAL: process.env.DASHBOARD_INSTALLABLE_TOTAL,
+      DASHBOARD_INSTALLABLE_INSTALLED: process.env.DASHBOARD_INSTALLABLE_INSTALLED,
+    };
+    process.env.DASHBOARD_STARTER = "Electron";
+    process.env.NODE_ENV = "production";
+    process.env.DASHBOARD_INSTALLABLE_TOTAL = "3";
+    process.env.DASHBOARD_INSTALLABLE_INSTALLED = "3";
+
+    try {
+      // Inject a deps override that captures what probeServer returns
+      // by building default deps and calling probeServer directly.
+      const { buildDefaultDepsForTest } = await import("../routes/doctor-routes.js") as {
+        buildDefaultDepsForTest?: () => SharedChecksDeps;
+      };
+
+      // We don't export buildDefaultDeps directly, so instead assert via
+      // the route: if the self-curl deadlock were present it would time out;
+      // instead the route must complete quickly (< 500 ms).
+      app = await makeApp();
+      const start = Date.now();
+      const res = await app.inject({ method: "GET", url: "/api/doctor" });
+      const elapsed = Date.now() - start;
+
+      expect(res.statusCode).toBe(200);
+      // Must complete well under the old 3 s curl timeout. The full
+      // doctor run includes binary-detection checks that can take ~1 s
+      // on slow CI; we just assert no self-curl deadlock (< 3 s).
+      expect(elapsed).toBeLessThan(3000);
+
+      // The server check row should say "running" / "ok" since we are
+      // processing this request inside the running server.
+      const body = res.json() as DoctorReport;
+      const serverRow = body.checks.find((c) => c.name === "Dashboard server");
+      expect(serverRow).toBeDefined();
+      expect(serverRow?.status).toBe("ok");
+    } finally {
+      // Restore env
+      if (prev.DASHBOARD_STARTER === undefined) delete process.env.DASHBOARD_STARTER;
+      else process.env.DASHBOARD_STARTER = prev.DASHBOARD_STARTER;
+      if (prev.NODE_ENV === undefined) delete process.env.NODE_ENV;
+      else process.env.NODE_ENV = prev.NODE_ENV;
+      if (prev.DASHBOARD_INSTALLABLE_TOTAL === undefined) delete process.env.DASHBOARD_INSTALLABLE_TOTAL;
+      else process.env.DASHBOARD_INSTALLABLE_TOTAL = prev.DASHBOARD_INSTALLABLE_TOTAL;
+      if (prev.DASHBOARD_INSTALLABLE_INSTALLED === undefined) delete process.env.DASHBOARD_INSTALLABLE_INSTALLED;
+      else process.env.DASHBOARD_INSTALLABLE_INSTALLED = prev.DASHBOARD_INSTALLABLE_INSTALLED;
+    }
+  });
+
   it("returns 200 with a single fallback row when buildDeps throws", async () => {
     app = await makeApp(() => {
       throw new Error("boom — deps unavailable");

package/packages/server/src/__tests__/event-wiring-queue-state.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Tests for the `queue_update` extension-to-server message handling.
+ * Validates that the server caches Session.pendingQueues wholesale and
+ * broadcasts session_updated to subscribers.
+ * See change: add-followup-edit-and-steer-cancel.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { WebSocket } from "ws";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createServer, type DashboardServer } from "../server.js";
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("event-wiring: queue_update caches Session.pendingQueues and broadcasts", () => {
+  let server: DashboardServer;
+  let piPort: number;
+  let browserPort: number;
+  let testPort = 19800;
+
+  beforeEach(async () => {
+    testPort += 2;
+    browserPort = testPort;
+    piPort = testPort + 1;
+    server = await createServer({
+      port: browserPort,
+      piPort,
+      dev: true,
+      autoShutdown: false,
+      shutdownIdleSeconds: 999,
+      tunnel: false,
+      editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+    });
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server.stop();
+  });
+
+  it("wholesale replaces Session.pendingQueues on each queue_update event", async () => {
+    const { sessionManager } = server;
+    const SID = "queue-test-sess";
+    const tmpDir = mkdtempSync(path.join(os.tmpdir(), "pi-queue-test-"));
+    const sessionFile = path.join(tmpDir, "s.jsonl");
+    writeFileSync(sessionFile, "");
+
+    const bridgeWs = new WebSocket(`ws://localhost:${piPort}`);
+    await new Promise<void>((resolve, reject) => {
+      bridgeWs.on("error", reject);
+      bridgeWs.on("open", () => {
+        bridgeWs.send(JSON.stringify({
+          type: "session_register",
+          sessionId: SID,
+          cwd: tmpDir,
+          source: "cli",
+          sessionFile,
+        }));
+        bridgeWs.send(JSON.stringify({ type: "replay_complete", sessionId: SID }));
+        resolve();
+      });
+    });
+    await wait(80);
+
+    // Initial state: queues start empty after register.
+    expect(sessionManager.get(SID)?.pendingQueues).toEqual({ steering: [], followUp: [] });
+
+    // 1. Bridge emits queue_update with steering only
+    bridgeWs.send(JSON.stringify({
+      type: "queue_update",
+      sessionId: SID,
+      steering: ["first"],
+      followUp: [],
+    }));
+    await wait(60);
+    expect(sessionManager.get(SID)?.pendingQueues).toEqual({ steering: ["first"], followUp: [] });
+
+    // 2. Bridge emits queue_update with both queues populated — wholesale replace
+    bridgeWs.send(JSON.stringify({
+      type: "queue_update",
+      sessionId: SID,
+      steering: ["alpha", "beta"],
+      followUp: ["wrap up"],
+    }));
+    await wait(60);
+    expect(sessionManager.get(SID)?.pendingQueues).toEqual({
+      steering: ["alpha", "beta"],
+      followUp: ["wrap up"],
+    });
+
+    // 3. Bridge emits empty snapshot (drain finished or clear ran)
+    bridgeWs.send(JSON.stringify({
+      type: "queue_update",
+      sessionId: SID,
+      steering: [],
+      followUp: [],
+    }));
+    await wait(60);
+    expect(sessionManager.get(SID)?.pendingQueues).toEqual({ steering: [], followUp: [] });
+
+    bridgeWs.close();
+  });
+
+  it("resets Session.pendingQueues to empty on session re-register", async () => {
+    const { sessionManager } = server;
+    const SID = "queue-rereg-sess";
+    const tmpDir = mkdtempSync(path.join(os.tmpdir(), "pi-queue-rereg-"));
+    const sessionFile = path.join(tmpDir, "s.jsonl");
+    writeFileSync(sessionFile, "");
+
+    // First bridge connects and populates the queues.
+    const ws1 = new WebSocket(`ws://localhost:${piPort}`);
+    await new Promise<void>((resolve) => {
+      ws1.on("open", () => {
+        ws1.send(JSON.stringify({
+          type: "session_register",
+          sessionId: SID,
+          cwd: tmpDir,
+          source: "cli",
+          sessionFile,
+        }));
+        ws1.send(JSON.stringify({ type: "replay_complete", sessionId: SID }));
+        ws1.send(JSON.stringify({
+          type: "queue_update",
+          sessionId: SID,
+          steering: ["a", "b"],
+          followUp: ["c"],
+        }));
+        setTimeout(resolve, 100);
+      });
+    });
+    expect(sessionManager.get(SID)?.pendingQueues?.steering).toHaveLength(2);
+    expect(sessionManager.get(SID)?.pendingQueues?.followUp).toHaveLength(1);
+    ws1.close();
+    await wait(80);
+
+    // Second bridge re-registers same sessionId — pendingQueues MUST reset.
+    const ws2 = new WebSocket(`ws://localhost:${piPort}`);
+    await new Promise<void>((resolve) => {
+      ws2.on("open", () => {
+        ws2.send(JSON.stringify({
+          type: "session_register",
+          sessionId: SID,
+          cwd: tmpDir,
+          source: "cli",
+          sessionFile,
+        }));
+        ws2.send(JSON.stringify({ type: "replay_complete", sessionId: SID }));
+        setTimeout(resolve, 100);
+      });
+    });
+    expect(sessionManager.get(SID)?.pendingQueues).toEqual({ steering: [], followUp: [] });
+    ws2.close();
+  });
+});

package/packages/server/src/__tests__/event-wiring-resume-clear.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Regression test: when a new session registers for a cwd that has a
+ * pending auto-resume, `resuming: false` must be set on the OLD session
+ * (pendingResume.oldSessionId), not the newly-registered one.
+ *
+ * Root cause: the original code used `sessionId` (new session) instead
+ * of `pendingResume.oldSessionId`, making the update a no-op on the new
+ * session and leaving the old session permanently stuck at `resuming: true`.
+ * `consume()` also cancels the 30s timeout, so `onTimeout` never fired.
+ *
+ * See change: fix-electron-server-launch-node-bin (resume stuck bug).
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { WebSocket } from "ws";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createServer, type DashboardServer } from "../server.js";
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("event-wiring: pending-resume clears old session resuming flag", () => {
+  let server: DashboardServer;
+  let piPort: number;
+  let browserPort: number;
+  let testPort = 19700;
+
+  beforeEach(async () => {
+    testPort += 2;
+    browserPort = testPort;
+    piPort = testPort + 1;
+    server = await createServer({
+      port: browserPort,
+      piPort,
+      dev: true,
+      autoShutdown: false,
+      shutdownIdleSeconds: 999,
+      tunnel: false,
+      editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
+    });
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server.stop();
+  });
+
+  it("clears resuming on oldSessionId (not newSessionId) when resumed session registers", async () => {
+    const { sessionManager, browserGateway } = server;
+
+    const OLD_SESSION = "old-session-aaa";
+    const NEW_SESSION = "new-session-bbb";
+    // Use a real temp dir so meta-persistence doesn't fail on mkdir.
+    const tmpDir = mkdtempSync(path.join(os.tmpdir(), "pi-resume-test-"));
+    const CWD = tmpDir;
+    const sessionFile = path.join(tmpDir, "old.jsonl");
+    writeFileSync(sessionFile, ""); // create empty file
+
+    // 1. Seed the old session as ended with resuming:true.
+    //    register() sets status:"active", so follow up with update() to ended+resuming.
+    sessionManager.register({ id: OLD_SESSION, cwd: CWD, sessionFile, source: "terminal" });
+    sessionManager.update(OLD_SESSION, { status: "ended", resuming: true });
+    expect(sessionManager.get(OLD_SESSION)?.resuming).toBe(true);
+
+    // 2. Record a pending resume for the cwd (mirrors handleSendPrompt auto-resume path)
+    browserGateway.pendingResumeRegistry.record(CWD, {
+      text: "continue from here",
+      oldSessionId: OLD_SESSION,
+      sessionFile,
+    });
+
+    // 3. A new session with the same cwd registers (the resumed pi process connecting back)
+    const newBridgeWs = new WebSocket(`ws://localhost:${piPort}`);
+    await new Promise<void>((resolve, reject) => {
+      newBridgeWs.on("error", reject);
+      newBridgeWs.on("open", () => {
+        newBridgeWs.send(JSON.stringify({
+          type: "session_register",
+          sessionId: NEW_SESSION,
+          cwd: CWD,
+          source: "cli",
+        }));
+        newBridgeWs.send(JSON.stringify({ type: "replay_complete", sessionId: NEW_SESSION }));
+        resolve();
+      });
+    });
+    await wait(200); // let event-wiring process
+
+    // 4. OLD session's resuming flag must now be false
+    expect(
+      sessionManager.get(OLD_SESSION)?.resuming,
+      `Old session ${OLD_SESSION} should have resuming:false after new session registered`,
+    ).toBe(false);
+
+    // 5. NEW session must not have a spurious resuming:false (it never had resuming:true)
+    //    New session's resuming should be undefined (never set).
+    const newResuming = sessionManager.get(NEW_SESSION)?.resuming;
+    expect(
+      newResuming,
+      `New session ${NEW_SESSION} should not have resuming set; got ${newResuming}`,
+    ).toBeFalsy();
+
+    newBridgeWs.close();
+  });
+});

package/packages/server/src/__tests__/health-shape.test.ts

@@ -1,29 +1,37 @@
 /**
- * Tests for /api/health response shape after Phase A additions.
+ * Tests for /api/health response shape.
  *
  * Asserts:
  *  - `pid` field is present (regression pin).
- *  - `starter` field is present, defaults to "Standalone".
+ *  - `launchSource` field is present and reflects DASHBOARD_STARTER.
  *
- * Note: the "Standalone default for missing DASHBOARD_STARTER" case is
- * also covered exhaustively in packages/shared/src/__tests__/dashboard-starter.test.ts.
- * This test pins the contract at the HTTP layer so a refactor cannot silently
- * drop either field from the health response.
+ * `launchSource` replaces the legacy `starter` field per change:
+ * eliminate-electron-runtime-install (task 3.2). It is the single source
+ * of truth for arm-aware client gating (e.g. hiding pi-core update UI
+ * under Electron, since bundled node_modules/ is read-only there).
  */
-import { describe, it, expect, afterEach } from "vitest";
+import { describe, it, expect, afterEach, beforeEach } from "vitest";
 import { createTestServer, type TestServerHandle } from "../test-support/test-server.js";
 
 let handle: TestServerHandle | undefined;
+let savedStarter: string | undefined;
+
+describe("GET /api/health — shape", () => {
+  beforeEach(() => {
+    savedStarter = process.env.DASHBOARD_STARTER;
+  });
 
-describe("GET /api/health — Phase A shape", () => {
   afterEach(async () => {
     if (handle) {
       try { await handle.stop(); } catch { /* already stopped */ }
       handle = undefined;
     }
+    if (savedStarter === undefined) delete process.env.DASHBOARD_STARTER;
+    else process.env.DASHBOARD_STARTER = savedStarter;
   });
 
   it("includes pid field (regression pin)", async () => {
+    delete process.env.DASHBOARD_STARTER;
     handle = await createTestServer();
     const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
     expect(res.status).toBe(200);
@@ -32,12 +40,27 @@ describe("GET /api/health — Phase A shape", () => {
     expect(body.pid).toBe(process.pid);
   });
 
-  it("includes starter field defaulting to Standalone", async () => {
+  it("launchSource defaults to 'standalone' when DASHBOARD_STARTER unset", async () => {
+    delete process.env.DASHBOARD_STARTER;
+    handle = await createTestServer();
+    const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.launchSource).toBe("standalone");
+  });
+
+  it("launchSource is 'electron' when DASHBOARD_STARTER=Electron", async () => {
+    process.env.DASHBOARD_STARTER = "Electron";
+    handle = await createTestServer();
+    const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body.launchSource).toBe("electron");
+  });
+
+  it("launchSource is 'bridge' when DASHBOARD_STARTER=Bridge", async () => {
+    process.env.DASHBOARD_STARTER = "Bridge";
     handle = await createTestServer();
     const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
-    expect(res.status).toBe(200);
     const body = await res.json() as Record<string, unknown>;
-    // When bootstrapState has no starter set, defaults to "Standalone".
-    expect(body.starter).toBe("Standalone");
+    expect(body.launchSource).toBe("bridge");
   });
 });