@blackbelt-technology/pi-agent-dashboard 0.4.5 → 0.5.0

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

@@ -0,0 +1,91 @@
+/**
+ * Tests for POST /api/electron/reextract
+ * See change: simplify-electron-bootstrap-derived-state (task 6.4 / 6.9).
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Fastify, { type FastifyInstance } from "fastify";
+import { registerSystemRoutes } from "../routes/system-routes.js";
+import type { BootstrapStateStore, BootstrapState } from "../bootstrap-state.js";
+
+function noGuard() {
+  return async () => { /* allow all */ };
+}
+
+function makeBootstrapState(starter: string): BootstrapStateStore {
+  return {
+    get: () => ({
+      status: "ready",
+      starter: starter as any,
+      installable: { total: 0, installed: 0, failed: [] },
+    } as BootstrapState),
+    set: () => {},
+    subscribe: () => () => {},
+  } as unknown as BootstrapStateStore;
+}
+
+function makeNoopDeps(bootstrapState?: BootstrapStateStore) {
+  return {
+    sessionManager: { listActive: () => [], listAll: () => [] } as never,
+    preferencesStore: { flush: () => {} } as never,
+    metaPersistence: { flushAll: () => {} } as never,
+    config: { port: 8000, piPort: 9999, dev: false } as never,
+    networkGuard: noGuard(),
+    bootstrapState,
+  };
+}
+
+describe("POST /api/electron/reextract", () => {
+  let fastify: FastifyInstance;
+
+  beforeEach(async () => {
+    fastify = Fastify();
+  });
+
+  afterEach(async () => {
+    await fastify.close();
+  });
+
+  it("returns 403 when starter is Bridge", async () => {
+    const deps = makeNoopDeps(makeBootstrapState("Bridge"));
+    registerSystemRoutes(fastify, deps);
+    await fastify.ready();
+
+    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
+    expect(res.statusCode).toBe(403);
+    const body = res.json() as Record<string, unknown>;
+    expect(body.error).toBe("reextract_not_allowed");
+    expect(body.starter).toBe("Bridge");
+  });
+
+  it("returns 403 when starter is Standalone", async () => {
+    const deps = makeNoopDeps(makeBootstrapState("Standalone"));
+    registerSystemRoutes(fastify, deps);
+    await fastify.ready();
+
+    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
+    expect(res.statusCode).toBe(403);
+    const body = res.json() as Record<string, unknown>;
+    expect(body.error).toBe("reextract_not_allowed");
+    expect(body.starter).toBe("Standalone");
+  });
+
+  it("returns 202 when starter is Electron", async () => {
+    const deps = makeNoopDeps(makeBootstrapState("Electron"));
+    registerSystemRoutes(fastify, deps);
+    await fastify.ready();
+
+    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
+    expect(res.statusCode).toBe(202);
+    const body = res.json() as Record<string, unknown>;
+    expect(body.ok).toBe(true);
+  });
+
+  it("returns 403 when no bootstrapState (defaults to Standalone)", async () => {
+    const deps = makeNoopDeps(undefined);
+    registerSystemRoutes(fastify, deps);
+    await fastify.ready();
+
+    const res = await fastify.inject({ method: "POST", url: "/api/electron/reextract" });
+    expect(res.statusCode).toBe(403);
+  });
+});

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

@@ -25,7 +25,7 @@ function makeNoopDeps() {
 function makeFakeGateway(): { gateway: PiGateway; broadcasts: ServerToExtensionMessage[] } {
   const broadcasts: ServerToExtensionMessage[] = [];
   const gateway: PiGateway = {
-    broadcast(msg) { broadcasts.push(msg); },
+    broadcast(msg: ServerToExtensionMessage) { broadcasts.push(msg); },
     sendToSession() { return false; },
     isSessionConnected() { return false; },
     connectionCount() { return 0; },
@@ -46,7 +46,7 @@ describe("POST /api/restart broadcasts server_restarting", () => {
     const fake = makeFakeGateway();
     broadcasts = fake.broadcasts;
     // process.exit is deferred via setTimeout(...,200); silence it for the test
-    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => undefined as never));
+    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: string | number | null) => undefined as never) as (code?: string | number | null | undefined) => never);
     registerSystemRoutes(fastify, { ...makeNoopDeps(), piGateway: fake.gateway });
   });
 
