@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/main/ipc/workflow-handlers.ts

@@ -0,0 +1,108 @@
+import { ipcMain, type IpcMainInvokeEvent } from 'electron'
+import { IPC_CHANNELS, type WorkflowControlResult } from '../../shared/ipc-contracts'
+import { isWorkflowActionAllowed } from '../../shared/workflow-control'
+import { getWorkflowRun, listWorkflowRuns, resolveWorkflowWorkspaces, setWorkflowPersistence } from '../workflow-monitor'
+import { assertTrustedSender, isString } from './validation'
+import { RpcTimeoutError, type PiRpcManager } from '../pi-rpc-manager'
+import type { IpcContext } from './context'
+import { t } from '../../shared/i18n'
+
+/**
+ * The one resolved workspace projection shared by list, getRun and control:
+ * registered workspaces keep their ids (healed in memory when their persisted
+ * path is a lossy phantom), plus read-only `workflow-<key>` projections for
+ * every discovered project that is not registered.
+ */
+async function workflowWorkspaces(ctx: IpcContext) {
+  return resolveWorkflowWorkspaces(ctx.workspaceManager.getWorkspaces())
+}
+
+async function findWorkspace(ctx: IpcContext, workspaceId: string) {
+  const workspaces = await workflowWorkspaces(ctx)
+  return workspaces.find((workspace) => workspace.id === workspaceId) ?? null
+}
+
+/** Probe the workspace's Pi for the `/workflows` extension command. */
+async function hasWorkflowsExtension(pi: PiRpcManager): Promise<boolean> {
+  const command = pi.getEngineKind() === 'omp' ? 'get_available_commands' : 'get_commands'
+  const response = await pi.sendCommand({ type: command }) as
+    | { success?: boolean; data?: { commands?: Array<{ name?: unknown; source?: unknown }> } }
+    | null
+  if (!response?.success || !Array.isArray(response.data?.commands)) return false
+  return response.data.commands.some(
+    (candidate) => candidate?.name === 'workflows' && candidate?.source === 'extension'
+  )
+}
+
+export function registerWorkflowHandlers(ctx: IpcContext): void {
+  ipcMain.handle(IPC_CHANNELS.WORKFLOW_LIST, async (event: IpcMainInvokeEvent) => {
+    assertTrustedSender(event)
+    // The launch-cwd projection must be included here too, not only in
+    // findWorkspace: a run from the current (possibly unregistered) project
+    // has to appear in the navigator list as well as be openable by id.
+    return listWorkflowRuns(await workflowWorkspaces(ctx))
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKFLOW_GET_RUN, async (event: IpcMainInvokeEvent, workspaceId: unknown, runId: unknown) => {
+    assertTrustedSender(event)
+    if (!isString(workspaceId) || !isString(runId)) throw new Error('workspaceId and runId must be strings')
+    const workspace = await findWorkspace(ctx, workspaceId)
+    if (!workspace) throw new Error(t('errors.workspace.notFoundPlain'))
+    const run = await getWorkflowRun(workspace, runId)
+    if (!run) throw new Error(t('errors.workflow.runNotFound'))
+    return run
+  })
+
+  ipcMain.handle(
+    IPC_CHANNELS.WORKFLOW_CONTROL,
+    async (event: IpcMainInvokeEvent, workspaceId: unknown, runId: unknown, action: unknown): Promise<WorkflowControlResult> => {
+      assertTrustedSender(event)
+      if (!isString(workspaceId) || !isString(runId) || (action !== 'stop' && action !== 'resume')) {
+        throw new Error('workspaceId, runId and action are required')
+      }
+      const fail = (reason: WorkflowControlResult['reason']): WorkflowControlResult => ({ action, runId, ok: false, reason })
+
+      // Gate on the persisted status first (never fake a transition locally).
+      const workspace = await findWorkspace(ctx, workspaceId)
+      if (!workspace) return fail('no-pi')
+      const run = await getWorkflowRun(workspace, runId)
+      if (!run) return fail('status-not-permitted')
+      if (!isWorkflowActionAllowed(action, run.status)) return fail('status-not-permitted')
+
+      // Route to the run's OWN session runtime, never the active one. A
+      // missing session identity is unsafe to guess, so fail closed.
+      if (!run.sessionId) return fail('no-pi')
+      const pi = ctx.workspaceManager.getPiManagerForSession(workspaceId, run.sessionId)
+      if (!pi) return fail('no-pi')
+
+      // A matched but stopped runtime cannot answer the probe below: sendCommand
+      // throws 'Pi process is not running' and the catch would relabel that as a
+      // missing extension. Report the real reason instead.
+      if (pi.getStatus().status !== 'running') return fail('pi-not-running')
+
+      // The extension command is what executes the control; only dispatch when
+      // it is actually registered in that Pi process. Without this probe an
+      // unloaded extension would fall through to a real LLM prompt turn.
+      try {
+        if (!(await hasWorkflowsExtension(pi))) return fail('extension-missing')
+      } catch {
+        return fail('extension-missing')
+      }
+
+      try {
+        // Extension commands execute immediately in Pi, even during streaming —
+        // no LLM turn is started for a registered command.
+        await pi.sendCommand({ type: 'prompt', message: `/workflows ${action} ${runId}` })
+        return { action, runId, ok: true, dispatched: true }
+      } catch (error) {
+        return fail(error instanceof RpcTimeoutError ? 'timeout' : 'dispatch-failed')
+      }
+    }
+  )
+
+  ipcMain.handle(IPC_CHANNELS.WORKFLOW_SET_PERSISTENCE, async (event: IpcMainInvokeEvent, enabled: unknown) => {
+    assertTrustedSender(event)
+    if (typeof enabled !== 'boolean') throw new Error('enabled must be a boolean')
+    await setWorkflowPersistence(enabled)
+  })
+}

package/apps/sessrumnir/src/main/ipc/workspace-activity-wiring.ts

@@ -0,0 +1,179 @@
+import { ipcMain, Notification, type BrowserWindow } from 'electron'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import type { PiProcessStatus, WorkspaceActivationIntent } from '../../shared/ipc-contracts'
+import {
+  createWorkspaceActivityTracker,
+  type WorkspaceActivityNotification,
+  type WorkspaceActivityTracker,
+} from '../workspace-activity'
+import { shouldNotify } from '../notify-decision'
+import { appLog } from '../app-log'
+import { loadAppSettings } from './settings'
+import type { IpcContext } from './context'
+import { t } from '../../shared/i18n'
+
+// An explicit map, not a template-literal key built from the notification
+// kind: `kind`'s type is the indexed-access type
+// `WorkspaceActivityNotification['kind']`, and the extractor's static
+// analysis cannot trace a template literal through that (verified: a
+// directly union-typed parameter, as in permission-mode.ts's
+// `getPermissionModeLabel`, extracts fine — an indexed-access type does
+// not), so it would report the individual notification keys below as unused.
+const NOTIFICATION_KEYS = {
+  completed: 'notifications.completed',
+  failed: 'notifications.failed',
+  'needs-approval': 'notifications.needs-approval',
+} as const satisfies Record<WorkspaceActivityNotification['kind'], string>
+
+function notificationBody(kind: WorkspaceActivityNotification['kind'], opensSession: boolean): string {
+  const body = t(NOTIFICATION_KEYS[kind])
+  return opensSession ? t('notifications.withSession', { body }) : body
+}
+
+export interface WindowControls {
+  getWindow(): BrowserWindow | null
+  /** Show the main window, creating it if it was fully closed (macOS). */
+  showWindow(): void
+}
+
+/**
+ * Wires the per-workspace activity tracker: feeds it every manager's turn and
+ * process signals, broadcasts the derived map to the renderer, registers the
+ * snapshot channel, and raises desktop notifications for background events.
+ *
+ * Returns the tracker so the composition root can feed it the router's
+ * pending-prompt counts (the one signal that originates router-side).
+ */
+export function wireWorkspaceActivity(
+  ctx: IpcContext,
+  windowControls: WindowControls,
+  iconPath: string,
+): WorkspaceActivityTracker {
+  const { workspaceManager } = ctx
+  const { getWindow, showWindow } = windowControls
+  // Activation intent from a notification clicked while no window existed;
+  // the freshly created renderer pulls it once its subscriptions are live.
+  let pendingActivation: WorkspaceActivationIntent | null = null
+
+  const showNotification = async (
+    notification: WorkspaceActivityNotification,
+  ): Promise<void> => {
+    const settings = await loadAppSettings(workspaceManager)
+    const window = getWindow()
+    const permitted = shouldNotify({
+      enabled: settings.desktopNotifications,
+      windowFocused: window?.isFocused() ?? false,
+      eventWorkspaceId: notification.workspaceId,
+      activeWorkspaceId: workspaceManager.getActiveWorkspaceId(),
+    })
+    if (!permitted || !Notification.isSupported()) return
+
+    const workspace = workspaceManager
+      .getWorkspaces()
+      .find((ws) => ws.id === notification.workspaceId)
+    if (!workspace) return
+
+    const osNotification = new Notification({
+      title: workspace.name,
+      body: notificationBody(notification.kind, Boolean(notification.sessionPath)),
+      ...(iconPath ? { icon: iconPath } : {}),
+    })
+    osNotification.on('click', () => {
+      // The workspace can be removed between showing and clicking; a stale
+      // click should just bring the app forward, not run confirm dialogs for
+      // a doomed switch.
+      const stillExists = workspaceManager
+        .getWorkspaces()
+        .some((ws) => ws.id === notification.workspaceId)
+      // Always stash AND broadcast: a webContents.send only lands if the
+      // renderer's subscription is already live, which a click during boot,
+      // reload, or with the window closed cannot guarantee. A renderer that
+      // does receive the broadcast consumes the stash immediately; one that
+      // missed it pulls the stash when its subscriptions come up.
+      const intent: WorkspaceActivationIntent = {
+        workspaceId: notification.workspaceId,
+        ...(notification.sessionPath ? { sessionPath: notification.sessionPath } : {}),
+        ...(notification.runtimeId ? { runtimeId: notification.runtimeId } : {}),
+      }
+      if (stillExists) pendingActivation = intent
+      const win = getWindow()
+      if (win) {
+        if (win.isMinimized()) win.restore()
+        win.show()
+        win.focus()
+        // The renderer owns workspace activation (it runs the streaming and
+        // dirty-editor confirms), so hand it the intent instead of switching
+        // main-side and desyncing its store.
+        if (stillExists) {
+          ctx.broadcast(IPC_CHANNELS.EVENT_ACTIVATE_WORKSPACE, intent)
+        }
+      } else {
+        // macOS: the window may be fully closed — recreate it; the fresh
+        // renderer pulls the stashed intent once its subscriptions are live.
+        showWindow()
+      }
+    })
+    osNotification.show()
+  }
+
+  const tracker = createWorkspaceActivityTracker({
+    getActiveWorkspaceId: () => workspaceManager.getActiveWorkspaceId(),
+    now: () => Date.now(),
+    onChange: (map) => ctx.broadcast(IPC_CHANNELS.EVENT_WORKSPACE_ACTIVITY, map),
+    onNotify: (notification) => {
+      void showNotification(notification).catch((err) => {
+        appLog.warn('notifications', 'Failed to show desktop notification', err)
+      })
+    },
+  })
+
+  // Every manager (existing and future) feeds the tracker; the workspace id is
+  // resolved at event time so pre-registration races cannot mislabel events.
+  workspaceManager.onPiManager((manager) => {
+    const workspaceIdOf = (): string | null => workspaceManager.workspaceIdFor(manager)
+    const sessionTarget = (): { runtimeId?: string; sessionPath?: string } => {
+      const sessionPath = workspaceManager.sessionPathFor(manager)
+      const runtimeId = workspaceManager.runtimeIdFor(manager)
+      return {
+        ...(sessionPath ? { sessionPath } : {}),
+        ...(runtimeId ? { runtimeId } : {}),
+      }
+    }
+    manager.on('agent_start', () => {
+      const id = workspaceIdOf()
+      if (id) tracker.handleAgentStart(id, sessionTarget())
+    })
+    manager.on('agent_end', () => {
+      const id = workspaceIdOf()
+      if (id) tracker.handleAgentEnd(id, sessionTarget())
+    })
+    manager.on('status-change', (status: PiProcessStatus) => {
+      const id = workspaceIdOf()
+      if (id) tracker.handleStatusChange(id, status, sessionTarget())
+    })
+    // Only unexpected death emits 'exit' (deliberate stop() detaches
+    // listeners first) — this is what distinguishes a crash from a stop.
+    manager.on('exit', () => {
+      const id = workspaceIdOf()
+      if (id) tracker.handleProcessExit(id, sessionTarget())
+    })
+  })
+
+  workspaceManager.onActiveWorkspaceChanged((workspaceId) => {
+    if (workspaceId) tracker.handleWorkspaceSeen(workspaceId)
+  })
+
+  workspaceManager.onWorkspaceRemoved((workspaceId) => {
+    tracker.handleWorkspaceRemoved(workspaceId)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_ACTIVITY_GET, async () => tracker.getMap())
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_TAKE_PENDING_ACTIVATION, async () => {
+    const intent = pendingActivation
+    pendingActivation = null
+    return intent
+  })
+
+  return tracker
+}

package/apps/sessrumnir/src/main/ipc/workspace-handlers.ts

@@ -0,0 +1,133 @@
+import { ipcMain } from 'electron'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { isString, isObject, isOptionalBoolean, isOptionalString } from './validation'
+import { validateStartOptions, applyResumePreference, applyPermissionModeToStartOptions } from './pi-start-options'
+import { loadAppSettings } from './settings'
+import type { WorkspaceTabOptions } from '../../shared/ipc-contracts'
+import { isWithinSessionRoots } from '../pi-paths'
+import { existsSync } from 'fs'
+import type { IpcContext } from './context'
+import { appLog } from '../app-log'
+import { t } from '../../shared/i18n'
+
+function validateWorkspaceTabOptions(value: unknown): WorkspaceTabOptions {
+  if (value === undefined || value === null) return {}
+  if (!isObject(value)) throw new Error('Tab options must be an object')
+  if (!isOptionalString(value.name)) throw new Error('tab name must be a string')
+  if (!isOptionalString(value.sourceWorkspaceId)) throw new Error('sourceWorkspaceId must be a string')
+  if (!isOptionalString(value.forkSessionPath)) throw new Error('forkSessionPath must be a string')
+  if (!isOptionalString(value.taskPrompt)) throw new Error('taskPrompt must be a string')
+  if (!isOptionalBoolean(value.startPi)) throw new Error('startPi must be a boolean')
+
+  return {
+    ...(isString(value.name) ? { name: value.name } : {}),
+    ...(isString(value.sourceWorkspaceId) ? { sourceWorkspaceId: value.sourceWorkspaceId } : {}),
+    ...(isString(value.forkSessionPath) ? { forkSessionPath: value.forkSessionPath } : {}),
+    ...(isString(value.taskPrompt) ? { taskPrompt: value.taskPrompt } : {}),
+    ...(typeof value.startPi === 'boolean' ? { startPi: value.startPi } : {}),
+  }
+}
+
+export function registerWorkspaceHandlers(ctx: IpcContext): void {
+  const { workspaceManager, notesManager } = ctx
+
+  // ─── Workspace Management ───────────────────────────────────────────────
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_LIST, async () => {
+    return workspaceManager.getWorkspaces()
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_CREATE, async (_event, name: unknown, path: unknown) => {
+    if (!isString(name)) throw new Error('name must be a string')
+    if (!isString(path)) throw new Error('path must be a string')
+    return workspaceManager.createWorkspace(name, path)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_REMOVE, async (_event, workspaceId: unknown) => {
+    if (!isString(workspaceId)) throw new Error('workspaceId must be a string')
+    const result = await workspaceManager.removeWorkspace(workspaceId)
+    // Notes scoped to the removed workspace fall back to global so they survive.
+    await notesManager.reassignToGlobal(workspaceId)
+    return result
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_RENAME, async (_event, workspaceId: unknown, name: unknown) => {
+    if (!isString(workspaceId)) throw new Error('workspaceId must be a string')
+    if (!isString(name)) throw new Error('name must be a string')
+    await workspaceManager.renameWorkspace(workspaceId, name)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_CHANGE_PATH, async (_event, workspaceId: unknown, newPath: unknown) => {
+    if (!isString(workspaceId)) throw new Error('workspaceId must be a string')
+    if (!isString(newPath)) throw new Error('newPath must be a string')
+    await workspaceManager.changeWorkspacePath(workspaceId, newPath)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_PATH_EXISTS, async (): Promise<boolean> => {
+    return workspaceManager.activeWorkspacePathExists()
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_SET_ACTIVE, async (_event, workspaceId: unknown) => {
+    if (!isString(workspaceId)) throw new Error('workspaceId must be a string')
+    return workspaceManager.setActiveWorkspace(workspaceId)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_GET_ACTIVE, async () => {
+    return workspaceManager.getActiveWorkspace()
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_START_PI, async (_event, workspaceId: unknown, options?: unknown) => {
+    if (!isString(workspaceId)) throw new Error('workspaceId must be a string')
+    const opts = validateStartOptions(options)
+    const settings = await loadAppSettings(workspaceManager)
+    const workspace = workspaceManager.getWorkspaces().find((w) => w.id === workspaceId)
+    if (!workspace) throw new Error(t('errors.workspace.notFound', { workspaceId }))
+    await workspaceManager.startPiForWorkspace(
+      workspaceId,
+      applyPermissionModeToStartOptions(
+        applyResumePreference({ cwd: workspace.path, ...opts }, settings),
+        settings
+      )
+    )
+    const pi = workspaceManager.getPiManager(workspaceId)
+    return pi?.getStatus() ?? { status: 'stopped', pid: null, error: null }
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_STOP_PI, async (_event, workspaceId: unknown) => {
+    if (!isString(workspaceId)) throw new Error('workspaceId must be a string')
+    workspaceManager.stopPiForWorkspace(workspaceId)
+    return { status: 'stopped', pid: null, error: null }
+  })
+
+  ipcMain.handle(IPC_CHANNELS.WORKSPACE_CREATE_TAB, async (_event, value: unknown) => {
+    const options = validateWorkspaceTabOptions(value)
+    if (options.forkSessionPath) {
+      if (!isWithinSessionRoots(options.forkSessionPath) || !existsSync(options.forkSessionPath)) {
+        throw new Error(t('errors.session.pathMustExist', { field: 'forkSessionPath' }))
+      }
+    }
+
+    const settings = await loadAppSettings(workspaceManager)
+    const workspace = await workspaceManager.createWorktreeWorkspace(options)
+    // Return the new project tab immediately. Its session runtime starts in the
+    // background so the tab/file contents are usable before Pi is ready. A task
+    // launch may explicitly skip this default runtime to avoid two Pi processes
+    // in the freshly-created worktree.
+    if (options.startPi !== false) void workspaceManager.startPiForWorkspace(
+      workspace.id,
+      applyPermissionModeToStartOptions(
+        applyResumePreference(
+          {
+            cwd: workspace.path,
+            provider: settings.defaultProvider ?? undefined,
+            model: settings.defaultModel ?? undefined,
+            forkSessionPath: options.forkSessionPath,
+          },
+          settings
+        ),
+        settings
+      )
+    ).catch((error) => appLog.warn('workspaces', 'Background worktree Pi start failed', error))
+    return workspace
+  })
+}

package/apps/sessrumnir/src/main/ipc-handlers.ts

@@ -0,0 +1,98 @@
+import { ipcMain, type IpcMainInvokeEvent } from 'electron'
+import { createExtensionUiRouter, wireExtensionUiIpc } from './extension-ui-ipc'
+import { WorkspaceManager } from './workspace-manager'
+import { IPC_CHANNELS } from '../shared/ipc-contracts'
+import { createIpcContext } from './ipc/context'
+import { assertTrustedSender } from './ipc/validation'
+import { registerPiHandlers } from './ipc/pi-handlers'
+import { registerTerminalHandlers } from './ipc/terminal-handlers'
+import { registerSessionHandlers } from './ipc/session-handlers'
+import { registerModelHandlers } from './ipc/model-handlers'
+import { registerSettingsHandlers } from './ipc/settings'
+import { registerPermissionRulesHandlers } from './ipc/permission-rules-handlers'
+import { registerThemeHandlers } from './ipc/theme-handlers'
+import { registerWorkspaceHandlers } from './ipc/workspace-handlers'
+import { registerPackageHandlers } from './ipc/package-handlers'
+import { registerSkillsMcpHandlers } from './ipc/skills-mcp-handlers'
+import { registerModelsConfigHandlers } from './ipc/models-config-handlers'
+import { registerCouncilHandlers } from './ipc/council-handlers'
+import { registerTagHandlers } from './ipc/tag-handlers'
+import { registerNotesHandlers } from './ipc/notes-handlers'
+import { registerFileHandlers } from './ipc/file-handlers'
+import { registerGitConveyorHandlers } from './ipc/git-conveyor-handlers'
+import { registerSystemHandlers } from './ipc/system-handlers'
+import { registerUpdateHandlers } from './ipc/update-handlers'
+import { registerDiagnosticsHandlers } from './ipc/diagnostics-handlers'
+import { registerWorkflowHandlers } from './ipc/workflow-handlers'
+import { wireWorkspaceActivity, type WindowControls } from './ipc/workspace-activity-wiring'
+
+export { loadAppSettings, saveAppSettings } from './ipc/settings'
+
+/**
+ * Registers all IPC handlers that the renderer can invoke.
+ *
+ * Security: every handler validates its input types before processing.
+ * The preload bridge is the only path from renderer to these handlers.
+ */
+export function registerIpcHandlers(
+  workspaceManager: WorkspaceManager,
+  windowControls: WindowControls = { getWindow: () => null, showWindow: () => {} },
+  iconPath = '',
+): void {
+  const ctx = createIpcContext(workspaceManager)
+
+  // Session runtime snapshots are separate from workspace activity: several
+  // live Pi processes may share one project cwd.
+  workspaceManager.onSessionRuntime((runtime) => {
+    ctx.broadcast(IPC_CHANNELS.EVENT_SESSION_RUNTIME, runtime)
+  })
+
+  registerPiHandlers(ctx)
+  registerTerminalHandlers(ctx)
+  registerSessionHandlers(ctx)
+  registerModelHandlers(ctx)
+  registerSettingsHandlers(ctx)
+  registerPermissionRulesHandlers(ctx)
+  registerThemeHandlers()
+  registerWorkspaceHandlers(ctx)
+  registerPackageHandlers(ctx)
+  registerSkillsMcpHandlers(ctx)
+  registerModelsConfigHandlers(ctx)
+  registerCouncilHandlers(ctx)
+  registerTagHandlers(ctx)
+  registerNotesHandlers(ctx)
+  registerFileHandlers(ctx)
+  registerGitConveyorHandlers(ctx)
+  registerSystemHandlers(ctx)
+  registerUpdateHandlers()
+  registerDiagnosticsHandlers(ctx)
+  registerWorkflowHandlers(ctx)
+
+  // ─── Extension UI Responses and Pi Event Forwarding ─────────────────────
+
+  // Cross-workspace activity map + desktop notifications. Wired before the
+  // router so it can observe the router's pending-prompt counts below.
+  const workspaceActivity = wireWorkspaceActivity(ctx, windowControls, iconPath)
+
+  // Router construction, the dialog-answer channels, the pending-prompt
+  // flush/get pair and the two workspace hooks all live in extension-ui-ipc.ts
+  // so they can be tested without Electron.
+  wireExtensionUiIpc<IpcMainInvokeEvent>({
+    handle: (channel, handler) => ipcMain.handle(channel, handler),
+    assertTrustedSender,
+    router: createExtensionUiRouter({
+      workspace: workspaceManager,
+      broadcast: ctx.broadcast,
+      onPendingCounts: (counts) => workspaceActivity.handlePendingCounts(counts),
+    }),
+    workspace: workspaceManager,
+    broadcast: ctx.broadcast,
+  })
+
+  // Forward debounced file-change events from the active workspace's watcher
+  // so the renderer can refresh the file tree and git status live. The
+  // WorkspaceManager only watches the active workspace, so no filtering here.
+  workspaceManager.onFileChange((event) => {
+    ctx.broadcast(IPC_CHANNELS.EVENT_FILE_CHANGE, event)
+  })
+}

package/apps/sessrumnir/src/main/map-concurrent.test.ts

@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { mapWithConcurrency } from './map-concurrent'
+
+/** Resolves only once released, so overlap is observable. */
+function gate(): { promise: Promise<void>; release: () => void } {
+  let release = (): void => {}
+  const promise = new Promise<void>((resolve) => {
+    release = () => resolve()
+  })
+  return { promise, release }
+}
+
+test('maps every item and keeps results in input order', async () => {
+  const out = await mapWithConcurrency([1, 2, 3, 4, 5], 2, async (n) => n * 10)
+  assert.deepEqual(out, [10, 20, 30, 40, 50])
+})
+
+test('keeps results positional even when later items finish first', async () => {
+  const gates = [gate(), gate()]
+  const running = mapWithConcurrency([0, 1], 2, async (i) => {
+    await gates[i].promise
+    return `item-${i}`
+  })
+  gates[1].release()
+  gates[0].release()
+  assert.deepEqual(await running, ['item-0', 'item-1'])
+})
+
+test('never runs more than the limit concurrently', async () => {
+  const LIMIT = 3
+  let active = 0
+  let peak = 0
+  await mapWithConcurrency(Array.from({ length: 20 }, (_, i) => i), LIMIT, async () => {
+    active += 1
+    peak = Math.max(peak, active)
+    await new Promise((resolve) => setImmediate(resolve))
+    active -= 1
+  })
+  assert.equal(peak, LIMIT, `peak concurrency was ${peak}`)
+})
+
+test('starts a queued item as soon as a slot frees', async () => {
+  // With limit 1 and 3 items, the mapper must be entered 3 times sequentially.
+  const order: number[] = []
+  await mapWithConcurrency([1, 2, 3], 1, async (n) => {
+    order.push(n)
+    await new Promise((resolve) => setImmediate(resolve))
+  })
+  assert.deepEqual(order, [1, 2, 3])
+})
+
+test('returns an empty array for no items without calling the mapper', async () => {
+  let calls = 0
+  const out = await mapWithConcurrency([], 4, async () => {
+    calls += 1
+  })
+  assert.deepEqual(out, [])
+  assert.equal(calls, 0)
+})
+
+test('tolerates a limit larger than the item count', async () => {
+  const out = await mapWithConcurrency([1, 2], 99, async (n) => n + 1)
+  assert.deepEqual(out, [2, 3])
+})
+
+test('treats a non-positive limit as sequential rather than stalling', async () => {
+  const out = await mapWithConcurrency([1, 2, 3], 0, async (n) => n)
+  assert.deepEqual(out, [1, 2, 3])
+})
+
+test('rejects when the mapper throws', async () => {
+  await assert.rejects(
+    () => mapWithConcurrency([1, 2, 3], 2, async (n) => {
+      if (n === 2) throw new Error('mapper failed')
+      return n
+    }),
+    /mapper failed/
+  )
+})

package/apps/sessrumnir/src/main/map-concurrent.ts

@@ -0,0 +1,30 @@
+/**
+ * Run `mapper` over `items` with at most `limit` calls in flight, keeping results
+ * positional. Shared by the session-list and lineage readers, which both fan out
+ * bounded file reads across every session in the store and would otherwise each
+ * carry their own worker pool.
+ *
+ * Rejects on the first mapper rejection, like `Promise.all`.
+ */
+export async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  limit: number,
+  mapper: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+  const results = new Array<R>(items.length)
+  if (items.length === 0) return results
+
+  // A non-positive limit would leave no worker to drain the queue.
+  const workerCount = Math.min(Math.max(1, Math.floor(limit)), items.length)
+  let cursor = 0
+
+  async function worker(): Promise<void> {
+    while (cursor < items.length) {
+      const index = cursor++
+      results[index] = await mapper(items[index], index)
+    }
+  }
+
+  await Promise.all(Array.from({ length: workerCount }, () => worker()))
+  return results
+}