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

package/packages/extension/src/__tests__/tui-prompt-adapter.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Tests for the bridge's built-in TUI adapter behavior.
+ * Tests the adapter contract using the same mock pattern as the wiring tests.
+ * The TUI adapter is defined inline in bridge.ts session_start.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { PromptBus, type PromptAdapter, type PromptRequest, type PromptResponse, type PromptClaim } from "../prompt-bus.js";
+
+// Minimal TUI adapter reimplementation for testing the contract
+// (mirrors the inline adapter in bridge.ts session_start)
+function createTestTuiAdapter(mockUi: any, bus: PromptBus): PromptAdapter {
+  const controllers = new Map<string, AbortController>();
+
+  return {
+    name: "tui",
+    onRequest(prompt: PromptRequest): PromptClaim | null {
+      const ac = new AbortController();
+      controllers.set(prompt.id, ac);
+
+      const present = async () => {
+        try {
+          let answer: any;
+          if (prompt.type === "select") {
+            answer = await mockUi.select(prompt.question, prompt.options, { signal: ac.signal });
+          } else if (prompt.type === "input") {
+            answer = await mockUi.input(prompt.question, prompt.defaultValue || "", { signal: ac.signal });
+          } else if (prompt.type === "confirm") {
+            answer = await mockUi.confirm(prompt.question, "", { signal: ac.signal });
+          }
+          if (!ac.signal.aborted) {
+            const str = typeof answer === "boolean" ? (answer ? "true" : "false") : answer;
+            bus.respond({ id: prompt.id, answer: str ?? undefined, cancelled: str == null, source: "tui" });
+          }
+        } catch {
+          if (!ac.signal.aborted) {
+            bus.respond({ id: prompt.id, cancelled: true, source: "tui" });
+          }
+        } finally {
+          controllers.delete(prompt.id);
+        }
+      };
+      present();
+      return {};
+    },
+    onResponse(response: PromptResponse) {
+      if (response.source !== "tui") {
+        const ac = controllers.get(response.id);
+        if (ac) { ac.abort(); controllers.delete(response.id); }
+      }
+    },
+    onCancel(id: string) {
+      const ac = controllers.get(id);
+      if (ac) { ac.abort(); controllers.delete(id); }
+    },
+  };
+}
+
+function createMockUi() {
+  const signals: Record<string, AbortSignal | undefined> = {};
+  const resolvers: Record<string, { resolve: (v: any) => void }> = {};
+
+  function makeMock(name: string) {
+    return vi.fn().mockImplementation((_q: string, _a?: any, opts?: any) => {
+      signals[name] = opts?.signal;
+      return new Promise((resolve) => {
+        resolvers[name] = { resolve };
+        opts?.signal?.addEventListener("abort", () => resolve(undefined), { once: true });
+      });
+    });
+  }
+
+  return {
+    select: makeMock("select"),
+    input: makeMock("input"),
+    confirm: makeMock("confirm"),
+    _resolve: (method: string, value: any) => resolvers[method]?.resolve(value),
+    _signal: (method: string) => signals[method],
+  };
+}
+
+describe("Bridge TUI adapter", () => {
+  let bus: PromptBus;
+  let mockUi: ReturnType<typeof createMockUi>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    bus = new PromptBus({ timeoutMs: 5000 });
+    mockUi = createMockUi();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("calls original select with question and options", () => {
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    bus.request({ pipeline: "command", type: "select", question: "Pick:", options: ["A", "B"] });
+
+    expect(mockUi.select).toHaveBeenCalledWith("Pick:", ["A", "B"], expect.objectContaining({ signal: expect.any(AbortSignal) }));
+  });
+
+  it("calls original input with question and defaultValue", () => {
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    bus.request({ pipeline: "command", type: "input", question: "Name:", defaultValue: "default" });
+
+    expect(mockUi.input).toHaveBeenCalledWith("Name:", "default", expect.objectContaining({ signal: expect.any(AbortSignal) }));
+  });
+
+  it("calls original confirm with question", () => {
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    bus.request({ pipeline: "command", type: "confirm", question: "Sure?" });
+
+    expect(mockUi.confirm).toHaveBeenCalledWith("Sure?", "", expect.objectContaining({ signal: expect.any(AbortSignal) }));
+  });
+
+  it("responds via bus when user answers select", async () => {
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    const promise = bus.request({ pipeline: "command", type: "select", question: "Q", options: ["A"] });
+
+    mockUi._resolve("select", "A");
+    await vi.advanceTimersByTimeAsync(0);
+
+    const result = await promise;
+    expect(result.answer).toBe("A");
+    expect(result.source).toBe("tui");
+  });
+
+  it("responds cancelled when user dismisses dialog", async () => {
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    const promise = bus.request({ pipeline: "command", type: "select", question: "Q", options: ["A"] });
+
+    mockUi._resolve("select", undefined);
+    await vi.advanceTimersByTimeAsync(0);
+
+    const result = await promise;
+    expect(result.cancelled).toBe(true);
+  });
+
+  it("converts boolean confirm to string", async () => {
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    const promise = bus.request({ pipeline: "command", type: "confirm", question: "Sure?" });
+
+    mockUi._resolve("confirm", true);
+    await vi.advanceTimersByTimeAsync(0);
+
+    const result = await promise;
+    expect(result.answer).toBe("true");
+  });
+
+  it("aborts TUI dialog when another adapter answers", async () => {
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    const promise = bus.request({ pipeline: "command", type: "select", question: "Q", options: ["A"] });
+
+    // External adapter answers
+    const id = (mockUi.select.mock.calls[0] as any)?.[2]?.signal ? undefined : undefined;
+    // Get the prompt id from the bus's pending
+    bus.respond({ id: (bus as any).pending.keys().next().value, answer: "B", source: "dashboard" });
+    await vi.advanceTimersByTimeAsync(0);
+
+    const result = await promise;
+    expect(result.answer).toBe("B");
+    expect(result.source).toBe("dashboard");
+    expect(mockUi._signal("select")?.aborted).toBe(true);
+  });
+
+  it("aborts TUI dialog on cancel", async () => {
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    const promise = bus.request({ pipeline: "command", type: "select", question: "Q", options: ["A"] });
+
+    const id = (bus as any).pending.keys().next().value;
+    bus.cancel(id);
+    await vi.advanceTimersByTimeAsync(0);
+
+    const result = await promise;
+    expect(result.cancelled).toBe(true);
+    expect(mockUi._signal("select")?.aborted).toBe(true);
+  });
+
+  it("does not respond after being aborted", async () => {
+    const respondSpy = vi.spyOn(bus, "respond");
+    bus.registerAdapter(createTestTuiAdapter(mockUi, bus));
+    bus.request({ pipeline: "command", type: "select", question: "Q", options: ["A"] });
+
+    const id = (bus as any).pending.keys().next().value;
+    // Dashboard answers first
+    bus.respond({ id, answer: "B", source: "dashboard" });
+    await vi.advanceTimersByTimeAsync(0);
+
+    // TUI resolves after abort — should NOT call respond again
+    mockUi._resolve("select", "A");
+    await vi.advanceTimersByTimeAsync(0);
+
+    // respond was called exactly once (by dashboard)
+    expect(respondSpy.mock.calls.filter(c => c[0].id === id)).toHaveLength(1);
+  });
+
+  it("returns empty claim (no component)", () => {
+    const adapter = createTestTuiAdapter(mockUi, bus);
+    bus.registerAdapter(adapter);
+    const claim = adapter.onRequest({
+      id: "test", pipeline: "command", type: "select", question: "Q", options: ["A"],
+    });
+    expect(claim).toEqual({});
+    expect(claim?.component).toBeUndefined();
+  });
+});

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