@@ -82,7 +82,7 @@ describe("POST /api/shutdown broadcasts server_restarting", () => {
     fastify = Fastify();
     const fake = makeFakeGateway();
     broadcasts = fake.broadcasts;
-    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => undefined as never));
+    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: string | number | null) => undefined as never) as (code?: string | number | null | undefined) => never);
     registerSystemRoutes(fastify, { ...makeNoopDeps(), piGateway: fake.gateway });
   });
 
@@ -111,7 +111,7 @@ describe("/api/restart works without piGateway (no-op broadcast)", () => {
 
   beforeEach(() => {
     fastify = Fastify();
-    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => undefined as never));
+    exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: string | number | null) => undefined as never) as (code?: string | number | null | undefined) => never);
     registerSystemRoutes(fastify, makeNoopDeps()); // no piGateway
   });
 

package/packages/server/src/__tests__/system-routes-spawn-failures.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Tests for GET /api/spawn-failures endpoint.
+ * See change: spawn-failure-diagnostics.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import Fastify, { type FastifyInstance } from "fastify";
+import { registerSystemRoutes } from "../routes/system-routes.js";
+
+// Mock the spawn-failure-log module.
+vi.mock("../spawn-failure-log.js", () => ({
+  readSpawnFailures: vi.fn().mockReturnValue([]),
+  appendSpawnFailure: vi.fn(),
+  SpawnFailureEntry: undefined,
+}));
+
+import { readSpawnFailures } from "../spawn-failure-log.js";
+
+const mockReadSpawnFailures = vi.mocked(readSpawnFailures);
+
+function makeNoopDeps() {
+  return {
+    sessionManager: {} as never,
+    preferencesStore: { flush: () => {} } as never,
+    metaPersistence: { flushAll: () => {} } as never,
+    config: { port: 8000, piPort: 9999, dev: false } as never,
+    directoryService: {} as never,
+    piGateway: {
+      broadcast: vi.fn(),
+      announceRestart: vi.fn(),
+    } as never,
+    idleTimer: {} as never,
+    serverVersion: "test",
+    localhostGuard: () => async () => {},
+    tunnelStatus: () => ({ active: false }),
+    serverConfig: { dev: false } as never,
+    pluginStatusStore: { getAll: () => [] } as never,
+  };
+}
+
+describe("GET /api/spawn-failures", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    app = Fastify({ logger: false });
+    registerSystemRoutes(app, makeNoopDeps() as never);
+    await app.ready();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  it("returns empty entries when no log exists", async () => {
+    mockReadSpawnFailures.mockReturnValue([]);
+    const res = await app.inject({ method: "GET", url: "/api/spawn-failures" });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body).toHaveProperty("entries");
+    expect(body.entries).toEqual([]);
+    expect(mockReadSpawnFailures).toHaveBeenCalledWith(50);
+  });
+
+  it("passes custom limit", async () => {
+    mockReadSpawnFailures.mockReturnValue([]);
+    await app.inject({ method: "GET", url: "/api/spawn-failures?limit=10" });
+    expect(mockReadSpawnFailures).toHaveBeenCalledWith(10);
+  });
+
+  it("falls back to default limit on NaN", async () => {
+    mockReadSpawnFailures.mockReturnValue([]);
+    await app.inject({ method: "GET", url: "/api/spawn-failures?limit=abc" });
+    expect(mockReadSpawnFailures).toHaveBeenCalledWith(50);
+  });
+
+  it("returns entries from the log", async () => {
+    const entry = { ts: "2026-01-01T00:00:00Z", cwd: "/p/x", strategy: "headless", code: "PI_CRASHED", message: "crashed" };
+    mockReadSpawnFailures.mockReturnValue([entry] as never);
+    const res = await app.inject({ method: "GET", url: "/api/spawn-failures" });
+    const body = JSON.parse(res.body);
+    expect(body.entries).toHaveLength(1);
+    expect(body.entries[0].code).toBe("PI_CRASHED");
+  });
+});

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

