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

package/packages/server/src/routes/manifest-route.ts

@@ -0,0 +1,162 @@
+/**
+ * Dynamic /manifest.json route.
+ *
+ * Serves a PWA web-app manifest whose `name` and `short_name` vary by
+ * server identity, so the same dashboard installed as a PWA from multiple
+ * origins (LAN host, tunnel, loopback) shows distinct labels on the
+ * launcher. See change: add-dynamic-pwa-manifest-naming.
+ *
+ * Resolution order for the name `<source>`:
+ *   1. `config.dashboardName` (user override; trimmed)
+ *   2. Request `Host` header with port stripped (IPv6-safe)
+ *   3. `os.hostname()`
+ *   4. Literal `"Pi-Dash"`
+ *
+ * Final manifest fields:
+ *   name       = `Pi-Dash \u00b7 ${source}`
+ *   short_name = source.slice(0, 12)
+ *   id         = "/"
+ *
+ * All other fields (icons, theme/background color, display, start_url)
+ * are spread from the static `manifest.json` shipped in the client bundle.
+ *
+ * This route is registered BEFORE `@fastify/static` so explicit Fastify
+ * route matching wins over the on-disk static asset.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { FastifyInstance } from "fastify";
+
+/**
+ * Strip the trailing port from a Host header.
+ *
+ * Handles:
+ *   - bare hostnames (`mybox.local`)
+ *   - host:port (`mybox.local:8000`)
+ *   - bracketed IPv6 with port (`[::1]:8000`)
+ *   - bracketed IPv6 without port (`[::1]`)
+ *   - empty / undefined input → empty string
+ *
+ * Lower-cases the result so casing differences across requests don't
+ * produce ostensibly distinct labels.
+ */
+export function stripPort(host: string | undefined | null): string {
+  if (!host) return "";
+  const trimmed = host.trim();
+  if (!trimmed) return "";
+
+  // Bracketed IPv6: "[::1]" or "[::1]:8000"
+  if (trimmed.startsWith("[")) {
+    const close = trimmed.indexOf("]");
+    if (close > 0) return trimmed.slice(1, close).toLowerCase();
+    // Malformed — drop bracket, return as-is
+    return trimmed.slice(1).toLowerCase();
+  }
+
+  // host:port — last colon, but only if there's exactly one colon
+  // (bare IPv6 like "::1" has multiple colons; we leave it untouched
+  //  since unbracketed IPv6 in a Host header is non-conformant anyway).
+  const firstColon = trimmed.indexOf(":");
+  const lastColon = trimmed.lastIndexOf(":");
+  if (firstColon === lastColon && firstColon > 0) {
+    return trimmed.slice(0, firstColon).toLowerCase();
+  }
+  return trimmed.toLowerCase();
+}
+
+/**
+ * Resolve the `<source>` string used to build manifest `name` / `short_name`.
+ *
+ * Pure — no fs or process access. Pass `hostname` explicitly so tests can
+ * control it.
+ */
+export function resolveManifestSource(
+  hostHeader: string | undefined | null,
+  configDashboardName: string | undefined | null,
+  hostname: string,
+): string {
+  const override = (configDashboardName ?? "").trim();
+  if (override) return override;
+
+  const fromHost = stripPort(hostHeader);
+  if (fromHost) return fromHost;
+
+  const fromHostname = (hostname ?? "").trim();
+  if (fromHostname) return fromHostname;
+
+  return "Pi-Dash";
+}
+
+/**
+ * Build the dynamic manifest body. Spreads the static base, overrides
+ * `name`/`short_name`/`id`. Pure given a `staticBase`.
+ */
+export function buildManifestBody(
+  staticBase: Record<string, unknown>,
+  source: string,
+): Record<string, unknown> {
+  return {
+    ...staticBase,
+    id: "/",
+    name: `Pi-Dash \u00b7 ${source}`,
+    short_name: source.slice(0, 12) || "Pi-Dash",
+  };
+}
+
+/**
+ * Load the static manifest JSON shipped in the client bundle. Returns an
+ * empty object if missing or unparseable (route still serves a valid
+ * minimal manifest in that case).
+ *
+ * Synchronous + cached — manifest content is immutable per server build.
+ */
+export function loadStaticManifest(clientDir: string): Record<string, unknown> {
+  if (!clientDir) return {};
+  try {
+    const manifestPath = path.join(clientDir, "manifest.json");
+    if (!fs.existsSync(manifestPath)) return {};
+    const raw = fs.readFileSync(manifestPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+export interface ManifestRouteDeps {
+  /** Resolved client-dist directory (where the static manifest.json lives). */
+  clientDir: string;
+  /** Lazy accessor for the *latest* dashboard config — re-read per request
+   *  so Settings panel changes propagate without a server restart. */
+  getDashboardName: () => string | undefined;
+}
+
+/**
+ * Register `GET /manifest.json` on the given Fastify instance.
+ *
+ * MUST be called BEFORE `fastify.register(fastifyStatic, ...)`. Explicit
+ * routes win over the static plugin's fallback handler.
+ */
+export function registerManifestRoute(
+  fastify: FastifyInstance,
+  deps: ManifestRouteDeps,
+): void {
+  const staticBase = loadStaticManifest(deps.clientDir);
+  const hostname = os.hostname();
+
+  fastify.get("/manifest.json", async (request, reply) => {
+    const source = resolveManifestSource(
+      typeof request.headers.host === "string" ? request.headers.host : "",
+      deps.getDashboardName(),
+      hostname,
+    );
+    const body = buildManifestBody(staticBase, source);
+    reply.header("Content-Type", "application/manifest+json; charset=utf-8");
+    reply.header("Cache-Control", "no-cache, must-revalidate");
+    return body;
+  });
+}

package/packages/server/src/routes/openspec-routes.ts

@@ -30,16 +30,9 @@ export function registerOpenSpecRoutes(
     networkGuard: NetworkGuard;
     /** Optional — called after a successful toggle to trigger openspec_update. */
     onOpenSpecChanged?: OpenSpecBroadcaster;
-    /**
-     * Optional bootstrap state. When provided AND status !== "ready", the
-     * `/api/pi-resources` endpoint returns an empty result set with a
-     * `bootstrap` passthrough so the UI can render "pi not yet installed".
-     * See change: unified-bootstrap-install §5.4.
-     */
-    bootstrapState?: import("../bootstrap-state.js").BootstrapStateStore;
   },
 ) {
-  const { sessionManager, preferencesStore, directoryService, networkGuard, onOpenSpecChanged, bootstrapState } = deps;
+  const { sessionManager, preferencesStore, directoryService, networkGuard, onOpenSpecChanged } = deps;
 
   // OpenSpec archive listing endpoint
   fastify.get<{ Querystring: { cwd?: string } }>(
@@ -66,23 +59,9 @@ export function registerOpenSpecRoutes(
         reply.code(400);
         return { success: false, error: "cwd parameter required" } satisfies ApiResponse;
       }
-      // Bootstrap gate: during degraded-mode install, return empty result
-      // with a `bootstrap` field so the UI can render the "pi not yet
-      // installed" state. See change: unified-bootstrap-install §5.4.
-      if (bootstrapState) {
-        const bs = bootstrapState.get();
-        if (bs.status !== "ready") {
-          return {
-            success: true,
-            data: {
-              local: { extensions: [], skills: [], prompts: [] },
-              global: { extensions: [], skills: [], prompts: [] },
-              packages: [],
-              bootstrap: bs,
-            },
-          } satisfies ApiResponse;
-        }
-      }
+      // Bootstrap gate removed under change: eliminate-electron-runtime-install
+      // (task 3.5). pi/openspec/tsx ship as regular npm deps; pi-resources
+      // endpoint is unconditionally available.
       const forceRefresh = request.query.refresh === "true" || request.query.refresh === "1";
       let data = forceRefresh ? undefined : directoryService.getPiResources(cwd);
       if (!data) {

package/packages/server/src/routes/pi-changelog-routes.ts

@@ -5,10 +5,8 @@
  * a `(from, to]` half-open version range, plus a derived `hasBreaking`
  * flag and a public GitHub URL for the full changelog.
  *
- * Gated identically to other `/api/pi-core/*` routes via the shared
- * bootstrap-status gate.
- *
- * See change: pi-update-whats-new-panel.
+ * See change: pi-update-whats-new-panel. Bootstrap gate removed under
+ * change: eliminate-electron-runtime-install (task 3.5).
  */
 import type { FastifyInstance } from "fastify";
 import type {
@@ -33,11 +31,9 @@ import {
   fetchRemoteChangelog,
 } from "../changelog-remote.js";
 import type { ChangelogRelease } from "@blackbelt-technology/pi-dashboard-shared/changelog-types.js";
-import type { BootstrapStateStore } from "../bootstrap-state.js";
 
 export interface PiChangelogRouteDeps {
-  /** When provided, route returns 503 unless bootstrap status is "ready". */
-  bootstrapState?: BootstrapStateStore;
+  // Bootstrap gate field removed; route is unconditionally available.
 }
 
 interface QueryShape {
@@ -48,27 +44,12 @@ interface QueryShape {
 
 export function registerPiChangelogRoutes(
   fastify: FastifyInstance,
-  deps: PiChangelogRouteDeps,
+  _deps: PiChangelogRouteDeps,
 ): void {
-  const { bootstrapState } = deps;
-
-  const bootstrapGate = async (
-    _req: unknown,
-    reply: { code: (n: number) => { send: (body: unknown) => unknown } },
-  ): Promise<unknown> => {
-    if (!bootstrapState) return undefined;
-    const status = bootstrapState.get().status;
-    if (status === "ready") return undefined;
-    return reply.code(503).send({
-      success: false,
-      error: `pi not yet installed (bootstrap status: ${status})`,
-      bootstrap: status,
-    });
-  };
+
 
   fastify.get<{ Querystring: QueryShape }>(
     "/api/pi-core/changelog",
-    { preHandler: bootstrapGate as any },
     async (request, reply) => {
       const pkg = (request.query.pkg ?? "").trim();
       const from = (request.query.from ?? "").trim();

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

@@ -18,16 +18,10 @@ import type {
 import type { PiCoreChecker } from "../pi-core-checker.js";
 import type { PiCoreUpdater } from "../pi-core-updater.js";
 import { PackageOperationBusyError } from "../package-manager-wrapper.js";
-import type { BootstrapStateStore } from "../bootstrap-state.js";
 
 export interface PiCoreRouteDeps {
 	piCoreChecker: PiCoreChecker;
 	piCoreUpdater: PiCoreUpdater;
-	/**
-	 * When provided, pi-core endpoints return 503 unless bootstrap
-	 * status is "ready". See change: unified-bootstrap-install §5.5.
-	 */
-	bootstrapState?: BootstrapStateStore;
 	/**
 	 * Called after the updater finishes a batch (success or per-package failure).
 	 * The server wires this to broadcast a `pi_core_update_complete` WS message
@@ -44,28 +38,15 @@ export function registerPiCoreRoutes(
 	fastify: FastifyInstance,
 	deps: PiCoreRouteDeps,
 ): void {
-	const { piCoreChecker, piCoreUpdater, bootstrapState } = deps;
+	const { piCoreChecker, piCoreUpdater } = deps;
 
-	/** Gate: 503 unless bootstrap is ready. Returns undefined when OK to proceed. */
-	const bootstrapGate = async (
-		_req: unknown,
-		reply: { code: (n: number) => { send: (body: unknown) => unknown } },
-	): Promise<unknown> => {
-		if (!bootstrapState) return undefined;
-		const status = bootstrapState.get().status;
-		if (status === "ready") return undefined;
-		return reply.code(503).send({
-			success: false,
-			error: `pi not yet installed (bootstrap status: ${status})`,
-			bootstrap: status,
-		});
-	};
+	// bootstrapGate removed under change: eliminate-electron-runtime-install (task 3.5).
+	// pi-core endpoints are unconditionally available; pi ships as regular npm dep.
 
 	// ── GET /api/pi-core/versions ──────────────────────────────────
 
 	fastify.get<{ Querystring: { refresh?: string } }>(
 		"/api/pi-core/versions",
-		{ preHandler: bootstrapGate as any },
 		async (request) => {
 			const refresh = request.query.refresh === "true";
 			try {
@@ -81,7 +62,6 @@ export function registerPiCoreRoutes(
 
 	fastify.post<{ Body: PiCoreUpdateRequest }>(
 		"/api/pi-core/update",
-		{ preHandler: bootstrapGate as any },
 		async (request, reply) => {
 			const requested = request.body?.packages ?? [];
 

package/packages/server/src/routes/plugin-activation-routes.ts

@@ -0,0 +1,193 @@
+/**
+ * Plugin activation REST routes.
+ *
+ * GET  /api/plugins            — list every discovered plugin (manifest + status)
+ * POST /api/plugins/:id/toggle — body { enabled: boolean }; writes
+ *                                config.plugins.<id>.enabled, broadcasts
+ *                                plugin_config_update, returns
+ *                                { restartRequired: true } or 404.
+ *
+ * See change: add-plugin-activation-ui.
+ */
+import type { FastifyInstance } from "fastify";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import {
+  discoverPlugins,
+  getPluginStatusStore,
+  buildGraph,
+  computeToggleImpact,
+  transitiveDependents,
+} from "@blackbelt-technology/dashboard-plugin-runtime/server";
+import type { NetworkGuard } from "./route-deps.js";
+import type { ServerToBrowserMessage } from "@blackbelt-technology/pi-dashboard-shared/browser-protocol.js";
+
+// Resolved lazily so tests that override $HOME after import still work.
+function configPaths() {
+  const dir = path.join(os.homedir(), ".pi", "dashboard");
+  return { dir, file: path.join(dir, "config.json") };
+}
+
+function readRawConfig(): Record<string, unknown> {
+  try {
+    return JSON.parse(fs.readFileSync(configPaths().file, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeRawConfig(merged: Record<string, unknown>): void {
+  const { dir, file } = configPaths();
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = file + ".tmp." + process.pid;
+  fs.writeFileSync(tmp, JSON.stringify(merged, null, 2) + "\n");
+  fs.renameSync(tmp, file);
+}
+
+export function registerPluginActivationRoutes(
+  fastify: FastifyInstance,
+  deps: {
+    networkGuard: NetworkGuard;
+    broadcast: (msg: ServerToBrowserMessage) => void;
+    repoRoot?: string;
+  },
+) {
+  const { networkGuard, broadcast, repoRoot } = deps;
+
+  // GET /api/plugins — every discovered plugin's manifest summary + status.
+  fastify.get(
+    "/api/plugins",
+    { preHandler: networkGuard },
+    async (_request, reply) => {
+      const plugins = discoverPlugins(repoRoot);
+      const store = getPluginStatusStore();
+      const all = store.listAll();
+      const statusById = new Map(all.map((s) => [s.id, s] as const));
+
+      // Compute dependents per plugin for the cascade-impact preview UX.
+      // See change: add-plugin-activation-ui (Layer 2 — dependency graph).
+      const graph = buildGraph(
+        plugins.map((p) => ({
+          id: p.manifest.id,
+          dependsOn: p.manifest.dependsOn ?? [],
+        })),
+        () => true,
+      );
+
+      const rows = plugins.map((p) => {
+        const m = p.manifest;
+        const status = statusById.get(m.id);
+        const dependents = Array.from(transitiveDependents(graph, m.id)).sort();
+        return {
+          id: m.id,
+          displayName: m.displayName,
+          priority: m.priority ?? 1000,
+          hasServer: Boolean(p.serverEntryPath),
+          hasBridge: Boolean(p.bridgeEntryPath),
+          hasClient: Boolean(p.clientEntryPath),
+          claims: m.claims.map((c) => ({
+            slot: c.slot,
+            component: c.component,
+            tab: c.tab,
+            command: c.command,
+            toolName: c.toolName,
+          })),
+          requires: m.requires ?? null,
+          dependsOn: m.dependsOn ?? [],
+          dependents,
+          status: status ?? null,
+        };
+      });
+
+      return reply.status(200).send({ success: true, plugins: rows });
+    },
+  );
+
+  // POST /api/plugins/:id/toggle — write config.plugins.<id>.enabled.
+  //
+  // Honors dependency-graph cascade per Robert's add-plugin-activation-ui
+  // Layer 2: enabling cascades deps; disabling cascades dependents; enabling
+  // with a missing dep returns 409 with the blocker list.
+  fastify.post<{ Params: { id: string }; Body: { enabled?: boolean } }>(
+    "/api/plugins/:id/toggle",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const { id } = request.params;
+      const body = request.body ?? {};
+
+      if (typeof body.enabled !== "boolean") {
+        return reply
+          .status(400)
+          .send({ success: false, error: "body.enabled must be boolean" });
+      }
+
+      const plugins = discoverPlugins(repoRoot);
+      const found = plugins.find((p) => p.manifest.id === id);
+      if (!found) {
+        return reply
+          .status(404)
+          .send({ success: false, error: `Plugin "${id}" not found` });
+      }
+
+      const existing = readRawConfig();
+      const existingPlugins =
+        (existing.plugins as Record<string, unknown> | undefined) ?? {};
+
+      function isEnabled(pid: string): boolean {
+        const cfg = existingPlugins[pid] as Record<string, unknown> | undefined;
+        return cfg?.enabled !== false;
+      }
+
+      const graph = buildGraph(
+        plugins.map((p) => ({
+          id: p.manifest.id,
+          dependsOn: p.manifest.dependsOn ?? [],
+        })),
+        isEnabled,
+      );
+      const impact = computeToggleImpact(graph, id, body.enabled);
+
+      if (body.enabled && impact.blockers.length > 0) {
+        return reply
+          .status(409)
+          .send({ success: false, reason: "blockers", blockers: impact.blockers });
+      }
+
+      // Atomic cascade write: collect every id whose `enabled` flips, write
+      // them all in a single config write, then emit one plugin_config_update
+      // per affected id.
+      const flips: Array<{ id: string; enabled: boolean }> = [
+        { id, enabled: body.enabled },
+      ];
+      if (body.enabled) {
+        for (const dep of impact.cascadeEnable) flips.push({ id: dep, enabled: true });
+      } else {
+        for (const dep of impact.cascadeDisable) flips.push({ id: dep, enabled: false });
+      }
+
+      const nextPlugins: Record<string, unknown> = { ...existingPlugins };
+      const mergedPerId = new Map<string, Record<string, unknown>>();
+      for (const flip of flips) {
+        const prev = (nextPlugins[flip.id] as Record<string, unknown> | undefined) ?? {};
+        const merged = { ...prev, enabled: flip.enabled };
+        nextPlugins[flip.id] = merged;
+        mergedPerId.set(flip.id, merged);
+      }
+      writeRawConfig({ ...existing, plugins: nextPlugins });
+
+      for (const [flipId, merged] of mergedPerId) {
+        broadcast({ type: "plugin_config_update", id: flipId, config: merged });
+      }
+
+      return reply.status(200).send({
+        success: true,
+        restartRequired: true,
+        cascade: {
+          ...(body.enabled ? { enable: impact.cascadeEnable } : {}),
+          ...(!body.enabled ? { disable: impact.cascadeDisable } : {}),
+        },
+      });
+    },
+  );
+}

package/packages/server/src/routes/recommended-routes.ts

@@ -173,6 +173,24 @@ async function enrichEntry(
 		}
 	}
 
+	// Cross-reference companion dashboard plugin (Layer 1.5 of
+	// add-plugin-activation-ui). When the entry names a `dashboardPlugin`,
+	// look it up in the plugin status store so the install browser can show
+	// a "+plugin" badge that knows whether the plugin is currently present.
+	let dashboardPluginInstalled: boolean | undefined;
+	if (entry.dashboardPlugin) {
+		try {
+			const { getPluginStatusStore } = await import(
+				"@blackbelt-technology/dashboard-plugin-runtime/server"
+			);
+			dashboardPluginInstalled = Boolean(
+				getPluginStatusStore().getStatus(entry.dashboardPlugin),
+			);
+		} catch {
+			dashboardPluginInstalled = false;
+		}
+	}
+
 	return {
 		...entry,
 		description,
@@ -180,6 +198,9 @@ async function enrichEntry(
 		installed: { scope: installedScope },
 		activeInPi,
 		updateAvailable,
+		...(entry.dashboardPlugin
+			? { dashboardPluginInstalled: dashboardPluginInstalled ?? false }
+			: {}),
 	};
 }
 

package/packages/server/src/routes/system-routes.ts

@@ -22,9 +22,53 @@ import path from "node:path";
 import os from "node:os";
 import { localhostGuard, netmaskToCidrBits, networkAddress } from "../localhost-guard.js";
 import { readSpawnFailures } from "../spawn-failure-log.js";
-import { getPluginStatusStore } from "@blackbelt-technology/dashboard-plugin-runtime/server";
+import {
+  getPluginStatusStore,
+  discoverPlugins,
+  pluginRegistryHash,
+} from "@blackbelt-technology/dashboard-plugin-runtime/server";
+import { classifyBridgeSource } from "@blackbelt-technology/pi-dashboard-shared/plugin-bridge-register.js";
+import fs from "node:fs";
+import type { BridgeLoadSource, PluginStatus } from "@blackbelt-technology/pi-dashboard-shared/dashboard-plugin/plugin-status.js";
 import type { NetworkInterface } from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
-import type { BootstrapStateStore } from "../bootstrap-state.js";
+import { parseLaunchSource } from "@blackbelt-technology/pi-dashboard-shared/dashboard-starter.js";
+
+/**
+ * Enrich each plugin status with `bridgeLoadedFrom` by classifying the
+ * plugin's resolved bridge path against the live pi settings.json.
+ *
+ * Reads settings.json once per health call; cached `discoverPlugins()`
+ * result keeps the bridge path lookup O(1).
+ *
+ * See change: fix-pi-flows-end-to-end (Group 2, task 2.4).
+ */
+function enrichWithBridgeSource(statuses: PluginStatus[]): PluginStatus[] {
+  let settings: unknown = null;
+  try {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+    const p = path.join(home, ".pi", "agent", "settings.json");
+    if (fs.existsSync(p)) {
+      const raw = fs.readFileSync(p, "utf-8").trim();
+      if (raw) settings = JSON.parse(raw);
+    }
+  } catch {
+    settings = null;
+  }
+
+  const plugins = discoverPlugins();
+  const bridgePaths = new Map<string, string>();
+  for (const p of plugins) {
+    if (p.bridgeEntryPath) bridgePaths.set(p.manifest.id, p.bridgeEntryPath);
+  }
+
+  return statuses.map((s) => {
+    const bp = bridgePaths.get(s.id);
+    const bridgeLoadedFrom: BridgeLoadSource = bp
+      ? classifyBridgeSource(settings, bp)
+      : "none";
+    return { ...s, bridgeLoadedFrom };
+  });
+}
 
 export function registerSystemRoutes(
   fastify: FastifyInstance,
@@ -37,10 +81,9 @@ export function registerSystemRoutes(
     version?: string;
     directoryService?: DirectoryService;
     piGateway?: PiGateway;
-    bootstrapState?: BootstrapStateStore;
   },
 ) {
-  const { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version, directoryService, piGateway, bootstrapState } = deps;
+  const { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version, directoryService, piGateway } = deps;
 
   // Quiesce windows for the bridge `server_restarting` broadcast. See change
   // `fix-restart-bridge-auto-start-race`. Bridges that receive this message
@@ -233,10 +276,17 @@ export function registerSystemRoutes(
     return {
       ok: true,
       pid: process.pid,
-      starter: bootstrapState?.get().starter ?? "Standalone",
-      installable: bootstrapState?.get().installable,
+      // launchSource: single source of truth for arm-aware client gating
+      // (e.g. hide pi-core update UI under Electron, since bundled
+      // node_modules/ is read-only). See change:
+      // eliminate-electron-runtime-install task 3.2.
+      launchSource: parseLaunchSource(process.env),
       version: version ?? "unknown",
       uptime: Math.floor((Date.now() - serverStartTime) / 1000),
+      // ISO timestamp of process start. Used by the Plugins tab to detect
+      // server restarts and clear the Restart-required banner.
+      // See change: add-plugin-activation-ui.
+      startedAt: new Date(serverStartTime).toISOString(),
       mode: config.dev ? "dev" : "production",
       server: {
         rss: mem.rss,
@@ -246,7 +296,19 @@ export function registerSystemRoutes(
         totalSessions: sessionManager.listAll().length,
       },
       agents: agentMetrics,
-      plugins: getPluginStatusStore().listAll(),
+      plugins: enrichWithBridgeSource(getPluginStatusStore().listAll()),
+      // Build-time-vs-runtime plugin-bundle hash. Clients compare it to
+      // the embedded `PLUGIN_REGISTRY_HASH` to detect stale bundles.
+      // See change: fix-pi-flows-end-to-end (Group 6).
+      // Must hash over the SAME plugin set the vite-plugin used at build
+      // time — production builds exclude `fixture: true` plugins (e.g. demo).
+      // Without this filter, the runtime hash would differ from the embedded
+      // PLUGIN_REGISTRY_HASH and the staleness banner would always show.
+      bundleHash: pluginRegistryHash(
+        discoverPlugins().filter((p) =>
+          config.dev ? true : p.manifest.fixture !== true,
+        ),
+      ),
       proxy: getModelProxyStatus(),
     };
   });
@@ -276,13 +338,13 @@ export function registerSystemRoutes(
     "/api/electron/reextract",
     { preHandler: networkGuard },
     async (_request, reply) => {
-      const starter = bootstrapState?.get().starter ?? "Standalone";
-      if (starter !== "Electron") {
+      const launchSource = parseLaunchSource(process.env);
+      if (launchSource !== "electron") {
         reply.status(403);
         return {
           error: "reextract_not_allowed",
-          message: `Re-extract is only available when the server was started by Electron (current starter: ${starter})`,
-          starter,
+          message: `Re-extract is only available when the server was started by Electron (current launchSource: ${launchSource})`,
+          launchSource,
         };
       }
       reply.status(202);