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

package/packages/server/src/cli.ts

@@ -15,7 +15,16 @@
  *   --dev            Development mode (skip static files)
  *   --no-tunnel      Disable zrok tunnel
  */
-import { createServer, type ServerConfig } from "./server.js";
+// `createServer` is imported dynamically inside `runForeground()` so a
+// top-level module-resolution failure (missing `fastify` etc.) can be
+// caught and degraded into the recovery HTTP server instead of crashing
+// the process. The type-only import here is fully erased at runtime.
+import type { createServer as _CreateServerType, ServerConfig } from "./server.js";
+import {
+  startRecoveryServer,
+  isModuleNotFoundError,
+  parseModuleNotFoundError,
+} from "./recovery-server.js";
 import { loadConfig, ensureConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import {
   launchDashboardServer,
@@ -47,48 +56,13 @@ import { discoverDashboard } from "@blackbelt-technology/pi-dashboard-shared/mdn
 
 import { assertNodeVersionSupported } from "./node-guard.js";
 import { getDefaultRegistry } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
-import { bootstrapInstall } from "@blackbelt-technology/pi-dashboard-shared/bootstrap-install.js";
 import {
   findBundledExtension,
   registerBridgeExtension,
 } from "@blackbelt-technology/pi-dashboard-shared/bridge-register.js";
-import type { DashboardServer } from "./server.js";
-import { updateBootstrapCompatibility } from "./pi-version-skew.js";
-import type { BootstrapStateStore } from "./bootstrap-state.js";
 import { parseDashboardStarter } from "@blackbelt-technology/pi-dashboard-shared/dashboard-starter.js";
-import { bootstrapInstallFromList } from "./bootstrap-install-from-list.js";
-
-/**
- * Emit a stderr warning at CLI startup when the resolved pi version is
- * below `piCompatibility.minimum` (blocking) or below `.recommended`
- * (advisory). Reads from the already-populated `bootstrapState` so no
- * additional I/O happens here. See change: warn-pi-version-skew-in-cli.
- */
-function logCompatibilityWarning(store: BootstrapStateStore): void {
-  const s = store.get();
-  const c = s.compatibility;
-  if (!c || !c.current) return;
-  // Below minimum: `updateBootstrapCompatibility` sets `error.message`.
-  // We treat the presence of a blocking error + upgradeRecommended as the
-  // below-minimum signal; `upgradeRecommended` alone means below-recommended.
-  if (s.error?.message && c.upgradeRecommended) {
-    console.error(
-      `[bootstrap] ⚠ pi ${c.current} is below the required minimum ${c.minimum}.`,
-    );
-    console.error(
-      `[bootstrap]   All pi-dependent features (sessions, resources, openspec) will return 503.`,
-    );
-    console.error(`[bootstrap]   Run: pi-dashboard upgrade-pi`);
-    return;
-  }
-  if (c.upgradeRecommended) {
-    console.warn(
-      `[bootstrap] pi ${c.current} is below the recommended ${c.recommended} — consider running \`pi-dashboard upgrade-pi\``,
-    );
-  }
-}
 
-const SUBCOMMANDS = ["start", "stop", "restart", "status", "upgrade-pi"] as const;
+const SUBCOMMANDS = ["start", "stop", "restart", "status"] as const;
 type Subcommand = (typeof SUBCOMMANDS)[number];
 
 export interface ParsedArgs {
@@ -157,184 +131,83 @@ export function buildConfig(flags: Partial<ServerConfig>): ServerConfig {
 }
 
 /**
- * Run the server in the foreground (original behavior).
+ * Run the server in the foreground.
  *
- * After the server starts listening, the degraded-mode bootstrap kicks
- * off: if `pi` is not resolvable via the ToolRegistry, the server flips
- * `bootstrapState` to "installing" and begins a background
- * `bootstrapInstall`. Session-spawn and other pi-dependent endpoints
- * queue or 503 during this window (see change tasks §5).
- *
- * See change: unified-bootstrap-install.
+ * Pi/openspec/tsx ship as regular npm deps of this package, so the
+ * ToolRegistry resolve of "pi" at startup either succeeds (regular
+ * path) or signals a corrupted install (hard error). See change:
+ * eliminate-electron-runtime-install.
  */
 async function runForeground(config: ServerConfig): Promise<void> {
   assertNodeVersionSupported();
-  const server = await createServer(config);
-
-  // Stamp the bootstrap state with who started this server process.
-  // parseDashboardStarter defaults to "Standalone" when DASHBOARD_STARTER is unset.
-  const starter = parseDashboardStarter(process.env);
-  server.bootstrapState.set({ starter });
-  console.log(`[bootstrap] starter=${starter}`);
-
-  let shuttingDown = false;
-  const shutdown = async () => {
-    if (shuttingDown) {
-      console.log("Force exit.");
-      process.exit(1);
-    }
-    shuttingDown = true;
-    console.log("\nShutting down...");
-    await server.stop();
-    process.exit(0);
-  };
-
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
 
-  // Reconcile installable.json before binding the port.
-  // Required-package failures throw and prevent server start.
-  // Optional failures are logged and continue.
-  // File-absent is a no-op (Bridge/Standalone starters don't seed installable.json).
-  // See change: simplify-electron-bootstrap-derived-state.
+  // Dynamic-import boundary for the main server module. If a top-level
+  // dependency (fastify, toad-cache, readable-stream, …) is missing, the
+  // import throws ERR_MODULE_NOT_FOUND here — caught and degraded to the
+  // recovery HTTP server bound to the same port.
+  let createServer: typeof _CreateServerType;
   try {
-    await bootstrapInstallFromList(server.bootstrapState);
+    ({ createServer } = await import("./server.js"));
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[bootstrap] installable reconcile failed (required package): ${message}`);
-    process.exit(1);
+    if (isModuleNotFoundError(err)) {
+      await startRecoveryServer({
+        port: config.port,
+        error: err as Error,
+        missingModule: parseModuleNotFoundError(err),
+      });
+      // startRecoveryServer never returns — its HTTP server keeps the
+      // event loop alive until the user clicks Retry (which respawns and
+      // process.exits) or the process is killed externally.
+      return new Promise<void>(() => { /* unreachable */ });
+    }
+    throw err;
   }
 
-  await server.start();
-
-  // Kick off the degraded-mode first-run bootstrap if pi is unresolvable.
-  // Runs async — server is already listening, so UI + non-pi endpoints
-  // remain fully operational during the ~30s install window.
-  // TODO(single-dashboard-per-home): when home-lock wiring lands, wrap
-  // this inside the acquired lock to serialize concurrent first-run
-  // installs from multiple dashboard invocations on the same HOME.
-  runDegradedModeBootstrap(server).catch((err) => {
-    console.error("[bootstrap] unexpected failure in bootstrap orchestrator:", err);
-  });
-}
+  const server = await createServer(config);
 
-/**
- * Orchestrate the first-run bootstrap flow.
- *
- *  - If pi is already resolvable → leave `bootstrapState` at the default
- *    "ready" and return immediately.
- *  - Otherwise flip to "installing", run `bootstrapInstall`, then:
- *      • on success, rescan the registry, attempt bridge registration
- *        (failures are non-fatal and land in `bridgeRegistrationError`),
- *        flip to "ready".
- *      • on failure, flip to "failed" with the error.
- *
- * Structured log lines at each transition aid diagnosis in daemon-mode
- * (stdout goes to ~/.pi/dashboard/server.log).
- */
-async function runDegradedModeBootstrap(server: DashboardServer): Promise<void> {
-  const registry = getDefaultRegistry();
-  const initial = registry.resolve("pi");
-
-  if (initial.ok) {
-    // Default state is "ready" — no change needed. Log once for clarity.
-    console.log(`[bootstrap] ready (pi resolved via ${initial.source})`);
-    // Populate version-skew compatibility info even when no install was
-    // needed — the UI banner renders upgradeRecommended hints.
-    try {
-      const serverPkg = path.resolve(
-        path.dirname(fileURLToPath(import.meta.url)),
-        "..",
-        "package.json",
+  // Tool-registry resolve confirms pi is reachable from the bundled
+  // node_modules/ — under change: eliminate-electron-runtime-install,
+  // pi/openspec/tsx ship as regular deps so the registry must resolve
+  // at startup. A miss here means the install tree is corrupted.
+  {
+    const registry = getDefaultRegistry();
+    const res = registry.resolve("pi");
+    if (res.ok) {
+      console.log(`[bootstrap] ready (pi resolved via ${res.source})`);
+    } else {
+      const tried = res.tried?.map((t: any) => t.strategy).join(", ") ?? "(no strategies)";
+      throw new Error(
+        `[bootstrap] pi is not resolvable from the dashboard install. ` +
+        `This indicates a corrupted node_modules/ tree. Tried: ${tried}. ` +
+        `Reinstall the dashboard (npm i -g @blackbelt-technology/pi-agent-dashboard) ` +
+        `or reinstall the Electron app.`,
       );
-      updateBootstrapCompatibility(server.bootstrapState, serverPkg);
-      logCompatibilityWarning(server.bootstrapState);
-    } catch (err) {
-      console.warn("[bootstrap] version-skew check failed (non-fatal):", err);
     }
-    return;
   }
 
-  const installPackages = ["@earendil-works/pi-coding-agent", "@fission-ai/openspec"];
-  server.bootstrapState.setLastInstallPackages(installPackages);
-  console.log("[bootstrap] installing (pi unresolved, running background install)");
-  server.bootstrapState.set({
-    status: "installing",
-    progress: { step: "pi", output: "starting install…" },
-    error: undefined,
-  });
-
+  // One-time advisory: legacy `~/.pi-dashboard/` directory left behind
+  // from pre-R3 versions. Nothing reads or writes it now — surface a
+  // single log line so the user knows it's safe to delete. Doctor UI
+  // shows the same advisory more visibly.
   try {
-    const res = await bootstrapInstall({
-      packages: installPackages,
-      progress: (p) => {
-        server.bootstrapState.set({
-          progress: { step: p.step, output: p.output },
-        });
-      },
-    });
-
-    if (!res.ok) {
-      console.error(`[bootstrap] failed: ${res.error}`);
-      server.bootstrapState.set({
-        status: "failed",
-        error: { message: res.error },
-        progress: undefined,
-      });
-      return;
-    }
-
-    // Post-install registry rescan + openspec/pi-resources force-refresh
-    // are now centralized in server.ts's bootstrapState.subscribe hook,
-    // which fires on every installing → ready transition (this caller +
-    // triggerUpgradePi + triggerRetry).
-    // See change: fix-openspec-buttons-after-bootstrap-install.
-
-    // Attempt bridge registration. Failures are non-fatal per spec §10.3.
-    let bridgeErr: string | undefined;
-    try {
-      const extPath = findBundledExtension(process.cwd());
-      if (extPath) {
-        registerBridgeExtension(extPath);
-      } else {
-        bridgeErr = "bundled extension not found after install";
-      }
-    } catch (err) {
-      bridgeErr = err instanceof Error ? err.message : String(err);
-    }
-
-    server.bootstrapState.set({
-      status: "ready",
-      progress: undefined,
-      error: undefined,
-      bridgeRegistrationError: bridgeErr,
-    });
-    // Populate compatibility info after a successful install.
-    try {
-      const serverPkg = path.resolve(
-        path.dirname(fileURLToPath(import.meta.url)),
-        "..",
-        "package.json",
+    const { detectLegacyManagedDir } = await import(
+      "@blackbelt-technology/pi-dashboard-shared/legacy-managed-dir.js"
+    );
+    const legacy = detectLegacyManagedDir();
+    if (legacy.present) {
+      console.log(
+        `[legacy] legacy install directory detected at ${legacy.path} ` +
+        `(${legacy.pkgCount} packages, ~${legacy.sizeMb} MB). No longer used — safe to delete.`,
       );
-      updateBootstrapCompatibility(server.bootstrapState, serverPkg);
-      logCompatibilityWarning(server.bootstrapState);
-    } catch (err) {
-      console.warn("[bootstrap] version-skew check failed (non-fatal):", err);
     }
-    console.log(
-      `[bootstrap] ready (installed ${res.installed.join(", ")}${bridgeErr ? `; bridge warning: ${bridgeErr}` : ""})`,
-    );
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[bootstrap] failed: ${message}`);
-    server.bootstrapState.set({
-      status: "failed",
-      error: { message },
-      progress: undefined,
-    });
+  } catch {
+    /* advisory only — never block startup */
   }
+
+  await server.start();
 }
 
+
 /**
  * Start the server as a detached background daemon.
  */
@@ -376,7 +249,6 @@ async function cmdStart(config: ServerConfig): Promise<void> {
       starter: "Standalone",
       healthTimeoutMs: 30_000,
       port: config.port,
-      env: { ...process.env },
     });
     const reportedPid = result.reportedPid ?? readPid() ?? result.childPid;
     console.log(`Dashboard server started (pid ${reportedPid}) at http://localhost:${config.port}`);
@@ -523,57 +395,6 @@ async function cmdRestartImpl(
 /**
  * Show server status.
  */
-/**
- * `pi-dashboard upgrade-pi` — upgrade pi-coding-agent via bootstrap.
- *
- * If a dashboard is currently running, POST to /api/bootstrap/upgrade-pi
- * (so the running server owns the install, broadcasts state, and reloads
- * connected sessions). Otherwise run `bootstrapInstall` directly with a
- * streaming progress formatter and exit when done.
- *
- * See change: unified-bootstrap-install §8.
- */
-async function cmdUpgradePi(config: ServerConfig): Promise<void> {
-  const status = await isDashboardRunning(config.port);
-  if (status.running) {
-    console.log(
-      `[upgrade-pi] dashboard running at http://localhost:${config.port}, delegating to server`,
-    );
-    try {
-      const res = await fetch(`http://localhost:${config.port}/api/bootstrap/upgrade-pi`, {
-        method: "POST",
-      });
-      if (!res.ok) {
-        const body = await res.text();
-        console.error(`[upgrade-pi] server rejected upgrade: HTTP ${res.status} ${body}`);
-        process.exit(1);
-      }
-      const body = (await res.json()) as { ticketId?: string };
-      console.log(`[upgrade-pi] queued (ticketId=${body.ticketId ?? "?"})`);
-      console.log("[upgrade-pi] progress is streamed to open dashboard tabs; CLI exits now.");
-      return;
-    } catch (err) {
-      console.error("[upgrade-pi] failed to reach server:", err);
-      process.exit(1);
-    }
-  }
-
-  console.log("[upgrade-pi] no dashboard running — installing directly");
-  const res = await bootstrapInstall({
-    packages: ["@earendil-works/pi-coding-agent"],
-    progress: (p) => {
-      const line = p.output
-        ? `[upgrade-pi] ${p.step} ${p.status}: ${p.output}`
-        : `[upgrade-pi] ${p.step} ${p.status}`;
-      console.log(line);
-    },
-  });
-  if (!res.ok) {
-    console.error(`[upgrade-pi] failed: ${res.error}`);
-    process.exit(1);
-  }
-  console.log(`[upgrade-pi] ✓ installed ${res.installed.join(", ")}`);
-}
 
 async function cmdStatus(port: number): Promise<void> {
   // 1. Try mDNS discovery first
@@ -665,9 +486,6 @@ async function main() {
     case "status":
       await cmdStatus(config.port);
       break;
-    case "upgrade-pi":
-      await cmdUpgradePi(config);
-      break;
     default:
       // No subcommand — run in foreground (backward compatible)
       await runForeground(config);

package/packages/server/src/event-status-extraction.ts

@@ -2,16 +2,12 @@
  * Extract session status/tool updates from forwarded events.
  * Returns partial DashboardSession updates, or null if the event is not relevant.
  */
-import type { DashboardEvent, DashboardSession, FlowStatus, SessionStatus } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import type { DashboardEvent, DashboardSession, SessionStatus } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 
 // Use null (not undefined) for fields that must be cleared — undefined is
 // dropped during JSON serialisation so the browser would keep the stale value.
 type SessionUpdates = Partial<Pick<DashboardSession, "status" | "model" | "thinkingLevel">> & {
   currentTool?: string | null;
-  activeFlowName?: string | null;
-  flowAgentsDone?: number;
-  flowAgentsTotal?: number;
-  flowStatus?: FlowStatus | null;
 };
 
 /**
@@ -83,54 +79,10 @@ export function extractSessionUpdates(event: DashboardEvent): SessionUpdates | n
       return null;
     }
 
-    // ── Flow events ──
-    case "flow_started": {
-      const d = event.data;
-      const steps = d.steps as Array<{ stepType: string }> | undefined;
-      const agentCount = steps?.filter(s => s.stepType === "agent").length ?? 0;
-      return {
-        activeFlowName: (d.flowName as string) ?? null,
-        flowAgentsTotal: agentCount,
-        flowAgentsDone: 0,
-        flowStatus: "running" as FlowStatus,
-      };
-    }
-
-    case "flow_agent_complete":
-      // Increment is handled by the caller — we return a marker
-      return { flowAgentsDone: -1 }; // sentinel: caller must increment
-
-    case "flow_complete": {
-      const result = event.data;
-      const status = (result.status as string) ?? "success";
-      return {
-        flowStatus: status as FlowStatus,
-      };
-    }
-
-    // ── Architect events ──
-    case "architect_started": {
-      const mode = (event.data.mode as string) || "new";
-      return {
-        activeFlowName: mode === "edit" ? "Editing flow..." : "Designing flow...",
-        flowStatus: "running" as FlowStatus,
-      };
-    }
-
-    case "flow_summary_dismissed": {
-      return {
-        activeFlowName: null,
-        flowStatus: null,
-      };
-    }
-
-    case "architect_complete":
-    case "architect_cancelled": {
-      return {
-        activeFlowName: null,
-        flowStatus: null,
-      };
-    }
+    // Flow / architect events are NOT extracted here. Per change
+    // pluginize-flows-via-registry, flows-plugin owns its own state
+    // derivation in the browser via useSessionEvents + plugin-internal
+    // contexts. The dashboard server has zero flow knowledge.
 
     default:
       return null;
@@ -164,16 +116,16 @@ const ACTIVITY_EVENT_TYPES: ReadonlySet<string> = new Set([
   "agent_end",
   // Bash command output
   "bash_output",
-  // Flow lifecycle / agent steps
-  "flow_started",
-  "flow_complete",
-  "flow_agent_started",
-  "flow_agent_complete",
-  // Architect (flow design) lifecycle
-  "architect_started",
-  "architect_complete",
-  "architect_cancelled",
 ]);
+// Note: flow / architect events used to live in this allowlist but the
+// classification of "is this user-visible activity?" is plugin business.
+// The plugin marks activity via its own session-state-derived signal
+// (e.g. lastActivityAt stamping based on flowState changes). For now,
+// the simpler tool/agent/message events are sufficient to keep
+// `lastActivityAt` accurate; if a flow that does no other tool calls
+// fails to bump activity, the user can re-add the events here behind a
+// generic predicate like `isPluginActivityEvent` exposed by plugin-runtime.
+// See change: pluginize-flows-via-registry.
 
 export function isActivityEvent(eventType: string): boolean {
   return ACTIVITY_EVENT_TYPES.has(eventType);

package/packages/server/src/event-wiring.ts

@@ -138,16 +138,15 @@ export function wireEvents(deps: EventWiringDeps): void {
 
   piGateway.onEvent = (sessionId, msg) => {
     if (msg.type === "event_forward") {
+      // Legacy queue_state event no longer emitted (bridge removed PromptQueue).
+      // See change: add-followup-edit-and-steer-cancel.
+      if (msg.event.eventType === "queue_state") return;
       // When canSkipWipe was true, the event store already has all events —
       // don't insert replayed events again (would cause exponential duplication)
       if (replayingSessions.has(sessionId) && skipReplayInsert.has(sessionId)) {
         // Still process status updates so session state stays accurate
         const updates = extractSessionUpdates(msg.event);
         if (updates) {
-          if (updates.flowAgentsDone === -1) {
-            const session = sessionManager.get(sessionId);
-            updates.flowAgentsDone = (session?.flowAgentsDone ?? 0) + 1;
-          }
           sessionManager.update(sessionId, updates as Partial<DashboardSession>);
         }
         // Skip insert + broadcast — events are already in store
@@ -173,10 +172,6 @@ export function wireEvents(deps: EventWiringDeps): void {
 
       const updates = extractSessionUpdates(msg.event);
       if (updates) {
-        if (updates.flowAgentsDone === -1) {
-          const session = sessionManager.get(sessionId);
-          updates.flowAgentsDone = (session?.flowAgentsDone ?? 0) + 1;
-        }
         sessionManager.update(sessionId, updates as Partial<DashboardSession>);
         // During replay, accumulate in sessionManager but don't broadcast
         // to avoid rapid status flickers on the session card
@@ -573,11 +568,29 @@ export function wireEvents(deps: EventWiringDeps): void {
           text: pendingResume.text,
           images: pendingResume.images,
         });
-        sessionManager.update(sessionId, { resuming: false });
-        browserGateway.broadcastSessionUpdated(sessionId, { resuming: false });
+        // Clear `resuming` on the OLD session that triggered the auto-resume,
+        // not the new session that just registered. The new session never had
+        // `resuming: true`; clearing it there was a no-op and left the old
+        // session permanently stuck. The 30s onTimeout was also cancelled by
+        // `consume()`, so without this fix the old session stays frozen forever.
+        sessionManager.update(pendingResume.oldSessionId, { resuming: false });
+        browserGateway.broadcastSessionUpdated(pendingResume.oldSessionId, { resuming: false });
       }
     }
 
+    // Pi's queue mirror (steer + follow-up) forwarded from the bridge.
+    // Caches `pendingQueues` on the session and broadcasts to subscribed browsers.
+    // See change: add-followup-edit-and-steer-cancel.
+    if (msg.type === "queue_update") {
+      const steering = Array.isArray(msg.steering) ? msg.steering : [];
+      const followUp = Array.isArray(msg.followUp) ? msg.followUp : [];
+      const update = { pendingQueues: { steering, followUp } } as Partial<DashboardSession>;
+      sessionManager.update(sessionId, update);
+      if (!replayingSessions.has(sessionId)) {
+        browserGateway.broadcastSessionUpdated(sessionId, update);
+      }
+      return;
+    }
     if (msg.type === "first_message_update") {
       sessionManager.update(sessionId, { firstMessage: msg.firstMessage });
       browserGateway.broadcastSessionUpdated(sessionId, { firstMessage: msg.firstMessage });

package/packages/server/src/memory-session-manager.ts

@@ -106,6 +106,10 @@ export function createMemorySessionManager(): SessionManager {
         firstMessage: params.firstMessage ?? existing?.firstMessage,
         dataUnavailable: false,
         pid: params.pid,
+        // Pi-native queue mirror: reset to empty on register / re-register;
+        // a fresh `queue_update` from the bridge populates it.
+        // See change: add-followup-edit-and-steer-cancel.
+        pendingQueues: { steering: [], followUp: [] },
       };
       sessions.set(params.id, session);
       mgr.onChange?.(params.id, {

package/packages/server/src/pi-core-checker.ts

@@ -92,7 +92,7 @@ export function _resetDynamicPiAliases(): void {
  * tooling if and only if its name is in `CORE_PACKAGE_NAMES` OR a
  * pi.dev-declared alias. The previous `pi-*` name-prefix heuristic was
  * removed because it caused recommended-extension packages (e.g.
- * `pi-agent-browser`, `@tintinweb/pi-subagents`) to appear in BOTH the
+ * `pi-agent-browser`, `pi-dashboard-subagents`) to appear in BOTH the
  * Core ecosystem panel and the Installed Packages panel. Recommended
  * extensions are now surfaced exclusively through
  * `/api/packages/installed`. See change: consolidate-packages-settings-ui.

package/packages/server/src/pi-dev-version-check.ts

@@ -1,6 +1,6 @@
 /**
  * pi.dev version-check client. Mirrors the implementation pi itself
- * uses for self-update checks (see `@mariozechner/pi-coding-agent/dist/
+ * uses for self-update checks (see `@earendil-works/pi-coding-agent/dist/
  * utils/version-check.js`). Returns `{ version, packageName? }` so the
  * dashboard can:
  *   1. Detect the genuinely-newest pi without npm-registry lag.

package/packages/server/src/pi-version-skew.ts

@@ -11,7 +11,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
-import type { BootstrapCompatibility, BootstrapStateStore } from "./bootstrap-state.js";
 import { getDefaultRegistry, type ToolRegistry } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
 
 /**
@@ -62,6 +61,30 @@ export function isAbove(version: string, threshold: string): boolean {
   return compareVersions(version, thresholdClean) > 0;
 }
 
+/**
+ * Pi version compatibility snapshot.
+ *
+ * Previously declared in `./bootstrap-state.js`; moved here under change:
+ * eliminate-electron-runtime-install (task 3.6) once the bootstrap-state
+ * store was removed. The shape stays stable so consumers (CLI version
+ * skew log, future UI version-skew banner for standalone arm) keep
+ * compiling.
+ */
+export interface BootstrapCompatibility {
+  /** Minimum pi version supported by this dashboard server. */
+  minimum: string;
+  /** Recommended pi version; below = soft warning, above = OK. */
+  recommended: string;
+  /** Maximum supported pi version, or `null` for unbounded. */
+  maximum: string | null;
+  /** Currently-resolved pi version (or `undefined` if pi unresolvable). */
+  current?: string;
+  /** Set when `current < recommended`. */
+  upgradeRecommended?: boolean;
+  /** Set when `current > maximum`. */
+  upgradeDashboard?: boolean;
+}
+
 /**
  * Read the server's declared compatibility range from its own package.json.
  * Falls back to the hard-coded defaults when the field is missing or
@@ -168,48 +191,3 @@ export function computeCompatibility(
   return out;
 }
 
-interface CacheEntry {
-  value: BootstrapCompatibility;
-  /** Milliseconds epoch when this entry should be discarded. */
-  expiresAt: number;
-}
-
-let cached: CacheEntry | undefined;
-const CACHE_TTL_MS = 60_000;
-
-/**
- * Convenience wrapper: read range + current version, compute result,
- * cache for 60 s. `store` is called with a structured compatibility
- * update and (when minimum is violated) a blocking `error` message.
- */
-export function updateBootstrapCompatibility(
-  store: BootstrapStateStore,
-  serverPkgJsonPath: string,
-  registry: ToolRegistry = getDefaultRegistry(),
-  now: () => number = Date.now,
-): BootstrapCompatibility {
-  const t = now();
-  if (cached && t < cached.expiresAt) {
-    store.set({ compatibility: cached.value });
-    return cached.value;
-  }
-  const range = readPiCompatibility(serverPkgJsonPath);
-  const current = readCurrentPiVersion(registry);
-  const computed = computeCompatibility(range, current);
-  cached = { value: computed, expiresAt: t + CACHE_TTL_MS };
-  store.set({ compatibility: computed });
-  // Minimum-violated → block pi-dependent ops by setting `error`.
-  if (current && isBelow(current, range.minimum)) {
-    store.set({
-      error: {
-        message: `pi version ${current} is below minimum ${range.minimum}. Please run \`pi-dashboard upgrade-pi\`.`,
-      },
-    });
-  }
-  return computed;
-}
-
-/** Test helper: clear the 60-second cache between runs. */
-export function _resetVersionSkewCache(): void {
-  cached = undefined;
-}