@blackbelt-technology/pi-agent-dashboard 0.2.2 → 0.2.4

package/AGENTS.md

@@ -56,7 +56,7 @@ make clean              # Destroy all cloned VMs
 | File | Purpose |
 |------|---------|
 | `src/shared/protocol.ts` | Extension↔Server WebSocket messages |
-| `src/shared/browser-protocol.ts` | Server↔Browser WebSocket messages |
+| `src/shared/browser-protocol.ts` | Server↔Browser WebSocket messages (all message types including PromptBus `prompt_request`/`prompt_dismiss`/`prompt_cancel` must be in the `ServerToBrowserMessage` union — `as any` switch cases are stripped by esbuild in production) |
 | `src/shared/types.ts` | Data models (Session, Workspace, Event) |
 | `src/shared/config.ts` | Shared config loader (`~/.pi/dashboard/config.json`) |
 | `src/extension/bridge.ts` | Main extension entry point (composes sync/tracker/flow modules, tracks `isAgentStreaming` in persistent BridgeState) |
@@ -157,7 +157,11 @@ make clean              # Destroy all cloned VMs
 | `src/client/hooks/useAuthStatus.ts` | Client auth status hook and login redirect helper |
 | `src/server/localhost-guard.ts` | Network access guard: `createNetworkGuard` (loopback/trusted/authenticated), `isBypassedHost` (CIDR/wildcard/exact), netmask-to-CIDR helpers |
 | `src/server/server-pid.ts` | PID file management for daemon mode |
-| `src/client/components/ServerSelector.tsx` | Server selector dropdown for switching between discovered dashboard servers |
+| `src/client/components/ServerSelector.tsx` | Server selector dropdown showing persisted known servers with availability probing |
+| `src/client/components/KnownServersSection.tsx` | Settings section: list/add/remove persisted known remote servers |
+| `src/client/components/NetworkDiscoverySection.tsx` | Settings section: mDNS network scan with "Add" action and label prompt |
+| `src/client/lib/known-servers-api.ts` | Client-side fetch helpers for known servers CRUD and discovery endpoints |
+| `src/server/routes/known-servers-routes.ts` | REST routes: known servers CRUD, on-demand mDNS discovery scan |
 | `src/server/terminal-manager.ts` | PTY lifecycle, ring buffer, spawn/attach/kill terminals |
 | `src/server/terminal-gateway.ts` | Binary WebSocket upgrade handler for `/ws/terminal/:id` |
 | `scripts/fix-pty-permissions.cjs` | Postinstall: fix node-pty spawn-helper execute permissions |
@@ -202,8 +206,8 @@ make clean              # Destroy all cloned VMs
 | `src/client/hooks/useZoomPan.ts` | Reusable zoom/pan hook (wheel, drag, pinch, buttons) |
 | `src/client/hooks/useMessageHandler.ts` | WebSocket message dispatch hook (extracted from App.tsx) |
 | `src/client/hooks/useSessionActions.ts` | Session action callbacks hook (send, abort, resume, spawn, etc.) |
-| `src/client/hooks/useOpenSpecActions.ts` | OpenSpec action callbacks hook (refresh, archive, attach, detach) |
-| `src/client/hooks/useContentViews.ts` | Content view state + fetch (pi resources, readme, file preview) |
+| `src/client/hooks/useOpenSpecActions.ts` | OpenSpec action callbacks hook (refresh, archive, attach, detach); calls `clearAllContentViews` before opening preview |
+| `src/client/hooks/useContentViews.ts` | Content view state + fetch (pi resources, readme, file preview); `clearAll()` resets all hook-owned states; `onBeforeOpen` callback for cross-component clearing |
 | `src/client/lib/event-reducer.ts` | Event-sourced state reducer (delegates flow events to flow-reducer); extracts LLM errors from `agent_end` into `lastError` |
 | `src/client/hooks/usePendingPromptTimeout.ts` | 30-second safety timeout for stuck `pendingPrompt` spinners |
 | `src/client/lib/flow-reducer.ts` | Flow state machine: all flow_* event handling |
@@ -262,7 +266,7 @@ make clean              # Destroy all cloned VMs
 | `packages/electron/scripts/test-electron-install.sh` | Full e2e Docker test: install, wizard, server launch, health check |
 | `packages/electron/scripts/test-electron-install-inner.sh` | Inner test script run inside Docker container |
 | `packages/electron/resources/icon.png` | Master 1024×1024 app icon (π on dark navy) |
-| `.github/workflows/electron-build.yml` | CI: builds DMG (macOS), DEB+AppImage (Linux), NSIS (Windows) on native runners |
+| `.github/workflows/publish.yml` | CI: builds DMG (macOS), DEB+AppImage (Linux), NSIS+ZIP+portable (Windows) on native runners; publishes npm + GitHub Release |
 
 ## Build & Restart Workflow
 

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Csakany
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -428,7 +428,7 @@ curl -X POST http://localhost:8000/api/restart -H 'Content-Type: application/jso
 src/
 ├── shared/           # Shared TypeScript types
 │   ├── protocol.ts        # Extension ↔ Server messages
-│   ├── browser-protocol.ts # Server ↔ Browser messages
+│   ├── browser-protocol.ts # Server ↔ Browser messages (incl. PromptBus types)
 │   ├── types.ts           # Data models
 │   ├── config.ts          # Shared config loader
 │   └── rest-api.ts        # REST API types
@@ -534,7 +534,7 @@ Output by platform:
 |----------|--------|----------|
 | macOS | `.dmg` | `packages/electron/out/make/` |
 | Linux | `.deb` + `.AppImage` | `packages/electron/out/make/` |
-| Windows | `.exe` (NSIS installer) | `packages/electron/out/make/` |
+| Windows | `.exe` (NSIS installer) + `.zip` + portable `.exe` | `packages/electron/out/make/` |
 
 ### Cross-Platform Builds (via Docker)
 

package/docs/architecture.md

