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

package/packages/server/src/server.ts

@@ -14,6 +14,7 @@ import { createMemoryEventStore, type EventStore } from "./memory-event-store.js
 import { createMemorySessionManager, type SessionManager } from "./memory-session-manager.js";
 import { createPiGateway, type PiGateway } from "./pi-gateway.js";
 import { createBrowserGateway, type BrowserGateway } from "./browser-gateway.js";
+import { pluginIntentCache } from "./plugin-intent-cache.js";
 import { createPreferencesStore, type PreferencesStore } from "./preferences-store.js";
 import { createMetaPersistence, type MetaPersistence } from "./meta-persistence.js";
 import { createSessionOrderManager, type SessionOrderManager } from "./session-order-manager.js";
@@ -24,7 +25,7 @@ import { createPendingResumeIntentRegistry } from "./pending-resume-intent-regis
 import { applyReattachPolicy } from "./reattach-placement.js";
 
 // pending-load-manager removed — server loads sessions directly via DirectoryService
-import { createDirectoryService, isOpenSpecDataEmpty, type DirectoryService } from "./directory-service.js";
+import { createDirectoryService, type DirectoryService } from "./directory-service.js";
 import { createTerminalManager, type TerminalManager } from "./terminal-manager.js";
 import { createTerminalGateway, type TerminalGateway } from "./terminal-gateway.js";
 import { writePid, removePid } from "./server-pid.js";
