@blackbelt-technology/pi-agent-dashboard 0.4.6 → 0.5.1

package/packages/server/src/__tests__/subscription-handler.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from "vitest";
-import { handleSubscribe } from "../browser-handlers/subscription-handler.js";
+import { handleSubscribe, replaySessionAssets } from "../browser-handlers/subscription-handler.js";
 import { createMemoryEventStore } from "../memory-event-store.js";
 import { createMemorySessionManager } from "../memory-session-manager.js";
 import type { BrowserHandlerContext } from "../browser-handlers/handler-context.js";
@@ -30,16 +30,18 @@ function createMockContext(overrides: Partial<BrowserHandlerContext> = {}): Brow
 }
 
 describe("handleSubscribe — metadata requests on subscribe", () => {
-  it("sends request_commands, request_models, and request_roles to piGateway", () => {
+  it("sends request_commands, request_models, request_providers, and request_roles to piGateway", () => {
+    // request_providers added by change: replace-hardcoded-provider-lists.
     const ctx = createMockContext();
     const subs = new Set<string>();
     handleSubscribe({ type: "subscribe", sessionId: "s1" }, subs, ctx);
 
     const calls = (ctx.piGateway.sendToSession as any).mock.calls;
-    expect(calls).toHaveLength(3);
+    expect(calls).toHaveLength(4);
     expect(calls[0]).toEqual(["s1", { type: "request_commands", sessionId: "s1" }]);
     expect(calls[1]).toEqual(["s1", { type: "request_models", sessionId: "s1" }]);
-    expect(calls[2]).toEqual(["s1", { type: "request_roles", sessionId: "s1" }]);
+    expect(calls[2]).toEqual(["s1", { type: "request_providers", sessionId: "s1" }]);
+    expect(calls[3]).toEqual(["s1", { type: "request_roles", sessionId: "s1" }]);
   });
 });
 
@@ -107,9 +109,17 @@ describe("handleSubscribe — stale lastSeq detection", () => {
     expect(clearReplaying).toHaveBeenCalledWith(ctx.ws, "s1", 5); // lastSent = 5
   });
 
-  it("does not mark replaying for fresh subscribe (lastSeq: 0)", async () => {
+  it("marks replaying for fresh subscribe (lastSeq: 0) when events exist", async () => {
+    // Regression: cold subscribe must suppress live events during paginated
+    // replay. Without suppression, a live `event` arriving between batches
+    // bumps the client's maxSeq past the next batch's firstSeq, triggering
+    // the `firstSeq <= maxSeq` reset rule on the client which wipes state
+    // and rebuilds from only the last batch — leaving the chat showing
+    // only the tail messages.
+    // See change: fix-cold-subscribe-replay-interleave.
     const markReplaying = vi.fn();
-    const ctx = createMockContext({ markReplaying });
+    const clearReplaying = vi.fn();
+    const ctx = createMockContext({ markReplaying, clearReplaying });
     for (let i = 0; i < 3; i++) ctx.eventStore.insertEvent("s1", makeEvent());
 
     const subs = new Set<string>();
@@ -117,6 +127,20 @@ describe("handleSubscribe — stale lastSeq detection", () => {
 
     await new Promise((r) => setTimeout(r, 50));
 
+    expect(markReplaying).toHaveBeenCalledWith(ctx.ws, "s1");
+    expect(clearReplaying).toHaveBeenCalledWith(ctx.ws, "s1", 3); // lastSent = 3
+  });
+
+  it("does not mark replaying for fresh subscribe when there are no events", async () => {
+    const markReplaying = vi.fn();
+    const ctx = createMockContext({ markReplaying });
+    // No events inserted — hasEvents() returns false; falls through to the
+    // empty-session branch.
+    const subs = new Set<string>();
+    handleSubscribe({ type: "subscribe", sessionId: "s1", lastSeq: 0 }, subs, ctx);
+
+    await new Promise((r) => setTimeout(r, 50));
+
     expect(markReplaying).not.toHaveBeenCalled();
   });
 
@@ -193,3 +217,71 @@ describe("handleSubscribe — stale lastSeq detection", () => {
     expect(allEvents).toHaveLength(3);
   });
 });
+
+// chat-markdown-local-images-and-math
+describe("replaySessionAssets — emits one asset_register per Session.assets entry", () => {
+  it("sends nothing when session has no assets", () => {
+    const ctx = createMockContext();
+    ctx.sessionManager.register({ id: "s1", cwd: "/c", source: "dashboard" } as any);
+    replaySessionAssets({} as any, "s1", ctx);
+    expect((ctx.sendTo as any).mock.calls).toHaveLength(0);
+  });
+
+  it("sends one asset_register per asset on the session", () => {
+    const ctx = createMockContext();
+    ctx.sessionManager.register({ id: "s1", cwd: "/c", source: "dashboard" } as any);
+    ctx.sessionManager.update("s1", {
+      assets: {
+        abc: { data: "AAAA", mimeType: "image/png" },
+        def: { data: "BBBB", mimeType: "image/svg+xml" },
+      },
+    } as any);
+    const ws = {} as any;
+    replaySessionAssets(ws, "s1", ctx);
+    const calls = (ctx.sendTo as any).mock.calls as Array<[any, ServerToBrowserMessage]>;
+    const assetMsgs = calls.filter(([, m]) => m.type === "asset_register");
+    expect(assetMsgs).toHaveLength(2);
+    const byHash = Object.fromEntries(assetMsgs.map(([, m]: any) => [m.hash, m]));
+    expect(byHash.abc).toMatchObject({ data: "AAAA", mimeType: "image/png", sessionId: "s1" });
+    expect(byHash.def).toMatchObject({ data: "BBBB", mimeType: "image/svg+xml", sessionId: "s1" });
+  });
+
+  it("skips malformed asset entries defensively", () => {
+    const ctx = createMockContext();
+    ctx.sessionManager.register({ id: "s1", cwd: "/c", source: "dashboard" } as any);
+    // Force a malformed entry past the type check.
+    ctx.sessionManager.update("s1", {
+      assets: {
+        good: { data: "AAAA", mimeType: "image/png" },
+        bad: { data: 123, mimeType: "image/png" } as any,
+      },
+    } as any);
+    replaySessionAssets({} as any, "s1", ctx);
+    const calls = (ctx.sendTo as any).mock.calls as Array<[any, ServerToBrowserMessage]>;
+    const assetMsgs = calls.filter(([, m]) => m.type === "asset_register");
+    expect(assetMsgs).toHaveLength(1);
+    expect((assetMsgs[0][1] as any).hash).toBe("good");
+  });
+});
+
+describe("handleSubscribe — asset replay precedes events", () => {
+  it("sends asset_register messages before event_replay batches", async () => {
+    const ctx = createMockContext();
+    ctx.sessionManager.register({ id: "s1", cwd: "/c", source: "dashboard" } as any);
+    ctx.sessionManager.update("s1", {
+      assets: { h1: { data: "AAAA", mimeType: "image/png" } },
+    } as any);
+    ctx.eventStore.insertEvent("s1", makeEvent("message_update"));
+
+    const subs = new Set<string>();
+    handleSubscribe({ type: "subscribe", sessionId: "s1", lastSeq: 0 }, subs, ctx);
+    await new Promise((r) => setTimeout(r, 50));
+
+    const calls = (ctx.sendTo as any).mock.calls as Array<[any, ServerToBrowserMessage]>;
+    const firstAssetIdx = calls.findIndex(([, m]) => m.type === "asset_register");
+    const firstEventIdx = calls.findIndex(([, m]) => m.type === "event_replay");
+    expect(firstAssetIdx).toBeGreaterThanOrEqual(0);
+    expect(firstEventIdx).toBeGreaterThanOrEqual(0);
+    expect(firstAssetIdx).toBeLessThan(firstEventIdx);
+  });
+});

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-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;