@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/main/diagnostics.ts

@@ -0,0 +1,111 @@
+import { app } from 'electron'
+import { existsSync } from 'fs'
+import { readFile } from 'fs/promises'
+import type { DiagnosticsReport, DiagnosticsWorkspaceInfo } from '../shared/ipc-contracts'
+import {
+  countPathEntries,
+  extractVersionLine,
+  reportModelsReadFailure,
+  reportPiStartFailure,
+  summarizeProviders,
+} from './diagnostics-report'
+import type { WorkspaceManager } from './workspace-manager'
+import { getConfiguredEngineKind, getPiCli, getPiResolution } from './pi-rpc-manager'
+import { workspaceTrustStore } from './workspace-trust'
+import { getOmpSessionsRoot, getSessionsRoot } from './pi-paths'
+import { getGuiDataDir } from './app-data-paths'
+import { appLog } from './app-log'
+import { validatePermissionRulesFile } from '../../resources/permission-rules'
+import { runPiCli } from './ipc/run-pi-cli'
+import { getGlobalPermissionRulesPath } from './ipc/pi-start-options'
+import { getSettingsPath, loadAppSettings } from './ipc/settings'
+import { buildWorkspaceRulesStatus } from './ipc/permission-rules-handlers'
+import { readModelsConfigFile } from './ipc/models-config-handlers'
+
+const PI_VERSION_TIMEOUT_MS = 10_000
+
+async function readGlobalRuleCount(): Promise<{ count: number | null; error: string | null }> {
+  const rulesPath = getGlobalPermissionRulesPath()
+  if (!existsSync(rulesPath)) return { count: 0, error: null }
+  try {
+    const parsed: unknown = JSON.parse(await readFile(rulesPath, 'utf-8'))
+    return { count: validatePermissionRulesFile(parsed).rules.length, error: null }
+  } catch (err) {
+    return { count: null, error: err instanceof Error ? err.message : String(err) }
+  }
+}
+
+export async function collectDiagnostics(
+  workspaceManager: WorkspaceManager,
+): Promise<DiagnosticsReport> {
+  const settings = await loadAppSettings(workspaceManager)
+  const cli = getPiCli()
+  const resolution = getPiResolution()
+
+  const activeWorkspace = workspaceManager.getActiveWorkspace()
+  // A stale workspace path (folder deleted/renamed outside the app) would make
+  // the spawn itself fail on cwd — fall back rather than reporting no version.
+  const versionCwd =
+    activeWorkspace && existsSync(activeWorkspace.path)
+      ? activeWorkspace.path
+      : (process.env.HOME ?? process.cwd())
+  const piVersionResult = cli.found
+    ? await runPiCli(['--version'], versionCwd, PI_VERSION_TIMEOUT_MS)
+    : { success: false, output: '' }
+
+  const workspaces: DiagnosticsWorkspaceInfo[] = workspaceManager.getWorkspaces().map((ws) => ({
+    id: ws.id,
+    name: ws.name,
+    path: ws.path,
+    pathExists: existsSync(ws.path),
+    trusted: workspaceTrustStore.isTrusted(ws.path),
+    piStatus: workspaceManager.getPiManager(ws.id)?.getStatus().status ?? 'stopped',
+  }))
+
+  const modelsRead = await readModelsConfigFile(getConfiguredEngineKind())
+  const providers = 'config' in modelsRead ? summarizeProviders(modelsRead.config, process.env) : null
+  const providersError = 'failure' in modelsRead ? reportModelsReadFailure(modelsRead.location.name, modelsRead.failure) : null
+
+  const globalRules = await readGlobalRuleCount()
+  const sessionsRoot = getConfiguredEngineKind() === 'omp' ? getOmpSessionsRoot() : getSessionsRoot()
+
+  return {
+    generatedAt: Date.now(),
+    app: {
+      version: app.getVersion(),
+      electron: process.versions.electron ?? 'unknown',
+      chrome: process.versions.chrome ?? 'unknown',
+      node: process.versions.node ?? 'unknown',
+      platform: process.platform,
+    },
+    piBinary: {
+      found: cli.found,
+      script: cli.script,
+      source: resolution.source,
+      useNode: cli.useNode,
+      nodeBinary: cli.node,
+      nodeFound: cli.nodeFound,
+      needsShell: cli.needsShell,
+      rejectedOverride: resolution.rejectedOverride,
+      failureReason: reportPiStartFailure(cli.failureReason),
+      pathEntryCount: countPathEntries(resolution.pathEnv, process.platform === 'win32'),
+    },
+    piVersion: piVersionResult.success ? extractVersionLine(piVersionResult.output) : null,
+    workspaces,
+    providers,
+    providersError,
+    permissions: {
+      mode: settings.permissionMode,
+      globalRuleCount: globalRules.count,
+      globalRulesError: globalRules.error,
+      workspace: await buildWorkspaceRulesStatus(workspaceManager),
+    },
+    storage: {
+      guiDataDir: getGuiDataDir(),
+      settingsPath: getSettingsPath(),
+      sessionsRoot,
+      sessionsRootExists: existsSync(sessionsRoot),
+    },
+    recentErrors: appLog.getRecent().filter((entry) => entry.level !== 'info'),
+  }
+}