@@ -42,6 +43,7 @@ import { createNetworkGuard, isLoopback, isBypassedHost } from "./localhost-guar
 import type { AuthConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import { loadConfig, CONFIG_FILE } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import { registerSessionApi } from "./session-api.js";
+import { registerManifestRoute } from "./routes/manifest-route.js";
 import { registerSessionRoutes } from "./routes/session-routes.js";
 import { registerGitRoutes } from "./routes/git-routes.js";
 import { registerFileRoutes } from "./routes/file-routes.js";
@@ -59,11 +61,6 @@ import { PiCoreChecker } from "./pi-core-checker.js";
 import { PiCoreUpdater } from "./pi-core-updater.js";
 import { registerToolRoutes } from "./routes/tool-routes.js";
 import { registerJjRoutes } from "./routes/jj-routes.js";
-import { registerBootstrapRoutes } from "./routes/bootstrap-routes.js";
-import { createBootstrapState, type BootstrapStateStore } from "./bootstrap-state.js";
-import { detectLegacyPiInstalls } from "./legacy-pi-cleanup.js";
-import { createBootstrapQueue } from "./bootstrap-queue.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 { registerProviderRoutes } from "./routes/provider-routes.js";
 import { PackageManagerWrapper } from "./package-manager-wrapper.js";
@@ -72,16 +69,20 @@ import { createEditorPidRegistry } from "./editor-pid-registry.js";
 import { registerEditorRoutes } from "./routes/editor-routes.js";
 import { registerKnownServersRoutes } from "./routes/known-servers-routes.js";
 import { registerPluginConfigRoutes } from "./routes/plugin-config-routes.js";
+import { registerPluginActivationRoutes } from "./routes/plugin-activation-routes.js";
 import { createModelProxyAuthGate } from "./model-proxy/auth-gate.js";
 import { registerModelProxyRoutes } from "./routes/model-proxy-routes.js";
 import { registerModelProxyApiKeyRoutes } from "./routes/model-proxy-api-key-routes.js";
 import { registerModelProxyRefreshRoutes } from "./routes/model-proxy-refresh-routes.js";
 import { getModelRegistry, getStreamSimpleFn } from "./model-proxy/registry-singleton.js";
 import { writeConfigPartial } from "./config-api.js";
-import { loadServerEntries, discoverPlugins, getPluginStatusStore } from "@blackbelt-technology/dashboard-plugin-runtime/server";
+import { loadServerEntries, discoverPlugins, getPluginStatusStore, refreshRequirementProbesFor } from "@blackbelt-technology/dashboard-plugin-runtime/server";
 import { createServerPluginContext } from "@blackbelt-technology/dashboard-plugin-runtime/server";
 import { getPluginConfig as getPluginConfigFromFile } from "@blackbelt-technology/pi-dashboard-shared/config.js";
-import { registerAllPluginBridges } from "@blackbelt-technology/pi-dashboard-shared/plugin-bridge-register.js";
+import {
+  registerAllPluginBridges,
+  reconcilePluginBridgePackages,
+} from "@blackbelt-technology/pi-dashboard-shared/plugin-bridge-register.js";
 import { registerEditorProxy, handleEditorUpgrade } from "./editor-proxy.js";
 import { detectCodeServerBinary } from "./editor-detection.js";
 
@@ -126,138 +127,12 @@ export interface DashboardServer {
   sessionManager: SessionManager;
   eventStore: EventStore;
   browserGateway: BrowserGateway;
-  /**
-   * Bootstrap state store. Exposed so the CLI can flip status during
-   * degraded-mode first-run (`pi-dashboard` without pi installed) and
-   * so the REST handler for `/api/bootstrap/upgrade-pi` can orchestrate
-   * async installs without reaching back through closures.
-   * See change: unified-bootstrap-install.
-   */
-  bootstrapState: BootstrapStateStore;
   /** Resolved HTTP port after start() (useful for port:0 in tests). Returns null if not listening. */
   httpPort(): number | null;
   /** Resolved pi gateway port after start(). Returns null if not listening. */
   piPort(): number | null;
 }
 
-// ── Post-install repair (centralized hook) ─────────────────────────
-// On every `installing → ready` bootstrap-state transition the server
-// re-runs the full ToolRegistry rescan, force-refreshes OpenSpec data
-// for every known directory, and refreshes pi-resources. Without this
-// the OpenSpec session-card buttons stay hidden until the next gated
-// poll tick (or never, if the gate's mtime heuristic declines).
-// See change: fix-openspec-buttons-after-bootstrap-install.
-
-import type { OpenSpecData } from "@blackbelt-technology/pi-dashboard-shared/types.js";
-import type { ServerToBrowserMessage } from "@blackbelt-technology/pi-dashboard-shared/browser-protocol.js";
-
-export interface PostInstallRepairDeps {
-  registry: { rescan(name?: string): void };
-  directoryService: {
-    knownDirectories(): string[];
-    getOpenSpecData(cwd: string): OpenSpecData | undefined;
-    refreshOpenSpec(cwd: string): Promise<OpenSpecData>;
-    refreshPiResources(cwd: string): Promise<unknown>;
-  };
-  browserGateway: { broadcastToAll(msg: ServerToBrowserMessage): void };
-}
-
-
-/**
- * Centralized post-install repair work fired on every `installing → ready`
- * bootstrap-state transition. Idempotent. Failures per-cwd are isolated.
- *
- * Steps:
- *   1) `registry.rescan()` (no arg — full registry invalidate). Restores
- *      the literal contract from `unified-bootstrap-install` task 4.3.
- *   2) For every `directoryService.knownDirectories()` cwd, force-refresh
- *      OpenSpec (bypassing the mtime gate). If the prior cache was empty
- *      or the refreshed payload differs, broadcast `openspec_update`.
- *   3) For every cwd, force-refresh pi-resources (silent on failure).
- *
- * The DEBUG=pi-dashboard|openspec-poll envvar enables a single-line
- * diagnostic log on completion, matching the existing daemon-log style.
- */
-export async function runPostInstallRepair(deps: PostInstallRepairDeps): Promise<void> {
-  const debug =
-    typeof process !== "undefined" &&
-    typeof process.env?.DEBUG === "string" &&
-    /pi-dashboard|openspec-poll/.test(process.env.DEBUG);
-
-  // 1) full registry rescan
-  deps.registry.rescan();
-  if (debug) console.log("[bootstrap] post-install: rescanned tool registry");
-
-  const cwds = deps.directoryService.knownDirectories();
-
-  // 2) per-cwd OpenSpec force-refresh + selective broadcast
-  await Promise.all(
-    cwds.map(async (cwd) => {
-      try {
-        const prior = deps.directoryService.getOpenSpecData(cwd);
-        const fresh = await deps.directoryService.refreshOpenSpec(cwd);
-        const priorEmpty = isOpenSpecDataEmpty(prior);
-        const dataDiffers = JSON.stringify(prior) !== JSON.stringify(fresh);
-        if (priorEmpty || dataDiffers) {
-          deps.browserGateway.broadcastToAll({ type: "openspec_update", cwd, data: fresh });
-        }
-      } catch (err) {
-        console.error(
-          `[bootstrap] post-install openspec refresh failed for ${cwd}:`,
-          err,
-        );
-      }
-    }),
-  );
-
-  // 3) per-cwd pi-resources force-refresh (silent fail)
-  await Promise.all(
-    cwds.map(async (cwd) => {
-      try {
-        await deps.directoryService.refreshPiResources(cwd);
-      } catch {
-        // matches existing pattern in directory-service.ts::schedulePiResourcesTick
-      }
-    }),
-  );
-
-  if (debug) console.log("[bootstrap] post-install: openspec + pi-resources refresh complete");
-}
-
-export interface BootstrapTransitionHandlerDeps {
-  /** Invoked once per `installing → ready` transition, fire-and-forget. */
-  onTransitionToReady: () => Promise<void> | void;
-  /** Existing queue flush invoked on the same transition. */
-  flushQueue: () => Promise<void> | void;
-}
-
-/**
- * Returns a stateful handler that drives `onTransitionToReady` and
- * `flushQueue` once per `installing → ready` (or `failed → ready`)
- * transition. The handler ignores the very first ready snapshot
- * because the bootstrap state defaults to ready.
- *
- * Both callbacks run fire-and-forget so the subscribe callback returns
- * synchronously — matches the existing `void bootstrapQueue.flushAll()`
- * pattern in the inline subscribe call site.
- */
-export function makeBootstrapTransitionHandler(
-  deps: BootstrapTransitionHandlerDeps,
-): (snapshot: { status: "ready" | "installing" | "failed" }) => void {
-  let last: "ready" | "installing" | "failed" = "ready";
-  return (snapshot) => {
-    if (last !== "ready" && snapshot.status === "ready") {
-      void Promise.resolve(deps.flushQueue()).catch((err) => {
-        console.error("[bootstrap] flushQueue failed:", err);
-      });
-      void Promise.resolve(deps.onTransitionToReady()).catch((err) => {
-        console.error("[bootstrap] post-install repair failed:", err);
-      });
-    }
-    last = snapshot.status;
-  };
-}
-
 export async function createServer(config: ServerConfig): Promise<DashboardServer> {
   // Ensure bridge extension is registered in pi's global settings
   // (needed for bundled installs where pi can't discover it from package.json)
@@ -689,48 +564,6 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     fastify.get("/auth/status", async () => ({ authenticated: true, authEnabled: false }));
   }
 
-  // ── Bootstrap state + queue ──────────────────────────────────────
-  // Declared here (before session-api registration) so the session
-  // routes can gate spawn operations on bootstrap status.
-  // See change: unified-bootstrap-install.
-  const bootstrapState = createBootstrapState();
-  // Scan for legacy `@mariozechner/pi-coding-agent` installs so the UI can
-  // offer a one-click cleanup. See: legacy-pi-cleanup.ts. Best-effort —
-  // detection failure is non-fatal (returns []).
-  try {
-    bootstrapState.set({ legacyPiInstalls: detectLegacyPiInstalls() });
-  } catch (err: any) {
-    console.warn("[legacy-pi] detection failed:", err?.message ?? err);
-  }
-  const bootstrapQueue = createBootstrapQueue();
-  // Centralized post-install repair: full ToolRegistry rescan +
-  // OpenSpec / pi-resources force-refresh on every `installing → ready`
-  // transition. See change: fix-openspec-buttons-after-bootstrap-install.
-  const handleBootstrapTransition = makeBootstrapTransitionHandler({
-    flushQueue: () => bootstrapQueue.flushAll(),
-    onTransitionToReady: () =>
-      runPostInstallRepair({
-        registry: getDefaultRegistry(),
-        directoryService,
-        browserGateway,
-      }),
-  });
-  const unsubscribeBootstrap = bootstrapState.subscribe((snapshot) => {
-    browserGateway.broadcastToAll({
-      type: "bootstrap_status_update",
-      state: snapshot,
-    });
-    handleBootstrapTransition(snapshot);
-  });
-  const unsubscribeQueueComplete = bootstrapQueue.onTicketComplete((evt) => {
-    browserGateway.broadcastToAll({
-      type: "bootstrap_ticket_complete",
-      ticketId: evt.ticketId,
-      success: evt.success,
-      error: evt.error,
-    });
-  });
-
   // Session control REST API (wraps WebSocket-only operations)
   registerSessionApi(fastify, {
     sessionManager,
@@ -738,8 +571,6 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     browserGateway,
     pendingForkRegistry,
     pendingDashboardSpawns,
-    bootstrapState,
-    bootstrapQueue,
     pendingResumeIntents,
     pendingAttachRegistry,
   });
@@ -756,7 +587,6 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     preferencesStore,
     directoryService,
     networkGuard,
-    bootstrapState,
     onOpenSpecChanged: (cwd) => {
       const data = directoryService.getOpenSpecData(cwd);
       if (data) browserGateway.broadcastToAll({ type: "openspec_update", cwd, data });
@@ -785,115 +615,16 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     networkGuard,
     store: openspecGroupStore,
   });