@@ -34,7 +34,8 @@ A global pi extension that runs in every pi session. It:
 - Routes `ctx.ui` dialog methods (confirm, select, input, editor, notify) through `PromptBus` (`prompt-bus.ts`)
   - Adapters register to handle prompts: `DashboardDefaultAdapter` renders generic dialogs inline; extensions (e.g. pi-flows) can register custom adapters via `prompt:register-adapter` event
   - First-response-wins: multiple adapters (TUI, dashboard, custom) can claim a prompt; the first to respond resolves it, others are dismissed
-  - Bridge emits `prompt:ctx-originals` so TUI adapters can capture original ctx.ui methods before patching
+  - Bridge's TUI adapter is registered inline (captures original `ctx.ui` methods before patching) and presents prompts in the terminal with AbortController-based cancellation
+  - Patched `ctx.ui` methods forward the `message` field (from opts) via `metadata` in the PromptBus request
   - Client-side `prompt-component-registry.ts` maps component type strings to render placement (inline, widget-bar, overlay)
   - Protocol messages: `prompt_request`, `prompt_dismiss`, `prompt_cancel`, `prompt_response`
 
@@ -78,7 +79,7 @@ A React-based responsive web UI that:
 ### 4. Shared Types (`src/shared/`)
 TypeScript type definitions shared across all components:
 - `protocol.ts` - Extension↔Server WebSocket messages
-- `browser-protocol.ts` - Server↔Browser WebSocket messages
+- `browser-protocol.ts` - Server↔Browser WebSocket messages (includes PromptBus messages: `prompt_request`, `prompt_dismiss`, `prompt_cancel`)
 - `types.ts` - Data models (Session, Workspace, Event, etc.)
 
 ## Data Flow
@@ -113,9 +114,15 @@ TypeScript type definitions shared across all components:
 - Adapters return custom `PromptClaim` with arbitrary component types (e.g. `"architect-prompt"`)
 - Client-side registry maps type strings to render placement; unknown types fall back to `"generic-dialog"`
 
+**Message passthrough:**
+- The `message` field from `ask_user` tool (and other `ctx.ui` callers) is forwarded via `metadata.message` in the PromptBus request, through the `prompt_request` protocol message, and extracted by the client into the interactive renderer's `params.message`.
+
+**Type safety:**
+- `prompt_request`, `prompt_dismiss`, and `prompt_cancel` **must** be in the `ServerToBrowserMessage` union in `browser-protocol.ts`. If they are only handled via `case "..." as any:` in switch statements, esbuild's dead-code elimination will strip the handlers in production builds, silently breaking the interactive UI.
+
 **Resilience:**
-- **Page refresh**: Server replays pending `prompt_request` messages when a browser subscribes.
-- **Server restart**: TODO — PromptBus reconnect resend not yet implemented.
+- **Page refresh**: Server replays pending `prompt_request` messages when a browser subscribes. Client deduplicates by `requestId` or pending title match.
+- **Bridge reconnect**: Bridge replays pending PromptBus requests on WebSocket reconnect so dashboard dialogs survive server restarts.
 
 ### Command Flow (browser → pi)
 1. User types prompt or command in browser
@@ -286,6 +293,18 @@ The web client includes a generic `MarkdownPreviewView` component that replaces
 ### Archive Browser
 The `ArchiveBrowserView` provides a searchable, date-grouped listing of archived OpenSpec changes. It uses a dedicated `GET /api/openspec-archive?cwd=<path>` endpoint that scans `openspec/changes/archive/` and returns entry metadata (name, date, artifacts). The view uses two-level navigation: the list is the first level, and clicking an artifact letter (P/D/S/T) opens the reader as the second level. Back from the reader returns to the list (preserving search and scroll), and back from the list returns to the session view. Entry point is the `[Archive]` button in `FolderOpenSpecSection`.
 
+### Content View Management
+
+The content area (right panel) shows one view at a time: ChatView, ArchiveBrowserView, SpecsBrowserView, PiResourcesView, MarkdownPreviewView (readme, pi resource file, flow YAML, OpenSpec artifact), FileDiffView, FlowArchitectDetail, or FlowAgentDetail. Each view is controlled by independent state in `App.tsx` and `useContentViews`. A priority chain in the JSX determines which view renders (first truthy state wins).
+
+**Mutual exclusivity**: A `clearAllContentViews()` helper resets all content view states. It is called before opening any new content view, ensuring the previous view is always dismissed. This combines `clearAppContentViews()` (App-level states: preview, specs browser, archive browser, diff view, flow YAML, architect detail, flow agent detail) with `clearContentViews()` from `useContentViews` (pi resources, pi resource file preview, readme preview).
+
+**Session switch**: When the selected session changes, `clearAllContentViews()` is called to dismiss any open content view.
+
+**Sub-navigation**: `handleViewPiResourceFile` (viewing a file within PiResourcesView) does not clear other views — it's sub-navigation within an already-active content view.
+
+**`onBeforeOpen` callback**: `useContentViews` accepts an optional `onBeforeOpen` callback. When `handleOpenPiResources` or `handleViewReadme` opens a new top-level view, it calls `onBeforeOpen` first so App.tsx can clear its own states, then clears the hook's sibling states internally.
+
 ### Network Access Control
 
 The server has a two-layer access model:
@@ -506,12 +525,26 @@ The dashboard uses mDNS (via `bonjour-service`) for zero-config server discovery
 - `isDashboardRunning(port)` replaces `isPortOpen(port)` for identity-verified detection
 - After auto-starting, the bridge waits up to 10s for the server's mDNS advertisement
 
+### Known Servers
+- Users can persist remote servers in `config.json` via `knownServers: KnownServer[]`
+- Each entry has `host`, `port`, optional `label`, and `addedAt` timestamp
+- REST API: `GET/POST/DELETE /api/known-servers` for CRUD, `POST /api/discover-servers` for on-demand mDNS scan
+- Localhost is always implicitly available (not stored)
+- The data model is extensible for future key exchange / auth tokens
+
 ### Server Selector UI