package/apps/sessrumnir/src/main/editor-guard.test.ts

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { createEditorGuard } from './editor-guard'
+
+test('a fresh guard never prompts', () => {
+  const guard = createEditorGuard()
+  assert.equal(guard.needsPrompt(), false)
+})
+
+test('a dirty buffer prompts until the discard is confirmed', () => {
+  const guard = createEditorGuard()
+  guard.setDirty(true, 'notes.md')
+  assert.equal(guard.needsPrompt(), true)
+
+  guard.confirmDiscard()
+  assert.equal(guard.needsPrompt(), false, 'the confirmed quit must proceed without a second ask')
+})
+
+test('new edits after a confirmed discard re-arm the prompt', () => {
+  const guard = createEditorGuard()
+  guard.setDirty(true, 'notes.md')
+  guard.confirmDiscard()
+
+  guard.setDirty(true, 'notes.md')
+
+  assert.equal(guard.needsPrompt(), true, 'fresh edits are a fresh decision')
+})
+
+test('a clean buffer clears the prompt and the remembered file', () => {
+  const guard = createEditorGuard()
+  guard.setDirty(true, 'notes.md')
+
+  guard.setDirty(false, null)
+
+  assert.equal(guard.needsPrompt(), false)
+  assert.equal(guard.promptMessage(), 'Discard unsaved changes?')
+})
+
+test('reset forgets dirty state and any prior confirmation', () => {
+  const guard = createEditorGuard()
+  guard.setDirty(true, 'notes.md')
+  guard.confirmDiscard()
+
+  guard.reset()
+
+  assert.equal(guard.needsPrompt(), false)
+  guard.setDirty(true, 'other.md')
+  assert.equal(guard.needsPrompt(), true, 'a reloaded renderer starts the decision over')
+})
+
+test('promptMessage names the file when known', () => {
+  const guard = createEditorGuard()
+  guard.setDirty(true, 'notes.md')
+  assert.equal(guard.promptMessage(), 'Discard unsaved changes to notes.md?')
+
+  const nameless = createEditorGuard()
+  nameless.setDirty(true, null)
+  assert.equal(nameless.promptMessage(), 'Discard unsaved changes?')
+})

package/apps/sessrumnir/src/main/editor-guard.ts