-  registerSystemRoutes(fastify, { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version: pkgVersion, directoryService, piGateway, bootstrapState });
+  registerSystemRoutes(fastify, { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version: pkgVersion, directoryService, piGateway });
   // GET /api/doctor — see change: doctor-rich-output (task 4.2). Auth-gated identically to /api/config.
   registerDoctorRoutes(fastify);
   registerToolRoutes(fastify, { registry: getDefaultRegistry(), networkGuard });
   registerJjRoutes(fastify, { browserGateway, pendingAttachRegistry, networkGuard });
 
-  // ── Bootstrap REST routes ────────────────────────────────────────
-  // The routes module is registered here; state + queue are declared
-  // above (before session-api) so session routes can see them.
-  registerBootstrapRoutes(fastify, {
-    bootstrapState,
-    networkGuard,
-    triggerUpgradePi: async () => {
-      const packages = ["@earendil-works/pi-coding-agent"];
-      bootstrapState.setLastInstallPackages(packages);
-      bootstrapState.set({
-        status: "installing",
-        progress: { step: "@earendil-works/pi-coding-agent", output: "starting upgrade…" },
-        error: undefined,
-      });
-      try {
-        const res = await bootstrapInstall({
-          packages,
-          progress: (p) => {
-            bootstrapState.set({
-              progress: { step: p.step, output: p.output },
-            });
-          },
-        });
-        if (res.ok) {
-          bootstrapState.set({
-            status: "ready",
-            progress: undefined,
-            error: undefined,
-          });
-          // Broadcast /reload to connected sessions so they pick up the
-          // new pi version. Mirrors the pi-core update pattern above.
-          const connectedIds = piGateway.getConnectedSessionIds();
-          for (const sid of connectedIds) {
-            const session = sessionManager.get(sid);
-            if (session && session.status !== "ended") {
-              piGateway.sendToSession(sid, {
-                type: "send_prompt",
-                sessionId: sid,
-                text: "/reload",
-              });
-            }
-          }
-        } else {
-          bootstrapState.set({
-            status: "failed",
-            error: { message: res.error },
-            progress: undefined,
-          });
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        bootstrapState.set({
-          status: "failed",
-          error: { message },
-          progress: undefined,
-        });
-      }
-    },
-    triggerRetry: async () => {
-      // Retry re-runs the EXACT package set from the last failed install.
-      // Falls back to the default first-run set if no prior install was
-      // recorded (edge case: manual retry before any install attempt).
-      const prev = bootstrapState.getLastInstallPackages();
-      const packages = prev.length > 0
-        ? prev
-        : ["@earendil-works/pi-coding-agent", "@fission-ai/openspec"];
-      bootstrapState.set({
-        status: "installing",
-        progress: { step: "retry", output: `restarting install (${packages.length} pkg${packages.length === 1 ? "" : "s"})…` },
-        error: undefined,
-      });
-      try {
-        const res = await bootstrapInstall({
-          packages,
-          progress: (p) => {
-            bootstrapState.set({
-              progress: { step: p.step, output: p.output },
-            });
-          },
-        });
-        if (res.ok) {
-          bootstrapState.set({
-            status: "ready",
-            progress: undefined,
-            error: undefined,
-          });
-        } else {
-          bootstrapState.set({
-            status: "failed",
-            error: { message: res.error },
-            progress: undefined,
-          });
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        bootstrapState.set({
-          status: "failed",
-          error: { message },
-          progress: undefined,
-        });
-      }
-    },
-  });
+  // /api/bootstrap/* routes removed under change:
+  // eliminate-electron-runtime-install (task 3.4). pi-core in-place
+  // updates flow through /api/pi-core/update for standalone + bridge
+  // arms; Electron arm uses electron-updater whole-app replacement.
   // Package management
   const packageManagerWrapper = new PackageManagerWrapper();
 
@@ -925,6 +656,24 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       ...(result.partialSuccess ? { partialSuccess: result.partialSuccess } : {}),
     } as any);
     if (result.success) invalidateRecommendedCache();