@@ -242,6 +242,51 @@ describe("TerminalManager", () => {
       handlers.message(resizeMsg, false);
       expect(mockPtyResize).toHaveBeenCalledWith(120, 40);
     });
+
+    // Resize floor — see change: fix-terminal-half-height-dual-mount.
+    // PTYs at <2 cols/rows are non-functional for every supported shell
+    // and the most common cause is a transient display:none container
+    // measured by FitAddon during a route transition.
+    describe("resize floor", () => {
+      function attachAndSendResize(cols: number, rows: number) {
+        const session = manager.spawn("/tmp");
+        const handlers: Record<string, Function> = {};
+        const mockWs = {
+          send: vi.fn(),
+          on: vi.fn((event: string, cb: any) => { handlers[event] = cb; }),
+          readyState: 1,
+          OPEN: 1,
+        } as any;
+        manager.attach(session.id, mockWs);
+        const msg = Buffer.from(JSON.stringify({ type: "resize", cols, rows }));
+        handlers.message(msg, false);
+      }
+
+      it("ignores resize with cols below floor (cols=1)", () => {
+        attachAndSendResize(1, 24);
+        expect(mockPtyResize).not.toHaveBeenCalled();
+      });
+
+      it("ignores resize with rows below floor (rows=0)", () => {
+        attachAndSendResize(80, 0);
+        expect(mockPtyResize).not.toHaveBeenCalled();
+      });
+
+      it("ignores resize with both dimensions below floor", () => {
+        attachAndSendResize(1, 1);
+        expect(mockPtyResize).not.toHaveBeenCalled();
+      });
+
+      it("accepts resize at the floor (cols=2, rows=2)", () => {
+        attachAndSendResize(2, 2);
+        expect(mockPtyResize).toHaveBeenCalledWith(2, 2);
+      });
+
+      it("accepts a normal resize", () => {
+        attachAndSendResize(80, 24);
+        expect(mockPtyResize).toHaveBeenCalledWith(80, 24);
+      });
+    });
   });
 
   describe("PTY exit", () => {

package/packages/server/src/bootstrap-install-from-list.ts

@@ -0,0 +1,232 @@
+/**
+ * Bootstrap install reconciler driven by ~/.pi/dashboard/installable.json.
+ * Invoked by cli.ts before app.listen.
+ *
+ * File-absent path is a deliberate no-op: Bridge and Standalone starters
+ * never write installable.json; only Electron seeds it on first run.
+ * When the file is absent, this function logs and returns immediately so
+ * bootstrap.status transitions to "ready" without delay.
+ *
+ * See change: simplify-electron-bootstrap-derived-state.
+ */
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { getManagedDir } from "@blackbelt-technology/pi-dashboard-shared/managed-paths.js";
+import {
+  readInstallableList,
+  type InstallablePackage,
+} from "@blackbelt-technology/pi-dashboard-shared/installable-list.js";
+import { bootstrapInstall } from "@blackbelt-technology/pi-dashboard-shared/bootstrap-install.js";
+import { getDefaultRegistry } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
+import type { BootstrapStateStore } from "./bootstrap-state.js";
+
+// ── Injectable helpers (overridable in tests) ──────────────────────────────
+
+export type InstallProgressCallback = (line: string) => void;
+export type PackageInstaller = (
+  pkg: InstallablePackage,
+  onOutput: InstallProgressCallback,
+) => Promise<void>;
+
+// ── Installed-check ────────────────────────────────────────────────────────
+
+/**
+ * Return true if `pkgName` is resolvable from `managedDir/node_modules`.
+ * Version satisfies check is intentionally omitted (no semver dep) —
+ * we treat "resolves at all" as satisfied. This is sufficient for the
+ * Phase B bootstrap use case.
+ */
+export function isNpmPackageInstalled(pkgName: string, managedDir: string): boolean {
+  try {
+    // createRequire resolves from the given path; look in managedDir/node_modules.
+    const req = createRequire(path.join(managedDir, "package.json"));
+    req.resolve(pkgName + "/package.json");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ── Default installers ─────────────────────────────────────────────────────
+
+async function defaultNpmInstall(
+  pkg: InstallablePackage,
+  managedDir: string,
+  onOutput: InstallProgressCallback,
+): Promise<void> {
+  const spec =
+    pkg.version && pkg.version !== "*"
+      ? `${pkg.name}@${pkg.version}`
+      : pkg.name;
+  const res = await bootstrapInstall({
+    packages: [spec],
+    managedDir,
+    progress: (p) => {
+      if (p.output) onOutput(p.output);
+    },
+  });
+  if (!res.ok) {
+    throw new Error(res.error);
+  }
+}
+
+async function defaultPiExtensionInstall(
+  pkg: InstallablePackage,
+  onOutput: InstallProgressCallback,
+): Promise<void> {
+  const registry = getDefaultRegistry();
+  const { module: piModule } = await registry.resolveModule<{
+    DefaultPackageManager: any;
+    SettingsManager: any;
+  }>("pi-coding-agent");
+  const agentDir = path.join(os.homedir(), ".pi", "agent");
+  const settingsManager = piModule.SettingsManager.create(process.cwd(), agentDir);
+  const pm = new piModule.DefaultPackageManager({
+    cwd: process.cwd(),
+    agentDir,
+    settingsManager,
+  });
+  pm.setProgressCallback((event: { message?: string }) => {
+    if (event.message) onOutput(event.message);
+  });
+  await pm.installAndPersist(pkg.name, { local: false });
+}
+
+// ── Options ────────────────────────────────────────────────────────────────
+
+export interface BootstrapInstallFromListOptions {
+  /** Override config dir for installable.json (default: ~/.pi/dashboard/). */
+  configDir?: string;
+  /** Override managed dir for npm installs (default: ~/.pi-dashboard/). */
+  managedDir?: string;
+  /**
+   * Injectable npm installer. Defaults to bootstrapInstall.
+   * Receives the InstallablePackage and a streaming output callback.
+   */
+  npmInstall?: PackageInstaller;
+  /**
+   * Injectable pi-extension installer. Defaults to pi DefaultPackageManager.
+   * Receives the InstallablePackage and a streaming output callback.
+   */
+  piInstall?: PackageInstaller;
+  /**
+   * Injectable installed-check for npm packages.
+   * Defaults to isNpmPackageInstalled.
+   */
+  isInstalled?: (pkg: InstallablePackage, managedDir: string) => boolean;
+}
+
+// ── Main reconciler ────────────────────────────────────────────────────────
+
+/**
+ * Reconcile packages from installable.json against the managed directory.
+ *
+ * - File absent: log and return immediately (not a failure).
+ * - Per package: check installed → skip or install.
+ * - Required failure: set bootstrap status=failed, throw (abort server start).
+ * - Optional failure: log, record in failed[], continue.
+ */
+export async function bootstrapInstallFromList(
+  bootstrapState: BootstrapStateStore,
+  opts?: BootstrapInstallFromListOptions,
+): Promise<void> {
+  const configDir =
+    opts?.configDir ?? path.join(os.homedir(), ".pi", "dashboard");
+  const managedDir = opts?.managedDir ?? getManagedDir();
+
+  // Read installable.json; absent file is a deliberate no-op.
+  const list = await readInstallableList(configDir);
+  if (list === null) {
+    console.log(
+      "[bootstrap] bootstrap.installable.skipped reason=file-not-found",
+    );
+    return;
+  }
+
+  // Only process packages that are active (not deprecated, not defaultOff).
+  const packages = list.packages.filter((p) => !p.deprecated && !p.defaultOff);
+  const total = packages.length;
+  let installedCount = 0;
+  const failed: string[] = [];
+
+  // Stamp initial installable progress into bootstrap state.
+  bootstrapState.set({ installable: { total, installed: 0, failed: [] } });
+
+  const checkInstalled =
+    opts?.isInstalled ?? ((p, dir) => isNpmPackageInstalled(p.name, dir));
+  const doNpmInstall: PackageInstaller =
+    opts?.npmInstall ??
+    ((p, cb) => defaultNpmInstall(p, managedDir, cb));
+  const doPiInstall: PackageInstaller =
+    opts?.piInstall ?? defaultPiExtensionInstall;
+
+  for (const pkg of packages) {
+    // Fast path: already installed (npm packages only; pi-extension always attempts).
+    if (pkg.kind === "npm" && checkInstalled(pkg, managedDir)) {
+      console.log(
+        `[bootstrap] bootstrap.installable.package name=${pkg.name} status=satisfied`,
+      );
+      installedCount++;
+      bootstrapState.set({
+        installable: { total, installed: installedCount, failed },
+      });
+      continue;
+    }
+
+    // Emit installing progress.
+    bootstrapState.set({
+      progress: { step: pkg.name, output: "installing..." },
+      installable: { total, installed: installedCount, failed },
+    });
+
+    try {
+      const onOutput = (line: string): void => {
+        bootstrapState.set({ progress: { step: pkg.name, output: line } });
+      };
+
+      if (pkg.kind === "npm") {
+        await doNpmInstall(pkg, onOutput);
+      } else {
+        await doPiInstall(pkg, onOutput);
+      }
+
+      installedCount++;
+      bootstrapState.set({
+        progress: undefined,
+        installable: { total, installed: installedCount, failed },
+      });
+      console.log(
+        `[bootstrap] bootstrap.installable.package name=${pkg.name} status=done`,
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(
+        `[bootstrap] bootstrap.installable.package name=${pkg.name} status=error error=${message}`,
+      );
+      failed.push(pkg.name);
+      bootstrapState.set({
+        progress: undefined,
+        installable: { total, installed: installedCount, failed: [...failed] },
+      });
+
+      if (pkg.required) {
+        const errorMessage = `Required package "${pkg.name}" failed to install: ${message}`;
+        bootstrapState.set({
+          status: "failed",
+          error: { message: errorMessage },
+        });
+        throw new Error(errorMessage);
+      }
+      // Optional package failure: log, continue to next package.
+    }
+  }
+
+  // Final state snapshot.
+  bootstrapState.set({
+    installable: { total, installed: installedCount, failed },
+  });
+  console.log(
+    `[bootstrap] bootstrap.installable.done total=${total} installed=${installedCount} failed=${failed.length}`,
+  );
+}

package/packages/server/src/bootstrap-state.ts

@@ -1,3 +1,5 @@
+import type { DashboardStarter } from "@blackbelt-technology/pi-dashboard-shared/dashboard-starter.js";
+
 /**
  * In-memory bootstrap state store for the dashboard server.
  *
@@ -51,6 +53,22 @@ export interface BootstrapState {
   compatibility?: BootstrapCompatibility;
   /** Set when `registerBridgeExtension` fails after a successful install. */
   bridgeRegistrationError?: string;
+  /**
+   * Who started this server process. Defaults to "Standalone" (direct CLI).
+   * Set at boot time from `parseDashboardStarter(process.env)`.
+   */
+  starter?: DashboardStarter;
+  /**
+   * Installable list reconciliation progress.
+   * Set by bootstrapInstallFromList during Phase B reconcile.
+   * See change: simplify-electron-bootstrap-derived-state.
+   */
+  installable?: {
+    total: number;
+    installed: number;
+    /** Package names that failed to install. */
+    failed: string[];
+  };
 }
 
 export type BootstrapListener = (state: BootstrapState) => void;

package/packages/server/src/browser-gateway.ts

@@ -15,7 +15,44 @@ import { createHeadlessPidRegistry, type HeadlessPidRegistry } from "./headless-
 import type { PendingForkRegistry } from "./pending-fork-registry.js";
 import type { SessionOrderManager } from "./session-order-manager.js";
 import type { PreferencesStore } from "./preferences-store.js";
-import type { DirectoryService } from "./directory-service.js";
+import { hasOpenSpecDir, type DirectoryService } from "./directory-service.js";
+
+/**
+ * Pure helper: build the per-cwd `openspec_update` messages a freshly
+ * connecting browser should receive. One message per known cwd.
+ * Disambiguates three states:
+ *   - cache populated         → cached payload
+ *   - openspec dir but cold   → { initialized: false, pending: true }
+ *   - no openspec dir         → { initialized: false, pending: false }
+ *
+ * Exported so cold-boot snapshot semantics can be unit-tested without
+ * spinning up a WS server. See change: fix-cold-boot-openspec-protocol.
+ */
+export function buildOpenSpecConnectSnapshot(
+  directoryService: Pick<DirectoryService, "knownDirectories" | "getOpenSpecData">,
+  hasDir: (cwd: string) => boolean,
+): Array<ServerToBrowserMessage> {
+  const out: Array<ServerToBrowserMessage> = [];
+  for (const cwd of directoryService.knownDirectories()) {
+    const cached = directoryService.getOpenSpecData(cwd);
+    if (cached && cached.initialized) {
+      out.push({ type: "openspec_update", cwd, data: cached });
+    } else if (hasDir(cwd)) {
+      out.push({
+        type: "openspec_update",
+        cwd,
+        data: { initialized: false, pending: true, changes: [] },
+      });
+    } else {
+      out.push({
+        type: "openspec_update",
+        cwd,
+        data: { initialized: false, pending: false, changes: [] },
+      });
+    }
+  }
+  return out;
+}
 import { createPendingResumeRegistry, type PendingResumeRegistry } from "./pending-resume-registry.js";
 import { createViewedSessionTracker, type ViewedSessionTracker } from "./viewed-session-tracker.js";
 import type { TerminalManager } from "./terminal-manager.js";
@@ -208,10 +245,21 @@ export function createBrowserGateway(
     const subs = new Set<string>();
     subscriptions.set(ws, subs);
 
-    // Send all sessions on connect (client filters by hidden flag)
-    const allSessions = sessionManager.listAll();
-    for (const session of allSessions) {
-      sendTo(ws, { type: "session_added", session });
+    // Atomic snapshot of the full session registry + per-cwd orders.
+    // Replaces the legacy per-session `session_added` loop and per-cwd
+    // `sessions_reordered` loop. Client REPLACES (not merges) its
+    // `sessions` Map and `sessionOrderMap` on receipt so stale ids from a
+    // previous server lifetime are dropped atomically.
+    // See change: fix-stale-sessions-on-reconnect.
+    {
+      const sessionsSnapshot = sessionManager.listAll();
+      const orders: Record<string, string[]> = {};
+      if (sessionOrderManager) {
+        for (const [cwd, sessionIds] of Object.entries(sessionOrderManager.getAllOrders())) {
+          if (sessionIds.length > 0) orders[cwd] = sessionIds;
+        }
+      }
+      sendTo(ws, { type: "sessions_snapshot", sessions: sessionsSnapshot, orders });
     }
 
     // Send pinned directories on connect
@@ -219,23 +267,12 @@ export function createBrowserGateway(
       sendTo(ws, { type: "pinned_dirs_updated", paths: preferencesStore.getPinnedDirectories() });
     }
 
-    // Send session orders for all cwds
-    if (sessionOrderManager) {
-      const allOrders = sessionOrderManager.getAllOrders();
-      for (const [cwd, sessionIds] of Object.entries(allOrders)) {
-        if (sessionIds.length > 0) {
-          sendTo(ws, { type: "sessions_reordered", cwd, sessionIds });
-        }
-      }
-    }
-
-    // Send cached OpenSpec data for all known directories
+    // Send OpenSpec data for every known directory — exactly one
+    // `openspec_update` per cwd, never silently omit.
+    // See change: fix-cold-boot-openspec-protocol.
     if (directoryService) {
-      for (const cwd of directoryService.knownDirectories()) {
-        const data = directoryService.getOpenSpecData(cwd);
-        if (data && data.initialized) {
-          sendTo(ws, { type: "openspec_update", cwd, data });
-        }
+      for (const msg of buildOpenSpecConnectSnapshot(directoryService, hasOpenSpecDir)) {
+        sendTo(ws, msg);
       }
     }
 

package/packages/server/src/browser-handlers/directory-handler.ts

@@ -148,6 +148,10 @@ export function handlePiGatewayForward(
     case "request_models":
       piGateway.sendToSession(msg.sessionId, { type: "request_models", sessionId: msg.sessionId });
       break;
+    case "request_providers":
+      // See change: replace-hardcoded-provider-lists.
+      piGateway.sendToSession(msg.sessionId, { type: "request_providers", sessionId: msg.sessionId });
+      break;
     case "set_thinking_level":
       piGateway.sendToSession(msg.sessionId, { type: "set_thinking_level", sessionId: msg.sessionId, level: msg.level });
       break;