@@ -0,0 +1,50 @@
+// Pure decision logic for guarding the renderer's unsaved editor buffer
+// against teardown (quit, window close, reload). Kept free of any `electron`
+// import so it can be unit-tested under a plain Node runtime; the dialog and
+// menu wiring lives in index.ts. The renderer mirrors its dirty flag here on
+// every transition — teardown outruns any renderer-side ask, so the decision
+// has to be local to main.
+
+import { t } from '../shared/i18n'
+
+export interface EditorGuard {
+  /** Mirror of the renderer's dirty flag; new edits re-arm a confirmed discard. */
+  setDirty(dirty: boolean, fileName: string | null): void
+  /** Renderer reloaded or crashed: its buffer is gone, nothing left to guard. */
+  reset(): void
+  /** True when a teardown must pause for the discard confirmation. */
+  needsPrompt(): boolean
+  /** Record an accepted discard so the resumed teardown is not asked again. */
+  confirmDiscard(): void
+  /** Dialog text, naming the dirty file when the renderer reported one. */
+  promptMessage(): string
+}
+
+export function createEditorGuard(): EditorGuard {
+  let dirty = false
+  let fileName: string | null = null
+  let discardConfirmed = false
+
+  return {
+    setDirty(nextDirty, nextFileName) {
+      dirty = nextDirty
+      fileName = nextDirty ? nextFileName : null
+      // Fresh edits are a fresh decision, even right after a confirmed discard.
+      if (nextDirty) discardConfirmed = false
+    },
+    reset() {
+      dirty = false
+      fileName = null
+      discardConfirmed = false
+    },
+    needsPrompt() {
+      return dirty && !discardConfirmed
+    },
+    confirmDiscard() {
+      discardConfirmed = true
+    },
+    promptMessage() {
+      return fileName ? t('editorGuard.discardFile', { fileName }) : t('editorGuard.discard')
+    },
+  }
+}

package/apps/sessrumnir/src/main/extension-ui-ipc.test.ts

