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

package/packages/server/src/browser-handlers/session-action-handler.ts

@@ -19,6 +19,7 @@ import {
   findPidByMarker,
 } from "@blackbelt-technology/pi-dashboard-shared/platform/process-identify.js";
 import { shouldInterceptReload } from "./session-action-helpers.js";
+import { keeperOptsFromSpawnResult } from "../headless-pid-registry.js";
 
 /**
  * Status message + code emitted when fork is attempted on a session whose
@@ -176,7 +177,13 @@ export async function handleHeadlessReload(
   }
 
   if (spawnResult.pid && spawnResult.process) {
-    headlessPidRegistry.register(spawnResult.pid, session.cwd, spawnResult.process);
+    headlessPidRegistry.register(
+      spawnResult.pid,
+      session.cwd,
+      spawnResult.process,
+      spawnResult.spawnToken,
+      keeperOptsFromSpawnResult(spawnResult),
+    );
   }
 
   emitCommandFeedback(ctx, msg.sessionId, "completed");
@@ -235,7 +242,13 @@ export async function handleSendPrompt(
       pendingDashboardSpawns?.set(promptSession.cwd, (pendingDashboardSpawns?.get(promptSession.cwd) ?? 0) + 1);
     }
     if (spawnResult.process && spawnResult.pid) {
-      headlessPidRegistry.register(spawnResult.pid, promptSession.cwd, spawnResult.process);
+      headlessPidRegistry.register(
+        spawnResult.pid,
+        promptSession.cwd,
+        spawnResult.process,
+        spawnResult.spawnToken,
+        keeperOptsFromSpawnResult(spawnResult),
+      );
     }
   } else {
     const sent = piGateway.sendToSession(msg.sessionId, {
@@ -303,6 +316,7 @@ export async function handleResumeSession(
         session.cwd,
         degradeResult.process,
         degradeResult.spawnToken,
+        keeperOptsFromSpawnResult(degradeResult),
       );
     }
     if (msg.requestId && degradeResult.spawnToken && pendingClientCorrelations) {
@@ -364,7 +378,13 @@ export async function handleResumeSession(
     pendingDashboardSpawns?.set(session.cwd, (pendingDashboardSpawns?.get(session.cwd) ?? 0) + 1);
   }
   if (result.process && result.pid) {
-    headlessPidRegistry.register(result.pid, session.cwd, result.process, result.spawnToken);
+    headlessPidRegistry.register(
+      result.pid,
+      session.cwd,
+      result.process,
+      result.spawnToken,
+      keeperOptsFromSpawnResult(result),
+    );
   }
   sendTo(ws, { type: "resume_result", sessionId: msg.sessionId, success: result.success, message: result.message, requestId: msg.requestId });
 }
@@ -412,7 +432,13 @@ export async function handleSpawnSession(
   try {
     const spawnResult = await spawnPiSession(msg.cwd, { strategy });
     if (spawnResult.process && spawnResult.pid) {
-      headlessPidRegistry.register(spawnResult.pid, msg.cwd, spawnResult.process, spawnResult.spawnToken);
+      headlessPidRegistry.register(
+        spawnResult.pid,
+        msg.cwd,
+        spawnResult.process,
+        spawnResult.spawnToken,
+        keeperOptsFromSpawnResult(spawnResult),
+      );
     }
     // Record client-correlation so the eventual session_added carries
     // spawnRequestId. See change: spawn-correlation-token.

package/packages/server/src/cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node --import tsx
+#!/usr/bin/env node
 /**
  * PI Dashboard Server CLI
  *
@@ -17,11 +17,13 @@
  */
 import { createServer, type ServerConfig } from "./server.js";
 import { loadConfig, ensureConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
-import { spawn } from "@blackbelt-technology/pi-dashboard-shared/platform/exec.js";
-import { spawnNodeScript } from "@blackbelt-technology/pi-dashboard-shared/platform/node-spawn.js";
-import { createRequire } from "node:module";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import fs from "node:fs";
+import {
+  launchDashboardServer,
+  JitiNotFoundError,
+  PortConflictError,
+  EarlyExitError,
+} from "@blackbelt-technology/pi-dashboard-shared/server-launcher.js";
+import { fileURLToPath } from "node:url";
 import os from "node:os";
 import path from "node:path";
 import { readPid, removePid, isServerRunning } from "./server-pid.js";
@@ -42,7 +44,7 @@ export function findPortHolders(
 }
 import { isDashboardRunning } from "@blackbelt-technology/pi-dashboard-shared/server-identity.js";
 import { discoverDashboard } from "@blackbelt-technology/pi-dashboard-shared/mdns-discovery.js";
-import { resolveJitiImport } from "@blackbelt-technology/pi-dashboard-shared/resolve-jiti.js";
+
 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";
@@ -141,6 +143,7 @@ export function buildConfig(flags: Partial<ServerConfig>): ServerConfig {
     shutdownIdleSeconds: fileConfig.shutdownIdleSeconds,
     tunnel: flags.tunnel ?? fileConfig.tunnel.enabled,
     tunnelReservedToken: fileConfig.tunnel.reservedToken,
+    tunnelWatchdog: fileConfig.tunnel.watchdog,
     authConfig: fileConfig.auth,
     maxEventsPerSession: fileConfig.memoryLimits.maxEventsPerSession,
     maxStringFieldSize: fileConfig.memoryLimits.maxStringFieldSize,
@@ -252,7 +255,7 @@ async function runDegradedModeBootstrap(server: DashboardServer): Promise<void>
     return;
   }
 
-  const installPackages = ["@earendil-works/pi-coding-agent", "@fission-ai/openspec", "tsx"];
+  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({
@@ -351,7 +354,10 @@ async function cmdStart(config: ServerConfig): Promise<void> {
     process.exit(1);
   }
 
-  // Spawn ourselves in foreground mode (no subcommand) as a detached process
+  // Spawn ourselves in foreground mode (no subcommand) as a detached process.
+  // All concerns below — jiti loader resolution, --import argv URL-wrapping,
+  // env merge, log-file header, readiness polling, port-conflict / early-exit
+  // detection — are owned by the shared `launchDashboardServer` primitive.
   const cliPath = fileURLToPath(import.meta.url);
   const args: string[] = [];
   if (config.port !== 8000) args.push("--port", String(config.port));
@@ -359,83 +365,39 @@ async function cmdStart(config: ServerConfig): Promise<void> {
   if (config.dev) args.push("--dev");
   if (!config.tunnel) args.push("--no-tunnel");
 
-  let tsLoader: string;
-  try {
-    tsLoader = resolveJitiImport();
-  } catch {
-    // Fallback to tsx when jiti is not available (e.g. running outside pi).
-    // The loader is passed to `node --import`; on Windows, Node >= 20 rejects
-    // raw absolute paths with a drive letter (parsed as URL scheme), so we
-    // return a file:// URL. See change: fix-windows-server-parity.
-    try {
-      const tsxMain = createRequire(cliPath).resolve("tsx");
-      const tsxLoaderPath = path.join(path.dirname(tsxMain), "esm", "index.mjs");
-      tsLoader = pathToFileURL(tsxLoaderPath).href;
-    } catch {
-      console.error(
-        "[pi-dashboard] Cannot find TypeScript loader. " +
-        "Install tsx (`npm install`) or run inside a pi session."
-      );
-      process.exit(1);
-    }
-  }
-
-  // Redirect daemon stdout/stderr to a log file for crash diagnosis.
-  // Log is opened in append mode ("a") so output from prior start attempts
-  // is preserved across retries — critical for diagnosing intermittent or
-  // silent launch failures. A timestamped header line distinguishes runs.
-  // See change: fix-windows-server-parity.
   const logDir = path.join(os.homedir(), ".pi", "dashboard");
-  fs.mkdirSync(logDir, { recursive: true });
   const logPath = path.join(logDir, "server.log");
-  const logFd = fs.openSync(logPath, "a");
-  fs.writeSync(
-    logFd,
-    `\n[${new Date().toISOString()}] pi-dashboard start (parent pid ${process.pid}, port ${config.port})\n`,
-  );
-
-  // Both tsLoader and cliPath are wrapped as file:// URLs by spawnNodeScript.
-  // Required on Windows for node --import (see change: fix-windows-entry-script-url).
-  const child = spawnNodeScript({
-    loader: tsLoader,
-    entry: cliPath,
-    args,
-    spawnOptions: {
-      detached: true,
-      stdio: ["ignore", logFd, logFd],
+
+  try {
+    const result = await launchDashboardServer({
+      cliPath,
+      extraArgs: args,
+      stdio: { logFile: logPath },
+      starter: "Standalone",
+      healthTimeoutMs: 30_000,
+      port: config.port,
       env: { ...process.env },
-    },
-  });
-  child.unref();
-  // Close the parent's copy of the fd — child has its own via stdio inheritance.
-  try { fs.closeSync(logFd); } catch { /* ignore */ }
-
-  // Wait for dashboard to become available. Windows + jiti cold-start can
-  // take 10s+ (TS compile on first boot, native module loads). 30s is the
-  // outer bound — if the server isn't up by then, something's genuinely wrong.
-  const READINESS_TIMEOUT_MS = 30_000;
-  const deadline = Date.now() + READINESS_TIMEOUT_MS;
-  let started = false;
-  while (Date.now() < deadline) {
-    // Also bail if the child has already exited (fast-path crash detection).
-    if (child.exitCode !== null) break;
-    await new Promise((r) => setTimeout(r, 300));
-    const status = await isDashboardRunning(config.port);
-    if (status.running) {
-      started = true;
-      break;
+    });
+    const reportedPid = result.reportedPid ?? readPid() ?? result.childPid;
+    console.log(`Dashboard server started (pid ${reportedPid}) at http://localhost:${config.port}`);
+  } catch (err: unknown) {
+    if (err instanceof JitiNotFoundError) {
+      console.error(`[pi-dashboard] ${err.message}`);
+      process.exit(1);
     }
-  }
-
-  if (started) {
-    const pid = readPid();
-    console.log(`Dashboard server started (pid ${pid ?? child.pid}) at http://localhost:${config.port}`);
-  } else {
-    const reason = child.exitCode !== null
-      ? `child process exited with code ${child.exitCode}`
-      : `timed out after ${READINESS_TIMEOUT_MS / 1000}s`;
+    if (err instanceof PortConflictError) {
+      console.error(`Port ${err.port} is occupied by another service (not the dashboard).`);
+      console.error(`Change the port in ~/.pi/dashboard/config.json or use --port <n>`);
+      process.exit(1);
+    }
+    if (err instanceof EarlyExitError) {
+      console.error(`Failed to start dashboard server (child process exited with code ${err.code})`);
+      console.error(`Check logs at ${logPath}`);
+      process.exit(1);
+    }
+    const reason = err instanceof Error ? err.message : String(err);
     console.error(`Failed to start dashboard server (${reason})`);
-    console.error(`Check logs at ${path.join(logDir, "server.log")}`);
+    console.error(`Check logs at ${logPath}`);
     process.exit(1);
   }
 }
@@ -666,7 +628,25 @@ async function cmdStatus(port: number): Promise<void> {
   console.log(`Dashboard server is running (pid ${pid}) on port ${port}`);
 }
 
+/**
+ * Install process-level safety net so a single misbehaving plugin or
+ * library cannot kill the whole dashboard. Logs the offending error and
+ * keeps the event loop running. We do NOT exit; the surrounding daemon
+ * harness already restarts on real crashes (signal/exit-code), and
+ * silently swallowing recoverable async faults is the lesser evil here.
+ */
+function installCrashSafetyNet(): void {
+  process.on("unhandledRejection", (reason: unknown) => {
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    console.error("[crash-safety] unhandledRejection (suppressed):", err.stack || err.message);
+  });
+  process.on("uncaughtException", (err: Error) => {
+    console.error("[crash-safety] uncaughtException (suppressed):", err.stack || err.message);
+  });
+}
+
 async function main() {
+  installCrashSafetyNet();
   ensureConfig();
 
   const { subcommand, flags } = parseArgs(process.argv.slice(2));

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

@@ -5,6 +5,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { loadConfig, type DashboardConfig, type AuthConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import { refreshModelRegistry } from "./model-proxy/registry-singleton.js";
 
 const REDACTED = "***";
 
@@ -114,9 +115,17 @@ export function writeConfigPartial(partial: Record<string, any>): WriteConfigRes
       partial.auth = mergedAuth;
     }
 
-    // Merge tunnel sub-object
+    // Merge tunnel sub-object (deep-merge nested watchdog)
     if (partial.tunnel) {
-      partial.tunnel = { ...existing.tunnel, ...partial.tunnel };
+      const existingTunnel = existing.tunnel ?? {};
+      const mergedWatchdog = partial.tunnel.watchdog
+        ? { ...(existingTunnel.watchdog ?? {}), ...partial.tunnel.watchdog }
+        : existingTunnel.watchdog;
+      partial.tunnel = {
+        ...existingTunnel,
+        ...partial.tunnel,
+        ...(mergedWatchdog ? { watchdog: mergedWatchdog } : {}),
+      };
     }
 
     // Merge memoryLimits sub-object
@@ -139,6 +148,9 @@ export function writeConfigPartial(partial: Record<string, any>): WriteConfigRes
     fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(file, JSON.stringify(merged, null, 2) + "\n");
 
+    // Eager-refresh model proxy registry (config may affect proxy settings).
+    refreshModelRegistry().catch(() => {});
+
     return { success: true, restartRequired };
   } catch (err: any) {
     return { success: false, restartRequired: false, error: err.message };

package/packages/server/src/directory-service.ts

@@ -76,6 +76,23 @@ export function hasOpenSpecDir(cwd: string): boolean {
   }
 }
 
+/**
+ * `true` iff `<cwd>/openspec/` exists and is a directory. Strictly weaker than
+ * `hasOpenSpecDir` (which also requires the `changes/` subdir). Used by the
+ * WS on-connect snapshot to emit the new `hasOpenspecDir` field on every
+ * payload so freshly-initialized projects without `changes/` yet still surface
+ * the OPENSPEC subcard as an init/attach affordance on the client.
+ *
+ * See change: auto-hide-empty-session-subcards.
+ */
+export function hasOpenSpecRoot(cwd: string): boolean {
+  try {
+    return fs.statSync(path.join(cwd, "openspec")).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
 export interface DirectoryService {
   knownDirectories(): string[];
   discoverSessions(cwd: string): DiscoveredSession[];
@@ -199,12 +216,25 @@ function emptyDirCache(): DirCache {
   return { listMtimeMs: undefined, listResult: undefined, changes: new Map(), data: undefined };
 }
 
+export interface DirectoryServiceOptions {
+  /**
+   * Optional async post-processor applied to `OpenSpecData` after
+   * `buildOpenSpecData` and before caching. Used to inject the per-cwd
+   * `groupId` join from the OpenSpec change-grouping store.
+   * Errors propagate as a logged warning + the unenriched data.
+   * See change: add-openspec-change-grouping.
+   */
+  enrichOpenSpecData?: (cwd: string, data: OpenSpecData) => Promise<OpenSpecData> | OpenSpecData;
+}
+
 export function createDirectoryService(
   preferencesStore: PreferencesStore,
   sessionManager: SessionManager,
   initialConfig?: Partial<OpenSpecPollConfig>,
+  options: DirectoryServiceOptions = {},
 ): DirectoryService {
   let cfg: OpenSpecPollConfig = { ...DEFAULT_OPENSPEC_POLL, ...(initialConfig ?? {}) };
+  const enrichOpenSpecData = options.enrichOpenSpecData;
 
   const caches = new Map<string, DirCache>();
   const piResourcesCache = new Map<string, PiResourcesResult>();
@@ -261,12 +291,22 @@ export function createDirectoryService(
     const cache = caches.get(cwd) ?? emptyDirCache();
     const gateEnabled = cfg.changeDetection === "mtime" && !force;
 
+    const openspecRoot = path.join(cwd, "openspec");
     const changesRoot = path.join(cwd, "openspec", "changes");
+    // `hasOpenspecDir` is strictly weaker than `initialized`: it's true when
+    // the project is OpenSpec-initialized (`openspec/` dir exists) even if no
+    // proposals are authored yet (no `openspec/changes/` subdir). The session
+    // card visibility gate uses this signal so a fresh `openspec init` project
+    // still shows the OPENSPEC subcard as an init/attach affordance.
+    // See change: auto-hide-empty-session-subcards.
+    const hasOpenspecDir = statMtimeOr(openspecRoot) !== undefined;
     const rootMtime = statMtimeOr(changesRoot);
 
-    // If the directory doesn't exist, short-circuit (matches old behavior).
+    // If the changes/ subdirectory doesn't exist, short-circuit (matches old
+    // behavior re: list polling). `hasOpenspecDir` still carries the broader
+    // "is this an OpenSpec project?" signal for the client.
     if (rootMtime === undefined) {
-      const empty: OpenSpecData = { initialized: false, changes: [] };
+      const empty: OpenSpecData = { initialized: false, changes: [], hasOpenspecDir };
       cache.data = empty;
       cache.listMtimeMs = undefined;
       cache.listResult = undefined;
@@ -294,7 +334,7 @@ export function createDirectoryService(
     if (!listCacheValid) {
       const raw = await semaphore.run(() => runOpenSpecList(cwd));
       if (!raw || !Array.isArray(raw.changes)) {
-        const empty: OpenSpecData = { initialized: false, changes: [] };
+        const empty: OpenSpecData = { initialized: false, changes: [], hasOpenspecDir };
         cache.data = empty;
         cache.listMtimeMs = rootMtime;
         cache.listResult = undefined;
@@ -377,12 +417,30 @@ export function createDirectoryService(
     }));
 
     // ── Step 3: build + cache + return ──
-    const data = buildOpenSpecData(
+    let data = buildOpenSpecData(
       { changes: listResult ?? [] },
       statusResults,
       createFsProbeFactory(cwd),
       createFsSpecsProbeFactory(cwd),
     );
+    // `hasOpenspecDir` is true here by definition: we only reach Step 3 when
+    // `<cwd>/openspec/changes/` exists, which implies `<cwd>/openspec/` exists.
+    // See change: auto-hide-empty-session-subcards.
+    data = { ...data, hasOpenspecDir };
+    if (enrichOpenSpecData) {
+      try {
+        data = await enrichOpenSpecData(cwd, data);
+      } catch (err) {
+        // Don\'t fail the whole poll if the enricher (e.g. group-store read)
+        // throws — log and continue with the unenriched data. See change:
+        // add-openspec-change-grouping.
+        // eslint-disable-next-line no-console
+        if (typeof process !== "undefined" && /pi-dashboard|openspec-poll/.test(process.env?.DEBUG ?? "")) {
+          // eslint-disable-next-line no-console
+          console.warn(`[directory-service] enrichOpenSpecData(${cwd}) threw:`, err);
+        }
+      }
+    }
 
     // Stamp the cache with the pre-call mtime — i.e. the mtime that
     // demonstrably reflects the file state observed by the CLI. Skip racy
@@ -401,6 +459,20 @@ export function createDirectoryService(
   }
 
   async function refreshOpenSpec(cwd: string): Promise<OpenSpecData> {
+    // Master gate: when `openspec.enabled` is false, every refresh path is a
+    // no-op. Return the cleared-state shape so callers (including
+    // `openspec_refresh` browser handler) converge to the disabled UX.
+    // See change: auto-hide-empty-session-subcards.
+    if (cfg.enabled === false) {
+      // Disabled state: `hasOpenspecDir: false` ensures the client wrapper
+      // hides the OPENSPEC subcard for every cwd. See change:
+      // auto-hide-empty-session-subcards.
+      const cleared: OpenSpecData = { initialized: false, pending: false, changes: [], hasOpenspecDir: false };
+      const cache = caches.get(cwd) ?? emptyDirCache();
+      cache.data = cleared;
+      caches.set(cwd, cache);
+      return cleared;
+    }
     try {
       // User-initiated refresh bypasses the gate. The gate is heuristic; the
       // CLI is authoritative. When the user clicks the OpenSpec refresh icon
@@ -422,6 +494,15 @@ export function createDirectoryService(
   }
 
   async function pollDirectoryGated(cwd: string): Promise<OpenSpecData> {
+    // Master gate: when `openspec.enabled` is false, never spawn a CLI for the
+    // periodic poll path either. See change: auto-hide-empty-session-subcards.
+    if (cfg.enabled === false) {
+      const cleared: OpenSpecData = { initialized: false, pending: false, changes: [], hasOpenspecDir: false };
+      const cache = caches.get(cwd) ?? emptyDirCache();
+      cache.data = cleared;
+      caches.set(cwd, cache);
+      return cleared;
+    }
     return pollOne(cwd, false);
   }
 
@@ -439,6 +520,9 @@ export function createDirectoryService(
   let openspecTickInFlight = false;
   async function scheduleOpenSpecTick() {
     if (openspecTickInFlight) return;
+    // Master gate: when `openspec.enabled` is false, the tick is a no-op.
+    // No CLI spawns. See change: auto-hide-empty-session-subcards.
+    if (cfg.enabled === false) return;
     openspecTickInFlight = true;
     const tickStart = Date.now();
     let spawnsBefore = 0;
@@ -542,12 +626,30 @@ export function createDirectoryService(
 
     reconfigurePolling(newCfg: OpenSpecPollConfig) {
       const oldInterval = cfg.pollIntervalSeconds;
+      const wasEnabled = cfg.enabled;
       cfg = { ...newCfg };
       semaphore.setMax(cfg.maxConcurrentSpawns);
       // Only re-install timers if they were running and the interval actually changed.
       if (pollTimer && oldInterval !== cfg.pollIntervalSeconds) {
         installTimers();
       }
+      // On the `true → false` transition, clear every per-cwd `OpenSpecData`
+      // cache and notify the broadcast channel so connected browsers converge
+      // to the disabled-state shape. The `false → true` transition is a
+      // no-op here — the next regular poll tick will re-populate caches.
+      // See change: auto-hide-empty-session-subcards.
+      if (wasEnabled !== false && cfg.enabled === false) {
+        const cleared: OpenSpecData = { initialized: false, pending: false, changes: [], hasOpenspecDir: false };
+        for (const [cwd, cache] of caches.entries()) {
+          cache.data = cleared;
+          caches.set(cwd, cache);
+          try {
+            onChangeCallback?.(cwd, cleared);
+          } catch (err) {
+            console.warn(`[openspec-poll] onChange after disable failed for ${cwd}:`, err);
+          }
+        }
+      }
     },
 
     async onDirectoryAdded(cwd: string): Promise<DirectoryAddedResult> {

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

@@ -19,6 +19,8 @@ import type { DashboardSession } from "@blackbelt-technology/pi-dashboard-shared
 import { detectOpenSpecActivity, isValidOpenSpecChangeSlug } from "@blackbelt-technology/pi-dashboard-shared/openspec-activity-detector.js";
 import { extractTurnStats } from "@blackbelt-technology/pi-dashboard-shared/stats-extractor.js";
 import { attachRenameTarget, isNameAutoSetFromAttachment } from "./proposal-attach-naming.js";
+import { handleDispatchExtensionCommand } from "./rpc-keeper/dispatch-router.js";
+import { keeperOptsFromSpawnResult } from "./headless-pid-registry.js";
 
 export interface EventWiringDeps {
   sessionManager: SessionManager;
@@ -811,7 +813,13 @@ export function wireEvents(deps: EventWiringDeps): void {
     if (msg.type === "spawn_new_session") {
       spawnPiSession(msg.cwd, { strategy: loadConfig().spawnStrategy }).then((result) => {
         if (result.process && result.pid) {
-          browserGateway.headlessPidRegistry.register(result.pid, msg.cwd, result.process);
+          browserGateway.headlessPidRegistry.register(
+            result.pid,
+            msg.cwd,
+            result.process,
+            result.spawnToken,
+            keeperOptsFromSpawnResult(result),
+          );
         }
         browserGateway.broadcastToAll({
           type: "spawn_result",
@@ -862,5 +870,27 @@ export function wireEvents(deps: EventWiringDeps): void {
       });
     }
 
+    // RPC keeper dispatch: bridge → server slash command forward.
+    // Fire-and-forget; the handler itself emits browser-bound
+    // `command_feedback` events on success and on every failure path.
+    // The terminal event is persisted via eventStore.insertEvent so it
+    // survives browser reattach (otherwise the chat pill stays "in progress").
+    // See change: add-rpc-stdin-dispatch-with-keeper-sidecar (Phase 8).
+    if (msg.type === "dispatch_extension_command") {
+      void handleDispatchExtensionCommand(msg, {
+        headlessPidRegistry: browserGateway.headlessPidRegistry,
+        emitCommandFeedback: (sid, command, status, message) => {
+          const event = {
+            eventType: "command_feedback",
+            timestamp: Date.now(),
+            data: message === undefined ? { command, status } : { command, status, message },
+          };
+          const seq = eventStore.insertEvent(sid, event);
+          const stored = eventStore.getEvent(sid, seq) ?? event;
+          browserGateway.broadcastEvent(sid, seq, stored);
+        },
+      });
+    }
+
   };
 }