@@ -34,7 +34,7 @@ export function registerAskUserTool(pi: ExtensionAPI): void {
       ),
       placeholder: Type.Optional(Type.String({ description: "Placeholder text (for input)" })),
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    async execute(_toolCallId: any, params: any, _signal: any, _onUpdate: any, ctx: any) {
       let result: unknown;
 
       const msgOpts = params.message ? { message: params.message } : undefined;

package/packages/extension/src/bridge-context.ts

@@ -8,7 +8,7 @@ import type { ConnectionManager } from "./connection.js";
 export interface BridgeContext {
   pi: ExtensionAPI;
   connection: ConnectionManager;
-  /** Current session ID (mutated on session_switch/fork) */
+  /** Current session ID (mutated on session change: new/fork/resume) */
   sessionId: string;
   cachedCtx: any;
   cachedModelRegistry: any;

package/packages/extension/src/bridge.ts

@@ -22,7 +22,8 @@ import { autoStartServer } from "./server-auto-start.js";
 import type { ServerToExtensionMessage } from "@blackbelt-technology/pi-dashboard-shared/protocol.js";
 import { expandPromptTemplateFromDisk } from "./prompt-expander.js";
 
-import { createUiProxy } from "./ui-proxy.js";
+import { PromptBus } from "./prompt-bus.js";
+import { DashboardDefaultAdapter } from "./dashboard-default-adapter.js";
 import { registerAskUserTool } from "./ask-user-tool.js";
 import { activate as activateProviderRegister, onProviderChanged } from "./provider-register.js";
 import type { FlowInfo } from "@blackbelt-technology/pi-dashboard-shared/types.js";
@@ -178,7 +179,7 @@ function initBridge(pi: ExtensionAPI) {
   let cachedCtx: any | undefined = prev.ctx;
   let lastModel: string | undefined;
   let lastThinkingLevel: string | undefined;
-  let uiProxy: ReturnType<typeof createUiProxy> | undefined;
+  let promptBus: PromptBus | undefined;
 
   /** Wrap a callback so errors log instead of crashing the host pi agent. */
   function safe<T extends (...args: any[]) => any>(fn: T): T {
@@ -207,11 +208,7 @@ function initBridge(pi: ExtensionAPI) {
     onMessage: safe(async (data: unknown) => {
       if (!isActive()) return; // Stale listener guard
       const msg = data as ServerToExtensionMessage;
-      // Route UI responses to the proxy
-      if (msg.type === "extension_ui_response" && uiProxy) {
-        uiProxy.handleResponse(msg);
-        return;
-      }
+      // Legacy extension_ui_response removed — now handled by prompt_response → promptBus.respond()
       // Reload auth credentials when dashboard notifies of changes
       if (msg.type === "credentials_updated") {
         try { cachedModelRegistry?.authStorage?.reload?.(); } catch { /* ignore */ }
@@ -315,22 +312,20 @@ function initBridge(pi: ExtensionAPI) {
         });
         return;
       }
-      // Route architect prompt responses back to flow-workspace via pi.events
-      if (msg.type === "architect_prompt_response" && pi.events) {
-        pi.events.emit("flow:prompt-response", {
-          id: msg.promptId,
-          answer: msg.answer,
-          cancelled: msg.cancelled,
+      // Route PromptBus responses from dashboard client
+      if (msg.type === "prompt_response" && promptBus) {
+        promptBus.respond({
+          id: (msg as any).promptId,
+          answer: (msg as any).answer,
+          cancelled: (msg as any).cancelled,
+          source: (msg as any).source ?? "dashboard-default",
         });
-        // Cancel any pending ui-proxy dialogs so the TUI selector is dismissed.
-        // The architect prompt was also forwarded via the ui-proxy (through
-        // flow-tui’s prompt-request handler calling uiCtx.select()), but the
-        // dashboard client suppresses the duplicate extension_ui_request when
-        // an architect_prompt_request is pending. So the proxy’s dashPromise
-        // would never resolve, leaving the TUI dialog open forever.
-        uiProxy?.cancelAllPending();
         return;
       }
+      // Legacy architect_prompt_response routing REMOVED.
+      // Previously routed to flow:prompt-response + cancelAllPending().
+      // Now handled by PromptBus: dashboard sends prompt_response,
+      // bus calls respond(), adapters get onResponse() for cross-cancellation.
       // Route flow control messages to pi-flows via pi.events
       if (msg.type === "flow_control" && pi.events) {
         if (msg.action === "abort") {
@@ -357,13 +352,33 @@ function initBridge(pi: ExtensionAPI) {
       if (!isActive()) return; // Stale listener guard
       sendStateSync();
       replaySessionEntries();
+      // Re-send pending PromptBus requests so dashboard dialogs survive browser refresh.
+      // Synchronous within this tick to prevent TUI respond() from interleaving.
+      // Client-side dedup by requestId prevents double-rendering.
+      if (promptBus) {
+        for (const { request, component, placement } of promptBus.getPendingRequests()) {
+          connection.send({
+            type: "prompt_request" as any,
+            sessionId,
+            promptId: request.id,
+            prompt: {
+              type: request.type,
+              question: request.question,
+              options: request.options,
+              defaultValue: request.defaultValue,
+              pipeline: request.pipeline,
+              metadata: request.metadata,
+            },
+            component,
+            placement,
+          });
+        }
+      }
       connection.send({ type: "replay_complete", sessionId });
       // If agent is mid-turn, send synthetic agent_start so server sets status to "streaming"
       if (getBridgeState().isAgentStreaming) {
         connection.send(mapEventToProtocol(sessionId, { type: "agent_start" }));
       }
-      // Re-send pending interactive UI requests so the new server can track them
-      uiProxy?.resendPending();
     }),
   });
 
@@ -530,8 +545,7 @@ function initBridge(pi: ExtensionAPI) {
   // - `context`: carries full message arrays (very large)
   // - `before_provider_request`: carries raw API payloads (very large)
   // - `session_start`: dedicated handler → session_register protocol message
-  // - `session_switch`: dedicated handler → session_register protocol message
-  // - `session_fork`: dedicated handler → session_register protocol message
+  // - session change (new/fork/resume): handled inside session_start via event.reason
   // - `session_shutdown`: dedicated handler → disconnect/cleanup
 
   // Unified EventBus rename map for the emit intercept (flow + subagent events)
@@ -623,6 +637,13 @@ function initBridge(pi: ExtensionAPI) {
     if (!isActive()) return;
     const newSessionId = ctx.sessionManager.getSessionId();
 
+    // On session switch/fork (0.65.0+: event.reason replaces session_switch/session_fork events),
+    // unregister the old session before re-registering the new one.
+    const reason = _event?.reason;
+    if ((reason === "new" || reason === "fork" || reason === "resume") && sessionId && sessionId !== newSessionId) {
+      handleSessionChange(ctx);
+    }
+
     cachedHasUI = ctx.hasUI;
     cachedCtx = ctx;
     sessionId = newSessionId;
@@ -637,30 +658,173 @@ function initBridge(pi: ExtensionAPI) {
     lastSessionFile = sessionFile;
     lastSessionDir = sessionDir;
 
-    // Set up UI proxy to forward dialogs to dashboard.
-    // For dashboard-spawned sessions (tmux or headless), skip the TUI race —
-    // the dashboard is the primary UI, and the TUI dialog in an unattended
-    // tmux window would auto-resolve/flood.
-    const dashboardSpawned = detectSessionSource(cachedHasUI, sessionFile) === "dashboard";
-    uiProxy = createUiProxy({
-      ui: ctx.ui as any,
-      hasUI: ctx.hasUI && !dashboardSpawned,
-      getSessionId: () => sessionId,
-      send: (msg: any) => connection.send(msg),
+    // ── PromptBus setup ──
+    // Create bus with dashboard connection wiring.
+    // Replaces the old ui-proxy race pattern.
+    promptBus = new PromptBus({
+      onDashboardRequest: (prompt, component, placement) => {
+        connection.send({
+          type: "prompt_request" as any,
+          sessionId,
+          promptId: prompt.id,
+          prompt: {
+            question: prompt.question,
+            type: prompt.type,
+            options: prompt.options,
+            defaultValue: prompt.defaultValue,
+            pipeline: prompt.pipeline,
+            metadata: prompt.metadata,
+          },
+          component,
+          placement,
+        });
+      },
+      onDashboardDismiss: (id) => {
+        connection.send({ type: "prompt_dismiss" as any, sessionId, promptId: id });
+      },
+      onDashboardCancel: (id) => {
+        connection.send({ type: "prompt_cancel" as any, sessionId, promptId: id });
+      },
     });
-    // Replace ctx.ui methods with proxied versions.
-    // The ui-proxy has a recursion guard (inProxy flag) so even if ctx.ui
-    // is already patched from a previous /reload, the TUI race path won't
-    // recurse — it falls back to dashboard-only on re-entry.
-    // Replace ctx.ui methods with proxied versions.
-    // The ui-proxy has a recursion guard (inProxy flag) so even if ctx.ui
-    // is already patched from a previous /reload, the TUI race path won't
-    // recurse — it falls back to dashboard-only on re-entry.
-    (ctx.ui as any).confirm = uiProxy.wrappedUi.confirm;
-    (ctx.ui as any).select = uiProxy.wrappedUi.select;
-    (ctx.ui as any).input = uiProxy.wrappedUi.input;
-    (ctx.ui as any).editor = uiProxy.wrappedUi.editor;
-    (ctx.ui as any).notify = uiProxy.wrappedUi.notify;
+
+    // Register built-in default adapter (always present, works without pi-flows)
+    promptBus.registerAdapter(new DashboardDefaultAdapter());
+
+    // Capture original ctx.ui method references BEFORE patching
+    const originalNotify = ctx.ui.notify?.bind(ctx.ui);
+    const originals = {
+      select: ctx.ui.select?.bind(ctx.ui) as ((q: string, opts: string[], extra?: any) => Promise<string | undefined>) | undefined,
+      input: ctx.ui.input?.bind(ctx.ui) as ((q: string, placeholder?: string, extra?: any) => Promise<string | undefined>) | undefined,
+      confirm: ctx.ui.confirm?.bind(ctx.ui) as ((q: string, msg: string, extra?: any) => Promise<boolean>) | undefined,
+      editor: ctx.ui.editor?.bind(ctx.ui) as ((q: string, prefill?: string, extra?: any) => Promise<string | undefined>) | undefined,
+    };
+
+    // Register TUI adapter — presents prompts in the terminal using original
+    // (unpatched) ctx.ui methods. Must be registered BEFORE patching ctx.ui.
+    if (ctx.hasUI) {
+      const activeControllers = new Map<string, AbortController>();
+      const bus = promptBus;
+
+      bus.registerAdapter({
+        name: "tui",
+
+        onRequest(prompt: any) {
+          const ac = new AbortController();
+          activeControllers.set(prompt.id, ac);
+
+          const present = async () => {
+            try {
+              let answer: string | boolean | undefined;
+
+              if (prompt.type === "select" && prompt.options && originals.select) {
+                answer = await originals.select(prompt.question, prompt.options, { signal: ac.signal });
+              } else if (prompt.type === "input" && originals.input) {
+                answer = await originals.input(prompt.question, prompt.defaultValue || "", { signal: ac.signal });
+              } else if (prompt.type === "confirm" && originals.confirm) {
+                answer = await originals.confirm(prompt.question, "", { signal: ac.signal });
+              } else if (prompt.type === "editor" && originals.editor) {
+                answer = await originals.editor(prompt.question, prompt.defaultValue || "", { signal: ac.signal });
+              } else {
+                return;
+              }
+
+              if (!ac.signal.aborted) {
+                const answerStr = typeof answer === "boolean" ? (answer ? "true" : "false") : answer;
+                bus.respond({
+                  id: prompt.id,
+                  answer: answerStr ?? undefined,
+                  cancelled: answerStr == null,
+                  source: "tui",
+                });
+              }
+            } catch {
+              if (!ac.signal.aborted) {
+                bus.respond({ id: prompt.id, cancelled: true, source: "tui" });
+              }
+            } finally {
+              activeControllers.delete(prompt.id);
+            }
+          };
+
+          present();
+          return {}; // Claim without component (TUI-only)
+        },
+
+        onResponse(response: any) {
+          if (response.source !== "tui") {
+            const ac = activeControllers.get(response.id);
+            if (ac) {
+              ac.abort();
+              activeControllers.delete(response.id);
+            }
+          }
+        },
+
+        onCancel(id: string) {
+          const ac = activeControllers.get(id);
+          if (ac) {
+            ac.abort();
+            activeControllers.delete(id);
+          }
+        },
+      });
+    }
+
+    // Replace ctx.ui dialog methods with PromptBus wrappers.
+    // All extension commands that call ctx.ui.select/input/confirm/editor
+    // 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 })
+          .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 })
+          .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 })
+          .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 })
+          .then(r => r.cancelled ? undefined : r.answer);
+
+      // Notify is fire-and-forget: call original + forward to dashboard
+      (ctx.ui as any).notify = (message: string, level?: string) => {
+        originalNotify?.(message, level);
+        connection.send({
+          type: "prompt_request" as any,
+          sessionId,
+          promptId: crypto.randomUUID(),
+          prompt: { question: message, type: "notify" },
+          component: { type: "notify", props: { message, level } },
+          placement: "inline",
+        });
+      };
+    }
+
+    // Listen for adapter registrations from other extensions (e.g. pi-flows)
+    if (pi.events) {
+      pi.events.on("prompt:register-adapter", (adapter: any) => {
+        if (promptBus && adapter && typeof adapter.name === "string") {
+          promptBus.registerAdapter(adapter);
+          // Inject respond/cancel functions so cross-package adapters can talk back
+          if (typeof adapter.setRespond === "function") {
+            adapter.setRespond((response: any) => promptBus!.respond(response));
+          }
+          if (typeof adapter.setCancel === "function") {
+            adapter.setCancel((id: string) => promptBus!.cancel(id));
+          }
+        }
+      });
+
+      // Expose bus request function for pi-flows to use via emitPromptAndAwait
+      pi.events.emit("prompt:set-bus-request", {
+        request: (options: any) => promptBus!.request(options),
+      });
+    }
 
     // Connect first, then auto-start if needed.
     // session_register must be buffered before any event_forward messages.
@@ -810,7 +974,7 @@ function initBridge(pi: ExtensionAPI) {
     registerFlowEventListeners(syncBc(), () => sessionReady, getFlowsList);
   }));
 
-  // Shared handler for session_switch and session_fork
+  // Shared handler for session changes (new/fork/resume)
   function handleSessionChange(ctx: any) {
     const bc = syncBc();
     _handleSessionChange(bc, ctx, getFlowsList);
@@ -823,17 +987,8 @@ function initBridge(pi: ExtensionAPI) {
     }, GIT_POLL_INTERVAL);
   }
 
-  pi.on("session_switch" as any, safe(async (_event: any, ctx: any) => {
-    if (!isActive()) return;
-    cachedCtx = ctx;
-    handleSessionChange(ctx);
-  }));
-
-  pi.on("session_fork" as any, safe(async (_event: any, ctx: any) => {
-    if (!isActive()) return;
-    cachedCtx = ctx;
-    handleSessionChange(ctx);
-  }));
+  // session_switch and session_fork events removed in pi 0.65.0.
+  // Now handled via session_start with event.reason ("new"|"fork"|"resume").
 
   pi.on("turn_end", safe(async (event: any, ctx: any) => {
     if (!isActive()) return;

package/packages/extension/src/command-handler.ts

@@ -178,8 +178,8 @@ export function createCommandHandler(
       const sessionId = getSessionId();
 
       // Ignore messages for other sessions (skip session-less messages like heartbeat_ack)
-      if (msg.sessionId !== undefined && msg.sessionId !== sessionId) {
-        console.error(`[dashboard] Ignoring message type=${msg.type} for session ${msg.sessionId}, current session is ${sessionId}`);
+      if ((msg as any).sessionId !== undefined && (msg as any).sessionId !== sessionId) {
+        console.error(`[dashboard] Ignoring message type=${msg.type} for session ${(msg as any).sessionId}, current session is ${sessionId}`);
         return undefined;
       }
 

package/packages/extension/src/dashboard-default-adapter.ts

@@ -0,0 +1,37 @@
+/**
+ * DashboardDefaultAdapter — built-in adapter that renders all prompts
+ * as generic interactive dialogs in the dashboard chat area.
+ *
+ * This is the fallback when no other adapter claims with a custom component.
+ * Always registered — works without pi-flows.
+ */
+
+import type { PromptAdapter, PromptRequest, PromptResponse, PromptClaim } from "./prompt-bus.js";
+
+export class DashboardDefaultAdapter implements PromptAdapter {
+  readonly name = "dashboard-default";
+
+  onRequest(_prompt: PromptRequest): PromptClaim {
+    return {
+      component: {
+        type: "generic-dialog",
+        props: {
+          question: _prompt.question,
+          type: _prompt.type,
+          options: _prompt.options,
+          defaultValue: _prompt.defaultValue,
+        },
+      },
+      placement: "inline",
+    };
+  }
+
+  onResponse(_response: PromptResponse): void {
+    // Dismiss is handled by the bus via onDashboardDismiss callback.
+    // No extra work needed here — the bus sends prompt_dismiss for us.
+  }
+
+  onCancel(_id: string): void {
+    // Cleanup is handled by the bus via onDashboardCancel callback.
+  }
+}

package/packages/extension/src/flow-event-wiring.ts

@@ -36,6 +36,8 @@ export const FLOW_EVENT_MAP: Record<string, string> = {
   "flow:architect-context-generating": "architect_context_generating",
   "flow:architect-context-ready": "architect_context_ready",
   "flow:architect-run-handoff": "architect_run_handoff",
+  // Autonomous mode feedback
+  "flow:autonomous-mode-changed": "flow_autonomous_changed",
 };
 
 /** Map of pi-subagents event names to dashboard protocol event types */
@@ -76,27 +78,8 @@ export function registerFlowEventListeners(
   // Note: event_forward sending for flow and subagent events is handled by
   // the EventBus emit intercept in bridge.ts (catch-all forwarding).
 
-  // Forward architect prompt requests directly to the dashboard widget bar.
-  // Non-architect prompts still go through ui-proxy (flow-tui -> ctx.ui.select -> extension_ui_request).
-  // Both paths race -- first response wins via emitPromptAndAwait's resolved guard.
-  pi.events.on("flow:prompt-request", (data: unknown) => {
-    if (!isSessionReady()) return;
-    const req = data as { id?: string; pipeline?: string; type?: string; question?: string; options?: string[]; defaultValue?: string };
-    if (!req.id || !req.pipeline?.startsWith("architect-")) return;
-    connection.send({
-      type: "event_forward",
-      sessionId: bc.sessionId,
-      event: {
-        eventType: "architect_prompt_request",
-        timestamp: Date.now(),
-        data: {
-          id: req.id,
-          promptType: req.type,
-          question: req.question,
-          options: req.options,
-          defaultValue: req.defaultValue,
-        },
-      },
-    });
-  });
+  // Legacy architect prompt forwarding REMOVED.
+  // Previously forwarded flow:prompt-request events with architect-* pipelines
+  // as architect_prompt_request to the dashboard. Now handled by
+  // ArchitectUIAdapter registered with the PromptBus (see architect-ui-adapter.ts).
 }