@@ -0,0 +1,299 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { PiRpcManager } from './pi-rpc-manager'
+import {
+  createExtensionUiRouter,
+  wireExtensionUiIpc,
+  type ExtensionUiWorkspace,
+} from './extension-ui-ipc'
+import { IPC_CHANNELS } from '../shared/ipc-contracts'
+import type { PendingPromptCounts, PiExtensionUiRequest, PiRpcEvent } from '../shared/ipc-contracts'
+import type { PiEventRouter } from './pi-event-router'
+
+const WS_A = 'ws-a'
+const WS_B = 'ws-b'
+const REQUEST_ID = 'req-1'
+/** Status a manager that was never started reports. */
+const STOPPED_STATUS = { status: 'stopped', pid: null, error: null, engine: 'pi', startupPhase: undefined }
+const PENDING_COUNTS: PendingPromptCounts = { [WS_A]: 2, [WS_B]: 1 }
+
+/** The four channels that answer a blocking extension-UI dialog. */
+const RESPONSE_CHANNELS = [
+  IPC_CHANNELS.UI_SELECT_RESPONSE,
+  IPC_CHANNELS.UI_CONFIRM_RESPONSE,
+  IPC_CHANNELS.UI_INPUT_RESPONSE,
+  IPC_CHANNELS.UI_EDITOR_RESPONSE,
+]
+/** The three whose payload is carried through verbatim as `value`. */
+const VALUE_CHANNELS = [
+  IPC_CHANNELS.UI_SELECT_RESPONSE,
+  IPC_CHANNELS.UI_INPUT_RESPONSE,
+  IPC_CHANNELS.UI_EDITOR_RESPONSE,
+]
+const ALL_CHANNELS = [
+  ...RESPONSE_CHANNELS,
+  IPC_CHANNELS.UI_PENDING_FLUSH,
+  IPC_CHANNELS.UI_PENDING_GET,
+]
+
+/** Stand-in for IpcMainInvokeEvent: only the sender check ever reads it. */
+interface FakeInvokeEvent {
+  trusted: boolean
+}
+
+const TRUSTED: FakeInvokeEvent = { trusted: true }
+const UNTRUSTED: FakeInvokeEvent = { trusted: false }
+
+interface RouterCall {
+  method: string
+  args: unknown[]
+}
+
+interface Broadcast {
+  channel: string
+  data: unknown
+}
+
+interface Harness {
+  invoke(channel: string, event: FakeInvokeEvent, ...args: unknown[]): Promise<unknown>
+  channels(): string[]
+  routerCalls: RouterCall[]
+  broadcasts: Broadcast[]
+  managerListeners: ((manager: PiRpcManager) => void)[]
+  activeListeners: (() => void)[]
+  setActivePi(manager: PiRpcManager | null): void
+}
+
+/** Records every router call instead of running the real routing logic. */
+function recordingRouter(calls: RouterCall[]): PiEventRouter {
+  return {
+    attachManager: (manager) => calls.push({ method: 'attachManager', args: [manager] }),
+    respond: (id, response) => calls.push({ method: 'respond', args: [id, response] }),
+    flush: (workspaceId) => calls.push({ method: 'flush', args: [workspaceId] }),
+    getPendingCounts: () => {
+      calls.push({ method: 'getPendingCounts', args: [] })
+      return PENDING_COUNTS
+    },
+    handleActiveWorkspaceChanged: () =>
+      calls.push({ method: 'handleActiveWorkspaceChanged', args: [] }),
+  }
+}
+
+function createHarness(): Harness {
+  const handlers = new Map<string, (event: FakeInvokeEvent, ...args: unknown[]) => Promise<unknown>>()
+  const routerCalls: RouterCall[] = []
+  const broadcasts: Broadcast[] = []
+  const managerListeners: ((manager: PiRpcManager) => void)[] = []
+  const activeListeners: (() => void)[] = []
+  let activePi: PiRpcManager | null = null
+
+  const workspace: ExtensionUiWorkspace = {
+    getActivePiManager: () => activePi,
+    workspaceIdFor: () => null,
+    onPiManager: (listener) => managerListeners.push(listener),
+    onActiveWorkspaceChanged: (listener) => activeListeners.push(() => listener(null)),
+  }
+
+  wireExtensionUiIpc<FakeInvokeEvent>({
+    handle: (channel, handler) => handlers.set(channel, handler),
+    assertTrustedSender: (event) => {
+      if (!event.trusted) throw new Error('Unauthorized IPC sender')
+    },
+    router: recordingRouter(routerCalls),
+    workspace,
+    broadcast: (channel, data) => broadcasts.push({ channel, data }),
+  })
+
+  return {
+    invoke: (channel, event, ...args) => {
+      const handler = handlers.get(channel)
+      assert.ok(handler, `no handler registered for ${channel}`)
+      return handler(event, ...args)
+    },
+    channels: () => [...handlers.keys()],
+    routerCalls,
+    broadcasts,
+    managerListeners,
+    activeListeners,
+    setActivePi: (manager) => {
+      activePi = manager
+    },
+  }
+}
+
+// --- Response channels ---
+
+test('every extension-UI channel is registered exactly once', () => {
+  const h = createHarness()
+  assert.deepEqual(h.channels().sort(), [...ALL_CHANNELS].sort())
+})
+
+test('value-carrying response channels forward the id and value to the router', async () => {
+  for (const channel of VALUE_CHANNELS) {
+    const h = createHarness()
+    await h.invoke(channel, TRUSTED, REQUEST_ID, 'answer')
+    assert.deepEqual(
+      h.routerCalls,
+      [{ method: 'respond', args: [REQUEST_ID, { value: 'answer' }] }],
+      channel,
+    )
+  }
+})
+
+test('the confirm channel forwards a boolean, whatever the renderer sent', async () => {
+  const h = createHarness()
+  await h.invoke(IPC_CHANNELS.UI_CONFIRM_RESPONSE, TRUSTED, REQUEST_ID, 1)
+  await h.invoke(IPC_CHANNELS.UI_CONFIRM_RESPONSE, TRUSTED, REQUEST_ID, undefined)
+  assert.deepEqual(h.routerCalls, [
+    { method: 'respond', args: [REQUEST_ID, { confirmed: true }] },
+    { method: 'respond', args: [REQUEST_ID, { confirmed: false }] },
+  ])
+})
+
+test('response channels reject a non-string id without touching the router', async () => {
+  for (const channel of RESPONSE_CHANNELS) {
+    const h = createHarness()
+    await assert.rejects(h.invoke(channel, TRUSTED, 42, 'answer'), /id must be a string/, channel)
+    assert.deepEqual(h.routerCalls, [], channel)
+  }
+})
+
+test('every extension-UI channel rejects an untrusted sender before doing anything', async () => {
+  for (const channel of ALL_CHANNELS) {
+    const h = createHarness()
+    await assert.rejects(
+      h.invoke(channel, UNTRUSTED, REQUEST_ID, 'answer'),
+      /Unauthorized IPC sender/,
+      channel,
+    )
+    assert.deepEqual(h.routerCalls, [], channel)
+  }
+})
+
+// --- Pending prompts ---
+
+test('the flush channel flushes the requested workspace', async () => {
+  const h = createHarness()
+  await h.invoke(IPC_CHANNELS.UI_PENDING_FLUSH, TRUSTED, WS_B)
+  assert.deepEqual(h.routerCalls, [{ method: 'flush', args: [WS_B] }])
+})
+
+test('the flush channel rejects a non-string workspaceId', async () => {
+  const h = createHarness()
+  await assert.rejects(
+    h.invoke(IPC_CHANNELS.UI_PENDING_FLUSH, TRUSTED, { id: WS_B }),
+    /workspaceId must be a string/,
+  )
+  assert.deepEqual(h.routerCalls, [])
+})
+
+test('the pending-get channel returns the router counts', async () => {
+  const h = createHarness()
+  assert.deepEqual(await h.invoke(IPC_CHANNELS.UI_PENDING_GET, TRUSTED), PENDING_COUNTS)
+})
+
+// --- Manager and activation hooks ---
+
+test('every Pi manager the workspace announces is attached to the router', () => {
+  const h = createHarness()
+  assert.equal(h.managerListeners.length, 1, 'the wiring must subscribe to new managers')
+  const first = new PiRpcManager()
+  const second = new PiRpcManager()
+  for (const listener of h.managerListeners) {
+    listener(first)
+    listener(second)
+  }
+  assert.deepEqual(h.routerCalls, [
+    { method: 'attachManager', args: [first] },
+    { method: 'attachManager', args: [second] },
+  ])
+})
+
+test('an active-workspace change pushes the new workspace Pi status and refreshes counts', () => {
+  const h = createHarness()
+  h.setActivePi(new PiRpcManager())
+  for (const listener of h.activeListeners) listener()
+  assert.deepEqual(h.broadcasts, [
+    { channel: IPC_CHANNELS.EVENT_PI, data: { type: 'status_change', ...STOPPED_STATUS } },
+  ])
+  assert.deepEqual(h.routerCalls, [{ method: 'handleActiveWorkspaceChanged', args: [] }])
+})
+
+test('an active-workspace change without a Pi manager still refreshes counts', () => {
+  const h = createHarness()
+  h.setActivePi(null)
+  for (const listener of h.activeListeners) listener()
+  assert.deepEqual(h.broadcasts, [], 'there is no status to report')
+  assert.deepEqual(h.routerCalls, [{ method: 'handleActiveWorkspaceChanged', args: [] }])
+})
+
+// --- Router construction ---
+
+interface RouterHarness {
+  broadcasts: Broadcast[]
+  managers: Map<string, PiRpcManager>
+  setActive(workspaceId: string | null): void
+}
+
+/**
+ * Builds the real router the way the app does, over fake workspace lookups, so
+ * the construction wiring itself (which manager is active, which workspace a
+ * manager belongs to, which channel each broadcast uses) is exercised.
+ */
+function createRouterHarness(workspaceIds: string[]): RouterHarness {
+  const broadcasts: Broadcast[] = []
+  const managers = new Map<string, PiRpcManager>()
+  let active: string | null = workspaceIds[0] ?? null
+
+  const workspace: ExtensionUiWorkspace = {
+    getActivePiManager: () => (active !== null ? (managers.get(active) ?? null) : null),
+    workspaceIdFor: (manager) => {
+      for (const [workspaceId, candidate] of managers) {
+        if (candidate === manager) return workspaceId
+      }
+      return null
+    },
+    onPiManager: () => {},
+    onActiveWorkspaceChanged: () => {},
+  }
+
+  const router = createExtensionUiRouter({
+    workspace,
+    broadcast: (channel, data) => broadcasts.push({ channel, data }),
+  })
+  for (const workspaceId of workspaceIds) {
+    const manager = new PiRpcManager()
+    managers.set(workspaceId, manager)
+    router.attachManager(manager)
+  }
+
+  return {
+    broadcasts,
+    managers,
+    setActive: (workspaceId) => {
+      active = workspaceId
+    },
+  }
+}
+
+test('the constructed router broadcasts active-workspace Pi events on the Pi event channel', () => {
+  const h = createRouterHarness([WS_A, WS_B])
+  const event: PiRpcEvent = { type: 'turn_start' }
+  h.managers.get(WS_A)!.emit('event', event)
+  h.managers.get(WS_B)!.emit('event', { type: 'turn_start' })
+  assert.deepEqual(h.broadcasts, [{ channel: IPC_CHANNELS.EVENT_PI, data: event }])
+})
+
+test('the constructed router broadcasts pending counts on the pending-prompts channel', () => {
+  const h = createRouterHarness([WS_A, WS_B])
+  const dialog: PiExtensionUiRequest = {
+    type: 'extension_ui_request',
+    id: 'b1',
+    method: 'confirm',
+    title: 'Approve?',
+  }
+  h.managers.get(WS_B)!.emit('event', dialog)
+  assert.deepEqual(h.broadcasts, [
+    { channel: IPC_CHANNELS.EVENT_PENDING_PROMPTS, data: { [WS_B]: 1 } },
+  ])
+})