+    // A successful package operation may have changed plugin requirement
+    // satisfaction. Refresh probes and broadcast plugin_config_update for
+    // any plugin whose `missingRequirements` flipped.
+    // See change: add-plugin-activation-ui.
+    if (result.success) {
+      void refreshRequirementProbesFor(null, {
+        listInstalled: () => packageManagerWrapper.listInstalled("global"),
+      }).then((changed) => {
+        for (const id of changed) {
+          const status = getPluginStatusStore().getStatus(id);
+          browserGateway.broadcast({
+            type: "plugin_config_update",
+            id,
+            config: status ?? {},
+          });
+        }
+      });
+    }
   });
 
   // Reload all active sessions after a successful package operation
@@ -977,12 +726,11 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       message: event.message,
     });
   });
-  registerPiChangelogRoutes(fastify, { bootstrapState });
+  registerPiChangelogRoutes(fastify, {});
 
   registerPiCoreRoutes(fastify, {
     piCoreChecker,
     piCoreUpdater,
-    bootstrapState,
     onUpdateComplete: (payload) => {
       browserGateway.broadcastToAll({
         type: "pi_core_update_complete",
@@ -1017,6 +765,10 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     networkGuard,
     broadcast: (msg) => browserGateway.broadcast(msg),
   });
+  registerPluginActivationRoutes(fastify, {
+    networkGuard,
+    broadcast: (msg) => browserGateway.broadcast(msg),
+  });
   registerProviderRoutes(fastify, { networkGuard, piGateway, browserGateway, port: config.port });
 
   // ── Model Proxy ───────────────────────────────────────────────────
@@ -1077,30 +829,44 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   // that works in the dev repo silently returns wrong paths in the
   // installed node_modules layout. require.resolve identifies packages
   // by name, which is the only canonical identity across layouts.
+  // Client-dir resolution — single strategy under change:
+  // eliminate-electron-runtime-install. The legacy 5-strategy chain
+  // (sibling/hoisted/monorepo/legacy paths) defended against runtime
+  // re-extraction wiping the bundled tree. Under the immutable bundle
+  // architecture that scenario cannot occur; the npm-resolver-anchored
+  // path is the only durable identity across install layouts.
+  //
+  // Dev / monorepo fallbacks are still allowed when require.resolve
+  // misses (e.g. running from a checked-out workspace where the web
+  // package hasn't been linked yet).
   const __dirname = path.dirname(fileURLToPath(import.meta.url));
-  const clientSearchPaths: string[] = [];
+  let clientDir = "";
   try {
-    const webPkgJson = createRequire(import.meta.url).resolve("@blackbelt-technology/pi-dashboard-web/package.json");
-    clientSearchPaths.push(path.join(path.dirname(webPkgJson), "dist"));
+    const webPkgJson = createRequire(import.meta.url).resolve(
+      "@blackbelt-technology/pi-dashboard-web/package.json",
+    );
+    const candidate = path.join(path.dirname(webPkgJson), "dist");
+    if (existsSync(path.join(candidate, "index.html"))) clientDir = candidate;
   } catch {
-    // Web package not resolvable — fall through to path-based search.
+    // Web package not resolvable — try dev-monorepo sibling.
+    const devCandidate = path.join(__dirname, "../../client/dist");
+    if (existsSync(path.join(devCandidate, "index.html"))) clientDir = devCandidate;
   }
-  clientSearchPaths.push(
-    // Installed as scoped sibling of server
-    path.join(__dirname, "..", "..", "pi-dashboard-web", "dist"),
-    // Installed in a parent node_modules (hoisted)
-    path.join(__dirname, "..", "..", "..", "@blackbelt-technology", "pi-dashboard-web", "dist"),
-    // Monorepo workspace sibling
-    path.join(__dirname, "../../client/dist"),
-    // Legacy path
-    path.join(__dirname, "../../dist/client"),
-  );
-  const clientDir = clientSearchPaths.find(p => existsSync(path.join(p, "index.html"))) ?? "";
   const hasProductionBuild = !!clientDir;
   if (!hasProductionBuild) {
     console.log("[dashboard] No client build found — running in API-only mode");
   }
 
+  // Dynamic PWA manifest — MUST be registered before fastify-static so
+  // explicit route matching wins over the static asset. See change:
+  // add-dynamic-pwa-manifest-naming.
+  registerManifestRoute(fastify, {
+    clientDir,
+    // Re-read config per request so Settings panel changes propagate
+    // without a server restart. loadConfig() is fs-cheap (<1ms).
+    getDashboardName: () => loadConfig().dashboardName,
+  });
+
   // Register static file serving for production build.
   // Always enabled — in dev mode, Vite handles most requests via the
   // not-found proxy, but asset files (JS/CSS with hashed names) must be
@@ -1179,7 +945,6 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     sessionManager,
     eventStore,
     browserGateway,
-    bootstrapState,
 
     httpPort() {
       const addr = fastify.server.address();
@@ -1224,6 +989,9 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
             const pluginCfg = getPluginConfigFromFile(cfg, pluginId) as Record<string, unknown>;
             return pluginCfg.enabled !== false;
           },
+          requirementDeps: {
+            listInstalled: () => packageManagerWrapper.listInstalled("global"),
+          },
           createContext: (plugin) => createServerPluginContext(
             {
               fastify,
@@ -1239,9 +1007,26 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
                   return events.length > 0 ? events[events.length - 1] : undefined;
                 },
               },
-              broadcastToSubscribers: (msg) => browserGateway.broadcast(msg as any),
+              broadcastToSubscribers: (msg) => {
+                // Intercept plugin_intents broadcasts and cache them so
+                // reconnecting clients can replay the current intent state.
+                // See change: adopt-server-driven-intent-rendering.
+                const m = msg as { type?: string; pluginId?: string; sessionId?: string | null; slot?: string; intent?: unknown } | undefined;
+                if (m && m.type === "plugin_intents" && typeof m.pluginId === "string" && typeof m.slot === "string") {
+                  pluginIntentCache.set(
+                    m.pluginId,
+                    m.sessionId ?? null,
+                    m.slot as Parameters<typeof pluginIntentCache.set>[2],
+                    (m.intent ?? null) as Parameters<typeof pluginIntentCache.set>[3],
+                  );
+                }
+                browserGateway.broadcast(msg as any);
+              },
               registerPiHandler: (_type, _handler) => {},
-              registerBrowserHandler: (_type, _handler) => {},
+              registerBrowserHandler: (type, handler) =>
+                browserGateway.registerHandler(type, (msg, ws) =>
+                  handler(msg, ws as unknown),
+                ),
               getPluginConfig: (id) => {
                 const cfg = loadConfig();
                 return getPluginConfigFromFile(cfg, id);
@@ -1415,6 +1200,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
             const existing = store.getStatus(id);
             store.setStatus({
               id,
+              displayName: existing?.displayName ?? id,
               enabled: existing?.enabled ?? true,
               loaded: existing?.loaded ?? false,
               error: `Bridge path conflict: existing=${result.existingPath}, new=${result.newPath}`,
@@ -1424,6 +1210,22 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
         }
       }
 
+      // One-shot reconciliation: heal pre-existing installs where the bridge
+      // was registered only in `dashboardPluginBridges` (pi ignores that key).
+      // See change: fix-pi-flows-end-to-end (Group 1, task 1.5).
+      try {
+        const summary = reconcilePluginBridgePackages();
+        for (const entry of summary) {
+          if (entry.action === "added") {
+            console.info(
+              `[plugin-bridge] Reconciled packages[] for plugin "${entry.pluginId}": ${entry.bridgePath}`,
+            );
+          }
+        }
+      } catch (err) {
+        console.warn("[plugin-bridge] Reconciliation failed (non-fatal):", err);
+      }
+
       idleTimer.start();
     },
 
@@ -1443,10 +1245,6 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       preferencesStore.flush();
       preferencesStore.dispose();
 
-      unsubscribeBootstrap();
-      unsubscribeQueueComplete();
-      bootstrapState.dispose();
-      bootstrapQueue.clear("server shutting down");
       stopTunnelWatchdog();
       await deleteTunnel(config.port);
       piGateway.stop();

package/packages/server/src/session-api.ts

@@ -13,8 +13,6 @@ import { spawnPiSession } from "./process-manager.js";
 import { loadConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import type { PendingForkRegistry } from "./pending-fork-registry.js";
 import type { PendingResumeIntentRegistry } from "./pending-resume-intent-registry.js";
-import type { BootstrapStateStore } from "./bootstrap-state.js";
-import type { BootstrapQueue } from "./bootstrap-queue.js";
 import { attachRenameTarget, detachShouldClearName } from "./proposal-attach-naming.js";
 import { FORK_DEGRADED_TO_NEW_MESSAGE, FORK_DEGRADED_TO_NEW_CODE } from "./browser-handlers/session-action-handler.js";
 import { keeperOptsFromSpawnResult } from "./headless-pid-registry.js";
@@ -25,13 +23,6 @@ export interface SessionApiDeps {
   browserGateway: BrowserGateway;
   pendingForkRegistry?: PendingForkRegistry;
   pendingDashboardSpawns?: Map<string, number>;
-  /**
-   * Bootstrap state + queue for degraded-mode gating. When omitted,
-   * session operations run normally (legacy behavior for tests that
-   * don't exercise the bootstrap flow). See change: unified-bootstrap-install.
-   */
-  bootstrapState?: BootstrapStateStore;
-  bootstrapQueue?: BootstrapQueue;
   /**
    * User-resume-intent registry. Tagged in the resume endpoint so the
    * `sessionManager.onChange` ended→alive branch can distinguish a
@@ -58,54 +49,12 @@ function getSessionOrFail(sessionManager: SessionManager, id: string): { session
 }
 
 export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDeps) {
-  const { sessionManager, piGateway, browserGateway, pendingForkRegistry, pendingDashboardSpawns, bootstrapState, bootstrapQueue, pendingResumeIntents, pendingAttachRegistry } = deps;
+  const { sessionManager, piGateway, browserGateway, pendingForkRegistry, pendingDashboardSpawns, pendingResumeIntents, pendingAttachRegistry } = deps;
 
-  /**
-   * Gate pi-dependent operations on bootstrap status. Returns:
-   *   - null when ready (proceed).
-   *   - `{ code: 202, body: { status: "queued", ticketId } }` when installing;
-   *     the operation is enqueued and will run once status flips to "ready".
-   *   - `{ code: 503, body: { error } }` when failed.
-   * See change: unified-bootstrap-install §5.
-   */
-  function gateOrEnqueue<T>(handler: () => Promise<T>):
-    | null
-    | { code: 202; body: { status: "queued"; ticketId: string } }
-    | { code: 503; body: { error: string; bootstrap: "failed" | "version-too-old" } } {
-    if (!bootstrapState) return null;
-    const snap = bootstrapState.get();
-    // Block when pi version is below the configured minimum —
-    // even when status is "ready", a too-old pi must not run sessions.
-    // See change: unified-bootstrap-install §9.3.
-    if (
-      snap.status === "ready"
-      && snap.error?.message?.startsWith("pi version ")
-    ) {
-      return {
-        code: 503,
-        body: { error: snap.error.message, bootstrap: "version-too-old" },
-      };
-    }
-    if (snap.status === "ready") return null;
-    if (snap.status === "installing") {
-      if (!bootstrapQueue) {
-        return {
-          code: 202,
-          body: { status: "queued", ticketId: "" },
-        };
-      }
-      const ticket = bootstrapQueue.enqueue(handler);
-      return {
-        code: 202,
-        body: { status: "queued", ticketId: ticket.ticketId },
-      };
-    }
-    // status === "failed"
-    return {
-      code: 503,
-      body: { error: "pi not installed (bootstrap failed)", bootstrap: "failed" },
-    };
-  }
+  // Bootstrap gate + queue removed under change: eliminate-electron-runtime-install
+  // (task 3.5). pi/openspec/tsx ship as regular npm deps so pi is always
+  // resolvable at startup; queueing pi-dependent operations during an
+  // install window is no longer needed.
 
   // POST /api/session/:id/prompt
   fastify.post<IdParams & { Body: { text?: string; images?: any[] } }>(
@@ -254,13 +203,6 @@ export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDep
         return spawnResult;
       };
 
-      // Bootstrap gate: if pi isn't ready, queue the spawn and return 202.
-      const gate = gateOrEnqueue(doSpawn);
-      if (gate) {
-        reply.code(gate.code);
-        return gate.body;
-      }
-
       const spawnResult = await doSpawn();
       if (!spawnResult.success) {
         reply.code(500);