-- A dropdown in the sidebar header shows all discovered servers (local + LAN)
-- Each entry shows hostname, port, Local/Remote badge, and connection status
+- The header dropdown shows persisted known servers (from config) plus localhost, not raw mDNS results
+- Each entry shows label (or hostname), host:port, Local/Remote badge, and availability status
+- Non-current servers are probed via health check when the dropdown opens
 - Switching closes the current WebSocket and connects to the selected server
 - Last-used server persisted in `localStorage` (`pi-dashboard-last-server`)
 
+### Server Management (Settings Panel)
+- **Known Servers section**: lists persisted servers with remove buttons and an inline add form (host, port, label)
+- **Network Discovery section**: "Scan network" triggers `POST /api/discover-servers`, shows results with "Add" button that prompts for a label
+- Already-known servers show "Already added" badge in discovery results
+- Electron loading page shows known servers as fallback when primary server is unreachable
+
 ## Provider Authentication
 
 The dashboard supports browser-based authentication with pi's LLM providers, enabling login from phones, tablets, or remote tunnel access without needing terminal access.
@@ -619,6 +652,19 @@ All code-server traffic is proxied through `/editor/:id/*` on the dashboard serv
 
 Binary auto-detection order: config override → `code-server` on PATH → `openvscode-server` on PATH.
 
+### Known Servers Configuration
+
+```json
+{
+  "knownServers": [
+    { "host": "office-mac.local", "port": 8000, "label": "Office Mac", "addedAt": "2024-01-15T10:30:00Z" },
+    { "host": "build-server", "port": 8000, "addedAt": "2024-01-20T14:00:00Z" }
+  ]
+}
+```
+
+Managed via REST API (`/api/known-servers`) or Settings panel. Localhost is always implicit.
+
 ## Bundled Skill: pi-dashboard
 
 The `.pi/skills/pi-dashboard/` directory is both a local project skill (discovered by pi from `.pi/skills/`) and shipped with the npm package (discovered via `pi.skills` in `package.json`). This means any pi session in the dashboard project or any project that installs the dashboard package gets access to the skill.

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@blackbelt-technology/pi-agent-dashboard",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Web dashboard for monitoring and interacting with pi agent sessions",
   "repository": {
     "type": "git",
     "url": "https://github.com/BlackBeltTechnology/pi-agent-dashboard"
   },
+  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
@@ -41,7 +42,8 @@
     "packages/dist/",
     "docs/architecture.md",
     "AGENTS.md",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "dev": "npm run dev --workspace=@blackbelt-technology/pi-dashboard-web",

package/packages/extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-extension",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Pi bridge extension for pi-dashboard",
   "type": "module",
   "pi": {

package/packages/extension/src/__tests__/ask-user-tool.test.ts

@@ -81,5 +81,55 @@ describe("registerAskUserTool", () => {
       await tool.execute("id", { method: "input", title: "Q" }, undefined, undefined, ctx);
       expect(ctx.ui.input).toHaveBeenCalledWith("Q", undefined, undefined);
     });
+
+    it("falls back to message when title is missing", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      await tool.execute("id", { method: "input", message: "Detailed question" }, undefined, undefined, ctx);
+      expect(ctx.ui.input).toHaveBeenCalledWith("Detailed question", undefined, { message: "Detailed question" });
+    });
+
+    it("falls back to 'Question' when both title and message are missing", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      await tool.execute("id", { method: "confirm" }, undefined, undefined, ctx);
+      expect(ctx.ui.confirm).toHaveBeenCalledWith("Question", "");
+    });
+
+    it("parses options from JSON string", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      await tool.execute("id", { method: "select", title: "Pick", options: '["A", "B"]' }, undefined, undefined, ctx);
+      expect(ctx.ui.select).toHaveBeenCalledWith("Pick", ["A", "B"], undefined);
+    });
+
+    it("handles malformed options string gracefully", async () => {
+      const { tool, ctx } = getToolAndMockCtx();
+      await tool.execute("id", { method: "select", title: "Pick", options: "not json" }, undefined, undefined, ctx);
+      expect(ctx.ui.select).toHaveBeenCalledWith("Pick", [], undefined);
+    });
+  });
+
+  describe("prepareArguments", () => {
+    function getTool() {
+      const pi = createMockPi();
+      registerAskUserTool(pi as any);
+      return pi.registerTool.mock.calls[0][0];
+    }
+
+    it("parses stringified options array", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({ method: "select", title: "Pick", options: '["A", "B"]' });
+      expect(result.options).toEqual(["A", "B"]);
+    });
+
+    it("leaves real array options unchanged", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({ method: "select", title: "Pick", options: ["A", "B"] });
+      expect(result.options).toEqual(["A", "B"]);
+    });
+
+    it("leaves malformed string as-is", () => {
+      const tool = getTool();
+      const result = tool.prepareArguments({ method: "select", title: "Pick", options: "not json" });
+      expect(result.options).toBe("not json");
+    });
   });
 });

package/packages/extension/src/__tests__/openspec-activity-detector.test.ts