package/apps/sessrumnir/src/main/extension-ui-ipc.ts

@@ -0,0 +1,117 @@
+import { IPC_CHANNELS, type PendingPromptCounts } from '../shared/ipc-contracts'
+import { createPiEventRouter, type PiEventRouter } from './pi-event-router'
+import type { PiRpcManager } from './pi-rpc-manager'
+
+/**
+ * Wiring for the extension-UI half of the IPC surface: the Pi event router,
+ * the four channels that answer a blocking dialog (select/confirm/input/
+ * editor), the pending-prompt flush/get pair, and the two workspace hooks that
+ * keep them fed.
+ *
+ * Electron-free: the handler registrar, the sender check, the broadcaster and
+ * the workspace registry all arrive as deps, so ipc-handlers passes the real
+ * ipcMain.handle / assertTrustedSender / BrowserWindow broadcast /
+ * WorkspaceManager while tests drive the same code with recording fakes.
+ */
+
+/** Registers one invoke handler; the shape of Electron's ipcMain.handle. */
+export type IpcInvokeRegistrar<TEvent> = (
+  channel: string,
+  handler: (event: TEvent, ...args: unknown[]) => Promise<unknown>,
+) => void
+
+/** The slice of WorkspaceManager this wiring depends on. */
+export interface ExtensionUiWorkspace {
+  getActivePiManager(): PiRpcManager | null
+  workspaceIdFor(manager: PiRpcManager): string | null
+  onPiManager(listener: (manager: PiRpcManager) => void): void
+  onActiveWorkspaceChanged(listener: (workspaceId: string | null) => void): void
+}
+
+/** Send one payload to every renderer window. */
+export type ChannelBroadcast = (channel: string, data: unknown) => void
+
+export interface ExtensionUiIpcDeps<TEvent> {
+  handle: IpcInvokeRegistrar<TEvent>
+  /** Rejects any sender frame that is not the app's own renderer. */
+  assertTrustedSender: (event: TEvent) => void
+  router: PiEventRouter
+  workspace: ExtensionUiWorkspace
+  broadcast: ChannelBroadcast
+}
+
+/**
+ * Build the router that carries Pi events to the renderer and holds blocking
+ * extension-UI prompts from ANY workspace, so an answer can always reach the
+ * Pi that asked — see pi-event-router.ts for the retention rules.
+ */
+export function createExtensionUiRouter(deps: {
+  workspace: ExtensionUiWorkspace
+  broadcast: ChannelBroadcast
+  /** Optional main-side observer of pending-count changes (activity tracker). */
+  onPendingCounts?: (counts: PendingPromptCounts) => void
+}): PiEventRouter {
+  return createPiEventRouter({
+    getActiveManager: () => deps.workspace.getActivePiManager(),
+    workspaceIdFor: (manager) => deps.workspace.workspaceIdFor(manager),
+    broadcastEvent: (event) => deps.broadcast(IPC_CHANNELS.EVENT_PI, event),
+    broadcastPendingCounts: (counts) => {
+      deps.onPendingCounts?.(counts)
+      deps.broadcast(IPC_CHANNELS.EVENT_PENDING_PROMPTS, counts)
+    },
+    now: () => Date.now(),
+  })
+}
+
+export function wireExtensionUiIpc<TEvent>(deps: ExtensionUiIpcDeps<TEvent>): void {
+  const { handle, assertTrustedSender, router, workspace, broadcast } = deps
+
+  // All four dialog answers route through the router so they reach the ORIGIN
+  // Pi — the one that asked — not whichever workspace happens to be active now.
+  const handleDialogResponse = (
+    channel: string,
+    toResponse: (payload: unknown) => Record<string, unknown>,
+  ): void => {
+    handle(channel, async (event, id: unknown, payload: unknown) => {
+      assertTrustedSender(event)
+      if (typeof id !== 'string') throw new Error('id must be a string')
+      router.respond(id, toResponse(payload))
+    })
+  }
+
+  handleDialogResponse(IPC_CHANNELS.UI_SELECT_RESPONSE, (value) => ({ value }))
+  handleDialogResponse(IPC_CHANNELS.UI_CONFIRM_RESPONSE, (confirmed) => ({ confirmed: !!confirmed }))
+  handleDialogResponse(IPC_CHANNELS.UI_INPUT_RESPONSE, (value) => ({ value }))
+  handleDialogResponse(IPC_CHANNELS.UI_EDITOR_RESPONSE, (value) => ({ value }))
+
+  handle(IPC_CHANNELS.UI_PENDING_FLUSH, async (event, workspaceId: unknown) => {
+    assertTrustedSender(event)
+    if (typeof workspaceId !== 'string') throw new Error('workspaceId must be a string')
+    router.flush(workspaceId)
+  })
+
+  handle(IPC_CHANNELS.UI_PENDING_GET, async (event) => {
+    assertTrustedSender(event)
+    return router.getPendingCounts()
+  })
+
+  // Every Pi manager feeds the router. It forwards non-dialog events ONLY from
+  // the currently-active workspace's manager (the renderer's piStatus is a
+  // single global, so status from inactive workspaces would make the green dot
+  // lie), while blocking extension-UI dialogs from ANY workspace are retained
+  // and queued instead of dropped — dropping one deadlocks that workspace's
+  // turn, since Pi holds the tool call until an answer arrives.
+  workspace.onPiManager((manager) => {
+    router.attachManager(manager)
+  })
+
+  // Push the active workspace's Pi status to the renderer whenever the active
+  // workspace changes, so the status indicator reflects the new workspace
+  // even if its Pi manager hasn't emitted any events recently. The router's
+  // counts re-broadcast keeps the pending-prompt badges in step with it.
+  workspace.onActiveWorkspaceChanged(() => {
+    const pi = workspace.getActivePiManager()
+    if (pi) broadcast(IPC_CHANNELS.EVENT_PI, { type: 'status_change', ...pi.getStatus() })
+    router.handleActiveWorkspaceChanged()
+  })
+}