@@ -93,28 +93,28 @@ describe("detectOpenSpecActivity", () => {
       const result = detectOpenSpecActivity("bash", {
         command: 'openspec status --change "session-sync" --json',
       });
-      expect(result).toEqual({ changeName: "session-sync" });
+      expect(result).toEqual({ changeName: "session-sync", isActive: true });
     });
 
     it("detects change name from openspec instructions command", () => {
       const result = detectOpenSpecActivity("bash", {
         command: 'openspec instructions apply --change "my-feature" --json',
       });
-      expect(result).toEqual({ changeName: "my-feature" });
+      expect(result).toEqual({ changeName: "my-feature", isActive: true });
     });
 
     it("detects change name without quotes", () => {
       const result = detectOpenSpecActivity("bash", {
         command: "openspec status --change session-sync --json",
       });
-      expect(result).toEqual({ changeName: "session-sync" });
+      expect(result).toEqual({ changeName: "session-sync", isActive: true });
     });
 
     it("detects change name from openspec archive command", () => {
       const result = detectOpenSpecActivity("bash", {
         command: "openspec archive session-sync",
       });
-      expect(result).toEqual({ changeName: "session-sync" });
+      expect(result).toEqual({ changeName: "session-sync", isActive: true });
     });
 
     it("returns null for non-openspec bash commands", () => {
@@ -128,21 +128,21 @@ describe("detectOpenSpecActivity", () => {
       const result = detectOpenSpecActivity("bash", {
         command: 'openspec new change "add-auth"',
       });
-      expect(result).toEqual({ changeName: "add-auth" });
+      expect(result).toEqual({ changeName: "add-auth", isActive: true });
     });
 
     it("detects change name from openspec new change with unquoted name", () => {
       const result = detectOpenSpecActivity("bash", {
         command: "openspec new change add-auth",
       });
-      expect(result).toEqual({ changeName: "add-auth" });
+      expect(result).toEqual({ changeName: "add-auth", isActive: true });
     });
 
     it("detects change name from openspec new change with cd prefix", () => {
       const result = detectOpenSpecActivity("bash", {
         command: 'cd /Users/dev/project && openspec new change "my-feature"',
       });
-      expect(result).toEqual({ changeName: "my-feature" });
+      expect(result).toEqual({ changeName: "my-feature", isActive: true });
     });
 
     it("returns null for openspec list (no change name)", () => {
@@ -154,18 +154,18 @@ describe("detectOpenSpecActivity", () => {
   });
 
   describe("change name detection from file reads", () => {
-    it("detects change name from openspec change file read", () => {
+    it("detects change name from openspec change file read as passive", () => {
       const result = detectOpenSpecActivity("read", {
         path: "openspec/changes/session-sync/tasks.md",
       });
-      expect(result).toEqual({ changeName: "session-sync" });
+      expect(result).toEqual({ changeName: "session-sync", isActive: false });
     });
 
-    it("detects change name from absolute path", () => {
+    it("detects change name from absolute path as passive", () => {
       const result = detectOpenSpecActivity("read", {
         path: "/Users/dev/project/openspec/changes/my-feature/proposal.md",
       });
-      expect(result).toEqual({ changeName: "my-feature" });
+      expect(result).toEqual({ changeName: "my-feature", isActive: false });
     });
 
     it("returns null for non-openspec file reads", () => {
@@ -177,18 +177,18 @@ describe("detectOpenSpecActivity", () => {
   });
 
   describe("change name detection from file writes", () => {
-    it("detects change name from openspec change file write", () => {
+    it("detects change name from openspec change file write as active", () => {
       const result = detectOpenSpecActivity("write", {
         path: "openspec/changes/session-sync/proposal.md",
       });
-      expect(result).toEqual({ changeName: "session-sync" });
+      expect(result).toEqual({ changeName: "session-sync", isActive: true });
     });
 
-    it("detects change name from absolute path write", () => {
+    it("detects change name from absolute path write as active", () => {
       const result = detectOpenSpecActivity("write", {
         path: "/Users/dev/project/openspec/changes/my-feature/spec.md",
       });
-      expect(result).toEqual({ changeName: "my-feature" });
+      expect(result).toEqual({ changeName: "my-feature", isActive: true });
     });
 
     it("returns null for non-openspec file writes", () => {
@@ -203,15 +203,15 @@ describe("detectOpenSpecActivity", () => {
     it("handles capitalized tool names (backward compatibility)", () => {
       expect(detectOpenSpecActivity("Read", {
         path: "openspec/changes/my-feature/proposal.md",
-      })).toEqual({ changeName: "my-feature" });
+      })).toEqual({ changeName: "my-feature", isActive: false });
 
       expect(detectOpenSpecActivity("Bash", {
         command: 'openspec status --change "add-auth" --json',
-      })).toEqual({ changeName: "add-auth" });
+      })).toEqual({ changeName: "add-auth", isActive: true });
 
       expect(detectOpenSpecActivity("Write", {
         path: "openspec/changes/my-feature/design.md",
-      })).toEqual({ changeName: "my-feature" });
+      })).toEqual({ changeName: "my-feature", isActive: true });
     });
 
     it("returns null for unknown tool names", () => {

package/packages/extension/src/ask-user-tool.ts

@@ -27,30 +27,50 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
         description:
           "Type of question: confirm (yes/no), select (pick from options), multiselect (pick multiple), input (free text)",
       }),
-      title: Type.String({ description: "The question to ask" }),
+      title: Type.Optional(Type.String({ description: "Short title for the question (optional, falls back to message)" })),
       message: Type.Optional(Type.String({ description: "Additional context or detailed question body (all methods)" })),
       options: Type.Optional(
         Type.Array(Type.String(), { description: "Options to choose from (for select)" }),
       ),
       placeholder: Type.Optional(Type.String({ description: "Placeholder text (for input)" })),
     }),
+    prepareArguments(args: unknown) {
+      const obj = (args && typeof args === "object" ? args : {}) as Record<string, unknown>;
+      // LLMs sometimes send options as a JSON string instead of an array
+      if (typeof obj.options === "string") {
+        try {
+          const parsed = JSON.parse(obj.options);
+          if (Array.isArray(parsed)) obj.options = parsed;
+        } catch { /* leave as-is, validation will report */ }
+      }
+      return obj as any;
+    },
     async execute(_toolCallId: any, params: any, _signal: any, _onUpdate: any, ctx: any) {
       let result: unknown;
 
       const msgOpts = params.message ? { message: params.message } : undefined;
 
+      const title = params.title || params.message || "Question";
+
+      // LLMs sometimes send options as a JSON string instead of an array
+      const options: string[] = Array.isArray(params.options)
+        ? params.options
+        : typeof params.options === "string"
+          ? (() => { try { const p = JSON.parse(params.options); return Array.isArray(p) ? p : []; } catch { return []; } })()
+          : [];
+
       switch (params.method) {
         case "confirm":
-          result = await ctx.ui.confirm(params.title, params.message ?? "");
+          result = await ctx.ui.confirm(title, params.message ?? "");
           break;
         case "select":
-          result = await ctx.ui.select(params.title, params.options ?? [], msgOpts);
+          result = await ctx.ui.select(title, options, msgOpts);
           break;
         case "multiselect":
-          result = await (ctx.ui as any).multiselect(params.title, params.options ?? [], msgOpts);
+          result = await (ctx.ui as any).multiselect(title, options, msgOpts);
           break;
         case "input":
-          result = await ctx.ui.input(params.title, params.placeholder, msgOpts);
+          result = await ctx.ui.input(title, params.placeholder, msgOpts);
           break;
       }
 

package/packages/extension/src/bridge.ts

@@ -775,20 +775,20 @@ function initBridge(pi: ExtensionAPI) {
     // now route through the bus, which distributes to all registered adapters.
     {
       const bus = promptBus;
-      (ctx.ui as any).select = (title: string, options: string[], _opts?: any) =>
-        bus.request({ pipeline: "command", type: "select", question: title, options })
+      (ctx.ui as any).select = (title: string, options: string[], opts?: any) =>
+        bus.request({ pipeline: "command", type: "select", question: title, options, metadata: opts?.message ? { message: opts.message } : undefined })
           .then(r => r.cancelled ? undefined : r.answer);
 
-      (ctx.ui as any).input = (title: string, placeholder?: string, _opts?: any) =>
-        bus.request({ pipeline: "command", type: "input", question: title, defaultValue: placeholder })
+      (ctx.ui as any).input = (title: string, placeholder?: string, opts?: any) =>
+        bus.request({ pipeline: "command", type: "input", question: title, defaultValue: placeholder, metadata: opts?.message ? { message: opts.message } : undefined })
           .then(r => r.cancelled ? undefined : r.answer);
 
-      (ctx.ui as any).confirm = (title: string, _message: string, _opts?: any) =>
-        bus.request({ pipeline: "command", type: "confirm", question: title })
+      (ctx.ui as any).confirm = (title: string, message?: string, opts?: any) =>
+        bus.request({ pipeline: "command", type: "confirm", question: title, metadata: (message || opts?.message) ? { message: message || opts?.message } : undefined })
           .then(r => !r.cancelled && r.answer === "true");
 
-      (ctx.ui as any).editor = (title: string, prefill?: string, _opts?: any) =>
-        bus.request({ pipeline: "command", type: "editor", question: title, defaultValue: prefill })
+      (ctx.ui as any).editor = (title: string, prefill?: string, opts?: any) =>
+        bus.request({ pipeline: "command", type: "editor", question: title, defaultValue: prefill, metadata: opts?.message ? { message: opts.message } : undefined })
           .then(r => r.cancelled ? undefined : r.answer);
 
       // Notify is fire-and-forget: call original + forward to dashboard

package/packages/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-server",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Dashboard server for monitoring and interacting with pi agent sessions",
   "type": "module",
   "main": "src/cli.ts",

package/packages/server/src/__tests__/known-servers-routes.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { loadConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import { writeConfigPartial } from "../config-api.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import type { DiscoveredServer } from "@blackbelt-technology/pi-dashboard-shared/mdns-discovery.js";
+
+describe("known-servers CRUD", () => {
+  let testDir: string;
+  let configFile: string;
+  let origHome: string;
+
+  beforeEach(() => {
+    testDir = path.join(os.tmpdir(), `test-known-servers-${Date.now()}`);
+    fs.mkdirSync(path.join(testDir, ".pi", "dashboard"), { recursive: true });
+    configFile = path.join(testDir, ".pi", "dashboard", "config.json");
+    fs.writeFileSync(configFile, JSON.stringify({}));
+    origHome = process.env.HOME!;
+    process.env.HOME = testDir;
+  });
+
+  afterEach(() => {
+    process.env.HOME = origHome;
+    if (fs.existsSync(testDir)) fs.rmSync(testDir, { recursive: true });
+  });
+
+  it("should default to empty knownServers", () => {
+    const config = loadConfig();
+    expect(config.knownServers).toEqual([]);
+  });
+
+  it("should add a known server", () => {
+    const server = { host: "office-mac", port: 8000, label: "Office", addedAt: new Date().toISOString() };
+    writeConfigPartial({ knownServers: [server] });
+    const config = loadConfig();
+    expect(config.knownServers).toHaveLength(1);
+    expect(config.knownServers[0].host).toBe("office-mac");
+    expect(config.knownServers[0].port).toBe(8000);
+    expect(config.knownServers[0].label).toBe("Office");
+  });
+
+  it("should update label on duplicate host:port", () => {
+    const servers = [
+      { host: "office-mac", port: 8000, label: "Old Label", addedAt: new Date().toISOString() },
+    ];
+    writeConfigPartial({ knownServers: servers });
+
+    // Simulate "add duplicate" by reading, updating, writing
+    const config = loadConfig();
+    const existing = config.knownServers;
+    const idx = existing.findIndex((s) => s.host === "office-mac" && s.port === 8000);
+    expect(idx).toBe(0);
+    existing[idx] = { ...existing[idx], label: "New Label" };
+    writeConfigPartial({ knownServers: existing });
+
+    const updated = loadConfig();
+    expect(updated.knownServers).toHaveLength(1);
+    expect(updated.knownServers[0].label).toBe("New Label");
+  });
+
+  it("should remove a known server", () => {
+    const servers = [
+      { host: "office-mac", port: 8000, label: "Office", addedAt: new Date().toISOString() },
+      { host: "build-server", port: 8000, label: "Build", addedAt: new Date().toISOString() },
+    ];
+    writeConfigPartial({ knownServers: servers });
+
+    const config = loadConfig();
+    const filtered = config.knownServers.filter((s) => !(s.host === "office-mac" && s.port === 8000));
+    writeConfigPartial({ knownServers: filtered });
+
+    const updated = loadConfig();
+    expect(updated.knownServers).toHaveLength(1);
+    expect(updated.knownServers[0].host).toBe("build-server");
+  });
+
+  it("should be idempotent when removing non-existent server", () => {
+    const servers = [
+      { host: "office-mac", port: 8000, label: "Office", addedAt: new Date().toISOString() },
+    ];
+    writeConfigPartial({ knownServers: servers });
+
+    const config = loadConfig();
+    const filtered = config.knownServers.filter((s) => !(s.host === "nonexistent" && s.port === 9999));
+    writeConfigPartial({ knownServers: filtered });
+
+    const updated = loadConfig();
+    expect(updated.knownServers).toHaveLength(1);
+  });
+
+  it("should list known servers from config", () => {
+    const servers = [
+      { host: "a", port: 8000, addedAt: "2024-01-01T00:00:00Z" },
+      { host: "b", port: 9000, label: "B Server", addedAt: "2024-01-02T00:00:00Z" },
+    ];
+    writeConfigPartial({ knownServers: servers });
+
+    const config = loadConfig();
+    expect(config.knownServers).toHaveLength(2);
+    expect(config.knownServers[0].host).toBe("a");
+    expect(config.knownServers[1].label).toBe("B Server");
+  });
+
+  it("should handle entries without label", () => {
+    const servers = [{ host: "no-label", port: 8000, addedAt: "2024-01-01T00:00:00Z" }];
+    writeConfigPartial({ knownServers: servers });
+
+    const config = loadConfig();
+    expect(config.knownServers[0].label).toBeUndefined();
+  });
+
+  it("should ignore invalid entries in knownServers", () => {
+    // Write raw JSON with invalid entries
+    fs.writeFileSync(configFile, JSON.stringify({
+      knownServers: [
+        { host: "valid", port: 8000, addedAt: "2024-01-01T00:00:00Z" },
+        { host: "no-port" }, // missing port
+        "invalid-string",
+        null,
+        { port: 8000 }, // missing host
+      ],
+    }));
+
+    const config = loadConfig();
+    expect(config.knownServers).toHaveLength(1);
+    expect(config.knownServers[0].host).toBe("valid");
+  });
+});

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

@@ -135,10 +135,11 @@ export function wireEvents(deps: EventWiringDeps): void {
           if (changed) {
             sessionManager.update(sessionId, activityUpdates);
             const updatedSession = sessionManager.get(sessionId);
-            // Auto-attach proposal when changeName is detected (phase is optional —
-            // skills loaded via prompt templates don't emit a SKILL.md read event)
+            // Auto-attach proposal when changeName is detected via active operations
+            // (write/CLI). Reads are passive (browsing/analysis) and don't trigger attach.
+            // Phase is optional — skills loaded via prompt templates don't emit a SKILL.md read event.
             const attachUpdates: Partial<DashboardSession> = {};
-            if (updatedSession?.openspecChange && !updatedSession.attachedProposal) {
+            if (updatedSession?.openspecChange && !updatedSession.attachedProposal && detected.isActive) {
               attachUpdates.attachedProposal = updatedSession.openspecChange;
               if (!updatedSession.name?.trim()) {
                 attachUpdates.name = updatedSession.openspecChange;
@@ -507,17 +508,17 @@ export function wireEvents(deps: EventWiringDeps): void {
     // Legacy extension_ui_request/dismiss removed — replaced by PromptBus protocol.
 
     // ── PromptBus protocol messages (extension → browser) ──
-    if ((msg as any).type === "prompt_request") {
+    if (msg.type === "prompt_request") {
       browserGateway.trackPromptRequest(sessionId, msg as any);
       browserGateway.sendToSubscribers(sessionId, msg as any);
     }
 
-    if ((msg as any).type === "prompt_dismiss") {
+    if (msg.type === "prompt_dismiss") {
       browserGateway.clearPromptRequest(sessionId, (msg as any).promptId);
       browserGateway.sendToSubscribers(sessionId, msg as any);
     }
 
-    if ((msg as any).type === "prompt_cancel") {
+    if (msg.type === "prompt_cancel") {
       browserGateway.clearPromptRequest(sessionId, (msg as any).promptId);
       browserGateway.sendToSubscribers(sessionId, msg as any);
     }

package/packages/server/src/routes/known-servers-routes.ts

@@ -0,0 +1,110 @@
+/**
+ * REST routes for known servers management and network discovery.
+ */
+import type { FastifyInstance } from "fastify";
+import type { NetworkGuard } from "./route-deps.js";
+import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import type { KnownServer } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import type { DiscoveredServer } from "@blackbelt-technology/pi-dashboard-shared/mdns-discovery.js";
+import type {
+  AddKnownServerRequest,
+  RemoveKnownServerRequest,
+  DiscoveredServerInfo,
+} from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
+import { loadConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import { writeConfigPartial } from "../config-api.js";
+
+export function registerKnownServersRoutes(
+  fastify: FastifyInstance,
+  deps: {
+    networkGuard: NetworkGuard;
+    getPeerServers: () => Map<string, DiscoveredServer>;
+  },
+) {
+  const { networkGuard, getPeerServers } = deps;
+
+  // List known servers from config
+  fastify.get(
+    "/api/known-servers",
+    { preHandler: networkGuard },
+    async (): Promise<ApiResponse<KnownServer[]>> => {
+      const config = loadConfig();
+      return { success: true, data: config.knownServers };
+    },
+  );
+
+  // Add or update a known server
+  fastify.post<{ Body: AddKnownServerRequest }>(
+    "/api/known-servers",
+    { preHandler: networkGuard },
+    async (request): Promise<ApiResponse> => {
+      const { host, port, label } = request.body;
+      if (!host || typeof port !== "number") {
+        return { success: false, error: "host and port are required" };
+      }
+
+      const config = loadConfig();
+      const existing = config.knownServers;
+      const idx = existing.findIndex((s) => s.host === host && s.port === port);
+
+      if (idx >= 0) {
+        // Update label on duplicate
+        existing[idx] = { ...existing[idx], ...(label !== undefined ? { label } : {}) };
+      } else {
+        existing.push({
+          host,
+          port,
+          ...(label ? { label } : {}),
+          addedAt: new Date().toISOString(),
+        });
+      }
+
+      const result = writeConfigPartial({ knownServers: existing });
+      if (!result.success) {
+        return { success: false, error: result.error };
+      }
+      return { success: true };
+    },
+  );
+
+  // Remove a known server
+  fastify.delete<{ Body: RemoveKnownServerRequest }>(
+    "/api/known-servers",
+    { preHandler: networkGuard },
+    async (request): Promise<ApiResponse> => {
+      const { host, port } = request.body;
+      if (!host || typeof port !== "number") {
+        return { success: false, error: "host and port are required" };
+      }
+
+      const config = loadConfig();
+      const filtered = config.knownServers.filter(
+        (s) => !(s.host === host && s.port === port),
+      );
+
+      const result = writeConfigPartial({ knownServers: filtered });
+      if (!result.success) {
+        return { success: false, error: result.error };
+      }
+      return { success: true };
+    },
+  );
+
+  // On-demand network discovery — returns current mDNS peers
+  fastify.post(
+    "/api/discover-servers",
+    { preHandler: networkGuard },
+    async (): Promise<ApiResponse<DiscoveredServerInfo[]>> => {
+      const peers = getPeerServers();
+      const data: DiscoveredServerInfo[] = Array.from(peers.values()).map((s) => ({
+        host: s.host,
+        port: s.port,
+        piPort: s.piPort,
+        version: s.version,
+        pid: s.pid,
+        isLocal: s.isLocal,
+      }));
+      return { success: true, data };
+    },
+  );
+}

package/packages/server/src/server.ts

@@ -46,6 +46,7 @@ import { registerProviderRoutes } from "./routes/provider-routes.js";
 import { PackageManagerWrapper } from "./package-manager-wrapper.js";
 import { createEditorManager, type EditorManager } from "./editor-manager.js";
 import { registerEditorRoutes } from "./routes/editor-routes.js";
+import { registerKnownServersRoutes } from "./routes/known-servers-routes.js";
 import { registerEditorProxy, handleEditorUpgrade } from "./editor-proxy.js";
 import { detectCodeServerBinary } from "./editor-detection.js";
 
@@ -342,6 +343,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   registerEditorProxy(fastify, editorManager);
 
   registerProviderAuthRoutes(fastify, { piGateway });
+  registerKnownServersRoutes(fastify, { networkGuard, getPeerServers: () => peerServers });
   registerProviderRoutes(fastify, { networkGuard });
 
   // Serve static files / SPA fallback

package/packages/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-shared",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Shared types and utilities for pi-dashboard",
   "type": "module",
   "exports": {

package/packages/shared/src/__tests__/browser-protocol-types.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Type-level tests ensuring PromptBus messages are included in ServerToBrowserMessage.
+ *
+ * These tests prevent the regression where `case "prompt_request" as any:` etc.
+ * in switch statements were dead-code eliminated by esbuild because the message
+ * types were not in the ServerToBrowserMessage union.
+ */
+import { describe, it, expect } from "vitest";
+import type {
+  ServerToBrowserMessage,
+  BrowserPromptRequestMessage,
+  BrowserPromptDismissMessage,
+  BrowserPromptCancelMessage,
+} from "../browser-protocol.js";
+
+// Type-level assertion: if these types are NOT in the union, this will fail to compile.
+type AssertExtends<T, U> = T extends U ? true : never;
+type _PromptRequestInUnion = AssertExtends<BrowserPromptRequestMessage, ServerToBrowserMessage>;
+type _PromptDismissInUnion = AssertExtends<BrowserPromptDismissMessage, ServerToBrowserMessage>;
+type _PromptCancelInUnion = AssertExtends<BrowserPromptCancelMessage, ServerToBrowserMessage>;
+
+// Runtime verification that the type discriminants are reachable in a switch
+function extractPromptType(msg: ServerToBrowserMessage): string | null {
+  switch (msg.type) {
+    case "prompt_request": return msg.promptId;
+    case "prompt_dismiss": return msg.promptId;
+    case "prompt_cancel": return msg.promptId;
+    default: return null;
+  }
+}
+
+describe("ServerToBrowserMessage includes PromptBus messages", () => {
+  it("prompt_request is a valid discriminant", () => {
+    const msg: BrowserPromptRequestMessage = {
+      type: "prompt_request",
+      sessionId: "s1",
+      promptId: "p1",
+      prompt: { question: "Q?", type: "input" },
+      component: { type: "generic-dialog", props: {} },
+      placement: "inline",
+    };
+    expect(extractPromptType(msg)).toBe("p1");
+  });
+
+  it("prompt_dismiss is a valid discriminant", () => {
+    const msg: BrowserPromptDismissMessage = {
+      type: "prompt_dismiss",
+      sessionId: "s1",
+      promptId: "p1",
+    };
+    expect(extractPromptType(msg)).toBe("p1");
+  });
+
+  it("prompt_cancel is a valid discriminant", () => {
+    const msg: BrowserPromptCancelMessage = {
+      type: "prompt_cancel",
+      sessionId: "s1",
+      promptId: "p1",
+    };
+    expect(extractPromptType(msg)).toBe("p1");
+  });
+});

package/packages/shared/src/browser-protocol.ts

@@ -162,6 +162,39 @@ export interface EditorStatusMessage {
   status: EditorInstanceStatus;
 }
 
+// ── PromptBus protocol (Server → Browser) ───────────────────────────
+
+export interface BrowserPromptRequestMessage {
+  type: "prompt_request";
+  sessionId: string;
+  promptId: string;
+  prompt: {
+    question: string;
+    type: string;
+    options?: string[];
+    defaultValue?: string;
+    pipeline?: string;
+    metadata?: Record<string, unknown>;
+  };
+  component: {
+    type: string;
+    props: Record<string, unknown>;
+  };
+  placement: string;
+}
+
+export interface BrowserPromptDismissMessage {
+  type: "prompt_dismiss";
+  sessionId: string;
+  promptId: string;
+}
+
+export interface BrowserPromptCancelMessage {
+  type: "prompt_cancel";
+  sessionId: string;
+  promptId: string;
+}
+
 /** Progress event streamed during a package install/remove/update operation. */
 export interface PackageProgressMessage {
   type: "package_progress";
@@ -216,7 +249,10 @@ export type ServerToBrowserMessage =
   | BrowserRolesListMessage
   | ProcessListUpdateMessage
   | ServersDiscoveredMessage
-  | ServersUpdatedMessage;
+  | ServersUpdatedMessage
+  | BrowserPromptRequestMessage
+  | BrowserPromptDismissMessage
+  | BrowserPromptCancelMessage;
 
 // ── Browser → Server ────────────────────────────────────────────────
 

package/packages/shared/src/config.ts

@@ -55,6 +55,13 @@ export const DEFAULT_EDITOR_CONFIG: EditorConfig = {
   maxInstances: 3,
 };
 
+export interface KnownServer {
+  host: string;
+  port: number;
+  label?: string;
+  addedAt: string; // ISO timestamp
+}
+
 export interface DashboardConfig {
   port: number;
   piPort: number;
@@ -78,6 +85,8 @@ export interface DashboardConfig {
   lastServer?: string;
   /** Whether the server was launched by the Electron app */
   electronMode: boolean;
+  /** Persisted list of known remote servers */
+  knownServers: KnownServer[];
 }
 
 export interface CorsConfig {
@@ -103,6 +112,7 @@ const DEFAULTS: DashboardConfig = {
   resolvedTrustedNetworks: [],
   cors: { allowedOrigins: [] },
   electronMode: false,
+  knownServers: [],
 };
 
 /**
@@ -156,6 +166,18 @@ function parseMemoryLimits(raw: any): MemoryLimitsConfig {
   };
 }
 
+function parseKnownServers(raw: any): KnownServer[] {
+  if (!Array.isArray(raw)) return [];
+  return raw
+    .filter((entry: any) => entry && typeof entry === "object" && typeof entry.host === "string" && typeof entry.port === "number")
+    .map((entry: any) => ({
+      host: entry.host,
+      port: entry.port,
+      ...(typeof entry.label === "string" ? { label: entry.label } : {}),
+      addedAt: typeof entry.addedAt === "string" ? entry.addedAt : new Date().toISOString(),
+    }));
+}
+
 function parseTrustedNetworks(raw: any): string[] {
   if (!Array.isArray(raw)) return [];
   return raw.filter((entry: unknown) => typeof entry === "string" && entry.length > 0);
@@ -204,6 +226,7 @@ export function loadConfig(): DashboardConfig {
       },
       ...(typeof parsed.lastServer === "string" ? { lastServer: parsed.lastServer } : {}),
       electronMode: parsed.electronMode === true,
+      knownServers: parseKnownServers(parsed.knownServers),
     };
 
     // Compute resolvedTrustedNetworks: merge trustedNetworks + auth.bypassHosts

package/packages/shared/src/openspec-activity-detector.ts

@@ -7,6 +7,8 @@ import type { OpenSpecPhase } from "./types.js";
 export interface DetectedActivity {
   phase?: OpenSpecPhase;
   changeName?: string;
+  /** True for write/CLI operations (active work), false for reads (passive browsing) */
+  isActive?: boolean;
 }
 
 /** Map from skill directory name suffix to phase */
@@ -59,10 +61,10 @@ export function detectOpenSpecActivity(
       return null;
     }
 
-    // Check for openspec change file read → change name detection
+    // Check for openspec change file read → change name detection (passive)
     const changeMatch = path.match(CHANGE_PATH_RE);
     if (changeMatch) {
-      return { changeName: changeMatch[1] };
+      return { changeName: changeMatch[1], isActive: false };
     }
 
     return null;
@@ -74,7 +76,7 @@ export function detectOpenSpecActivity(
 
     const changeMatch = path.match(CHANGE_PATH_RE);
     if (changeMatch) {
-      return { changeName: changeMatch[1] };
+      return { changeName: changeMatch[1], isActive: true };
     }
 
     return null;
@@ -87,19 +89,19 @@ export function detectOpenSpecActivity(
     // Check for --change flag
     const flagMatch = command.match(CLI_CHANGE_FLAG_RE);
     if (flagMatch) {
-      return { changeName: flagMatch[1] };
+      return { changeName: flagMatch[1], isActive: true };
     }
 
     // Check for openspec archive <name>
     const archiveMatch = command.match(CLI_ARCHIVE_RE);
     if (archiveMatch) {
-      return { changeName: archiveMatch[1] };
+      return { changeName: archiveMatch[1], isActive: true };
     }
 
     // Check for openspec new change "name"
     const newChangeMatch = command.match(CLI_NEW_CHANGE_RE);
     if (newChangeMatch) {
-      return { changeName: newChangeMatch[1] };
+      return { changeName: newChangeMatch[1], isActive: true };
     }
 
     return null;

package/packages/shared/src/rest-api.ts

@@ -246,6 +246,34 @@ export interface PackageUpdateInfo {
 
 export type CheckUpdatesResponse = ApiResponse<PackageUpdateInfo[]>;
 
+// ── Known Servers ─────────────────────────────────────────────
+
+import type { KnownServer } from "./config.js";
+
+export type KnownServersListResponse = ApiResponse<KnownServer[]>;
+
+export interface AddKnownServerRequest {
+  host: string;
+  port: number;
+  label?: string;
+}
+
+export interface RemoveKnownServerRequest {
+  host: string;
+  port: number;
+}
+
+export interface DiscoveredServerInfo {
+  host: string;
+  port: number;
+  piPort: number;
+  version: string;
+  pid: number;
+  isLocal: boolean;
+}
+
+export type DiscoverServersResponse = ApiResponse<DiscoveredServerInfo[]>;
+
 /** Detected network interface for trusted networks UI. */
 export interface NetworkInterface {
   name: string;