@brimveyn/aimux 1.3.1 → 1.4.1

package/src/pty/pty-manager.ts

@@ -79,8 +79,98 @@ function getTerminalModes(emulator: XTerm, alternateScrollMode: boolean): Termin
   }
 }
 
+function envInt(name: string, fallback: number): number {
+  const raw = process.env[name]
+  if (raw === undefined) return fallback
+  const parsed = Number(raw)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback
+}
+
+const RENDER_COALESCE_MS = 16
+const DATA_DEBOUNCE_MS = envInt('AIMUX_RENDER_DEBOUNCE_MS', 32)
+const BURST_MAX_MS = envInt('AIMUX_RENDER_BURST_MS', 500)
+
 export class PtyManager extends EventEmitter<PtyManagerEvents> {
   private sessions = new Map<string, SessionHandle>()
+  private pendingFlushes = new Map<string, ReturnType<typeof setTimeout>>()
+  private pendingBurstCaps = new Map<string, ReturnType<typeof setTimeout>>()
+
+  private clearTimers(tabId: string): void {
+    const flush = this.pendingFlushes.get(tabId)
+    if (flush) {
+      clearTimeout(flush)
+      this.pendingFlushes.delete(tabId)
+    }
+    const burst = this.pendingBurstCaps.get(tabId)
+    if (burst) {
+      clearTimeout(burst)
+      this.pendingBurstCaps.delete(tabId)
+    }
+  }
+
+  private scheduleRender(session: SessionHandle): void {
+    if (this.pendingFlushes.has(session.tabId)) {
+      return
+    }
+    const timer = setTimeout(() => {
+      this.pendingFlushes.delete(session.tabId)
+      if (this.sessions.get(session.tabId) !== session) {
+        return
+      }
+      const burst = this.pendingBurstCaps.get(session.tabId)
+      if (burst) {
+        clearTimeout(burst)
+        this.pendingBurstCaps.delete(session.tabId)
+      }
+      this.emitRenderIfChanged(session)
+    }, RENDER_COALESCE_MS)
+    this.pendingFlushes.set(session.tabId, timer)
+  }
+
+  private scheduleDataRender(session: SessionHandle): void {
+    const existingFlush = this.pendingFlushes.get(session.tabId)
+    if (existingFlush) {
+      clearTimeout(existingFlush)
+    }
+    const flushTimer = setTimeout(() => {
+      this.pendingFlushes.delete(session.tabId)
+      if (this.sessions.get(session.tabId) !== session) {
+        return
+      }
+      if (session.pendingWrites > 0) {
+        this.scheduleDataRender(session)
+        return
+      }
+      const burst = this.pendingBurstCaps.get(session.tabId)
+      if (burst) {
+        clearTimeout(burst)
+        this.pendingBurstCaps.delete(session.tabId)
+      }
+      this.emitRenderIfChanged(session)
+    }, DATA_DEBOUNCE_MS)
+    this.pendingFlushes.set(session.tabId, flushTimer)
+
+    if (!this.pendingBurstCaps.has(session.tabId)) {
+      const burstTimer = setTimeout(() => {
+        this.pendingBurstCaps.delete(session.tabId)
+        if (this.sessions.get(session.tabId) !== session) {
+          return
+        }
+        const flush = this.pendingFlushes.get(session.tabId)
+        if (flush) {
+          clearTimeout(flush)
+          this.pendingFlushes.delete(session.tabId)
+        }
+        this.emitRenderIfChanged(session)
+      }, BURST_MAX_MS)
+      this.pendingBurstCaps.set(session.tabId, burstTimer)
+    }
+  }
+
+  private flushRenderNow(session: SessionHandle): void {
+    this.clearTimers(session.tabId)
+    this.emitRenderIfChanged(session)
+  }
 
   private emitRenderIfChanged(session: SessionHandle): void {
     const nextSnapshot = snapshotTerminal(session.emulator, session.cursorVisible)
@@ -116,7 +206,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     this.sessions.delete(session.tabId)
-    this.emitRenderIfChanged(session)
+    this.flushRenderNow(session)
     session.emulator.dispose()
     logDebug('ptyManager.finalize', { exitCode, tabId: session.tabId })
     this.emit('exit', session.tabId, exitCode)
@@ -188,9 +278,10 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         session.cursorVisible = trackedModes.cursorVisible
         session.pendingModeSequence = trackedModes.pendingSequence
         session.pendingWrites += 1
+        this.scheduleDataRender(session)
         emulator.write(data, () => {
           session.pendingWrites -= 1
-          this.emitRenderIfChanged(session)
+          this.scheduleDataRender(session)
 
           if (session.pendingWrites === 0 && session.pendingExitCode !== null) {
             this.finalizeSession(session, session.pendingExitCode)
@@ -215,7 +306,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
 
       this.sessions.set(options.tabId, session)
       logDebug('ptyManager.create.success', { tabId: options.tabId })
-      this.emitRenderIfChanged(session)
+      this.scheduleRender(session)
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
       logDebug('ptyManager.create.error', { error: message, tabId: options.tabId })
@@ -224,7 +315,9 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
   }
 
   write(tabId: string, input: string): void {
-    this.sessions.get(tabId)?.pty.write(input)
+    const session = this.sessions.get(tabId)
+    if (!session) return
+    session.pty.write(input)
   }
 
   scrollViewport(tabId: string, deltaLines: number): void {
@@ -234,7 +327,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     session.emulator.scrollLines(deltaLines)
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   scrollViewportToBottom(tabId: string): void {
@@ -244,7 +337,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     }
 
     session.emulator.scrollToBottom()
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   private applyScrollIntent(session: SessionHandle, intent: ScrollIntent | undefined): void {
@@ -262,7 +355,12 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.emulator.scrollToLine(Math.max(0, intent.absoluteLine))
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
     const safeCols = Math.max(20, cols)
     const safeRows = Math.max(8, rows)
 
@@ -270,11 +368,21 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       session.pty.resize(safeCols, safeRows)
       session.emulator.resize(safeCols, safeRows)
       this.applyScrollIntent(session, intents?.get(session.tabId))
-      this.emitRenderIfChanged(session)
+      if (options?.sync) {
+        this.flushRenderNow(session)
+      } else {
+        this.scheduleRender(session)
+      }
     }
   }
 
-  resizeSession(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeSession(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void {
     const session = this.sessions.get(tabId)
     if (!session) {
       return
@@ -284,7 +392,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.pty.resize(safeCols, safeRows)
     session.emulator.resize(safeCols, safeRows)
     this.applyScrollIntent(session, intent)
-    this.emitRenderIfChanged(session)
+    if (options?.sync) {
+      this.flushRenderNow(session)
+    } else {
+      this.scheduleRender(session)
+    }
   }
 
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
@@ -293,7 +405,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       return
     }
     this.applyScrollIntent(session, intent)
-    this.emitRenderIfChanged(session)
+    this.scheduleRender(session)
   }
 
   disposeSession(tabId: string): void {
@@ -302,12 +414,16 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       return
     }
 
+    this.clearTimers(tabId)
     this.sessions.delete(tabId)
     session.pty.kill()
     session.emulator.dispose()
   }
 
   disposeAll(): void {
+    for (const tabId of this.sessions.keys()) {
+      this.clearTimers(tabId)
+    }
     for (const session of this.sessions.values()) {
       session.pty.kill()
       session.emulator.dispose()

package/src/restart-terminal-manager.ts

@@ -0,0 +1,44 @@
+import {
+  getTerminalManagerSocketPath,
+  removeTerminalManagerSocketIfExists,
+} from './daemon/runtime-paths'
+import {
+  findIpcDaemonPid,
+  findTerminalManagerPid,
+  killProcess,
+  spawnDetachedTerminalManager,
+} from './platform/daemon-control'
+
+export async function runRestartTerminalManager(): Promise<number> {
+  const socketPath = getTerminalManagerSocketPath()
+
+  const daemonPid = await findIpcDaemonPid()
+  if (daemonPid !== null) {
+    process.stdout.write(`Stopping IPC daemon (pid ${daemonPid})...\n`)
+    await killProcess(daemonPid)
+  }
+
+  const managerPid = await findTerminalManagerPid()
+  if (managerPid !== null) {
+    process.stdout.write(
+      `WARNING: killing terminal-manager (pid ${managerPid}) will kill live sessions.\n`
+    )
+    await killProcess(managerPid)
+    process.stdout.write('Terminal-manager stopped.\n')
+  } else {
+    process.stdout.write('No running terminal-manager found.\n')
+  }
+
+  removeTerminalManagerSocketIfExists()
+
+  process.stdout.write('Starting terminal-manager...\n')
+  const ok = await spawnDetachedTerminalManager()
+
+  if (ok) {
+    process.stdout.write(`Terminal-manager started on ${socketPath}.\n`)
+    return 0
+  }
+
+  process.stderr.write('Failed to start terminal-manager.\n')
+  return 1
+}

package/src/session-backend/local-session-backend.ts

@@ -12,12 +12,16 @@ import {
   toTerminalContentSize,
 } from '../state/layout-resize'
 
+const SESSION_IDLE_TIMEOUT_MS = 2_000
+
 export class LocalSessionBackend
   extends EventEmitter<SessionBackendEvents>
   implements SessionBackend
 {
   private readonly sessionManager = new SessionManager()
   private currentSessionId: string | null = null
+  private readonly sessionIdleTimers = new Map<string, ReturnType<typeof setTimeout>>()
+  private readonly sessionBusy = new Map<string, boolean>()
 
   constructor() {
     super()
@@ -25,6 +29,7 @@ export class LocalSessionBackend
       if (sessionId === this.currentSessionId) {
         this.emit('render', tabId, viewport, terminalModes)
       }
+      this.markSessionBusy(sessionId)
     })
     this.sessionManager.on('exit', (sessionId, tabId, exitCode) => {
       if (sessionId === this.currentSessionId) {
@@ -38,6 +43,23 @@ export class LocalSessionBackend
     })
   }
 
+  private markSessionBusy(sessionId: string): void {
+    if (this.sessionBusy.get(sessionId) !== true) {
+      this.sessionBusy.set(sessionId, true)
+      this.emit('sessionActivity', sessionId, true)
+    }
+    const existing = this.sessionIdleTimers.get(sessionId)
+    if (existing) clearTimeout(existing)
+    const timer = setTimeout(() => {
+      this.sessionIdleTimers.delete(sessionId)
+      if (this.sessionBusy.get(sessionId) === true) {
+        this.sessionBusy.set(sessionId, false)
+        this.emit('sessionActivity', sessionId, false)
+      }
+    }, SESSION_IDLE_TIMEOUT_MS)
+    this.sessionIdleTimers.set(sessionId, timer)
+  }
+
   async attach(options: {
     sessionId: string
     cols: number
@@ -129,18 +151,29 @@ export class LocalSessionBackend
     this.sessionManager.setActiveTab(this.currentSessionId, tabId)
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
     if (!this.currentSessionId) {
       return
     }
-    this.sessionManager.resize(this.currentSessionId, cols, rows, intents)
+    this.sessionManager.resize(this.currentSessionId, cols, rows, intents, options)
   }
 
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void {
     if (!this.currentSessionId) {
       return
     }
-    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent)
+    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent, options)
   }
 
   disposeSession(tabId: string): void {
@@ -166,6 +199,11 @@ export class LocalSessionBackend
         this.sessionManager.disposeSession(this.currentSessionId)
       }
     }
+    for (const timer of this.sessionIdleTimers.values()) {
+      clearTimeout(timer)
+    }
+    this.sessionIdleTimers.clear()
+    this.sessionBusy.clear()
     this.currentSessionId = null
   }
 }

package/src/session-backend/remote-session-backend.ts

@@ -398,7 +398,12 @@ export class RemoteSessionBackend
     }).catch((error) => this.reportCommandError('setActiveTab', error))
   }
 
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    _options?: { sync?: boolean }
+  ): void {
     if (!this.attached) {
       logDebug('backend.remote.skipResizeBeforeAttach', { cols, rows })
       return
@@ -412,7 +417,13 @@ export class RemoteSessionBackend
     }).catch((error) => this.reportCommandError('resizeClient', error))
   }
 
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    _options?: { sync?: boolean }
+  ): void {
     if (!this.attached) {
       return
     }

package/src/session-backend/types.ts

@@ -12,6 +12,7 @@ export type SessionBackendEvents = {
   render: [tabId: string, viewport: TerminalSnapshot, terminalModes: TerminalModeState]
   exit: [tabId: string, exitCode: number]
   error: [tabId: string, message: string]
+  sessionActivity: [sessionId: string, busy: boolean]
 }
 
 export interface BackendAttachResult {
@@ -41,8 +42,19 @@ export interface SessionBackend extends EventEmitter<SessionBackendEvents> {
   scrollViewportToBottom(tabId: string): void
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void
   setActiveTab(tabId: string | null): void
-  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void
-  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void
+  resizeTab(
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent,
+    options?: { sync?: boolean }
+  ): void
   disposeSession(tabId: string): void
   disposeAll(): void
   destroy(keepSessions?: boolean): Promise<void> | void

package/src/state/dispatch-ref.ts

@@ -1,8 +1,11 @@
+import type { SideEffect } from '../input/modes/types'
 import type { AppAction } from './types'
 
 type DispatchFn = (action: AppAction) => void
+type SideEffectFn = (effect: SideEffect) => void
 
 let activeDispatch: DispatchFn | null = null
+let activeSideEffect: SideEffectFn | null = null
 
 export function setActiveDispatch(dispatch: DispatchFn | null): void {
   activeDispatch = dispatch
@@ -11,3 +14,11 @@ export function setActiveDispatch(dispatch: DispatchFn | null): void {
 export function dispatchGlobal(action: AppAction): void {
   activeDispatch?.(action)
 }
+
+export function setActiveSideEffectRunner(runner: SideEffectFn | null): void {
+  activeSideEffect = runner
+}
+
+export function runSideEffectGlobal(effect: SideEffect): void {
+  activeSideEffect?.(effect)
+}

package/src/state/reducers/session-state.ts

@@ -64,6 +64,8 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
       const filteredNew = filterSessions(newSessions, state.modal.editBuffer)
       const maxIndex = filteredNew.length
       const clampedIndex = Math.min(state.modal.selectedIndex, maxIndex)
+      const nextBusy = { ...state.sessionsBusy }
+      delete nextBusy[action.sessionId]
       return {
         ...state,
         activeTabId: action.sessionId === state.currentSessionId ? null : state.activeTabId,
@@ -77,9 +79,35 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
           type: 'session-picker',
         },
         sessions: newSessions,
+        sessionsBusy: nextBusy,
         tabs: action.sessionId === state.currentSessionId ? [] : state.tabs,
       }
     }
+    case 'reorder-sessions': {
+      const byId = new Map(state.sessions.map((s) => [s.id, s]))
+      const ordered: typeof state.sessions = []
+      let idx = 0
+      for (const id of action.orderedIds) {
+        const s = byId.get(id)
+        if (s) {
+          ordered.push({ ...s, order: idx })
+          byId.delete(id)
+        }
+        idx++
+      }
+      let nextOrder = ordered.length
+      for (const s of byId.values()) {
+        ordered.push({ ...s, order: nextOrder++ })
+      }
+      return { ...state, sessions: ordered }
+    }
+    case 'set-session-busy': {
+      if ((state.sessionsBusy[action.sessionId] ?? false) === action.busy) return state
+      return {
+        ...state,
+        sessionsBusy: { ...state.sessionsBusy, [action.sessionId]: action.busy },
+      }
+    }
     default:
       return null
   }

package/src/state/reducers/ui-state.ts

@@ -23,6 +23,14 @@ export function reduceUIState(state: AppState, action: AppAction): AppState | nu
         return state
       }
       return { ...state, pendingChords: action.chords }
+    case 'toggle-session-bar':
+      return {
+        ...state,
+        sessionBar: { ...state.sessionBar, visible: !state.sessionBar.visible },
+      }
+    case 'set-session-bar-position':
+      if (state.sessionBar.position === action.position) return state
+      return { ...state, sessionBar: { ...state.sessionBar, position: action.position } }
     default:
       return null
   }

package/src/state/session-catalog.ts

@@ -46,7 +46,7 @@ export function loadSessionCatalog(): SessionRecord[] {
   const { file, issue } = readCatalogFile()
   if (file) {
     logDebug('sessions.catalog.load', { sessionCount: file.sessions.length })
-    return file.sessions
+    return normalizeOrder(file.sessions)
   }
 
   if (issue) {
@@ -95,3 +95,24 @@ export function saveSessionCatalog(sessions: SessionRecord[]): void {
 export function getSessionCatalogPath(): string {
   return SESSIONS_PATH
 }
+
+/**
+ * Assign a stable `order` to every session. Records with an existing numeric
+ * `order` keep their slot (sorted ascending); the rest are appended by
+ * createdAt ascending so older sessions come first.
+ */
+function normalizeOrder(sessions: SessionRecord[]): SessionRecord[] {
+  const withOrder: SessionRecord[] = []
+  const withoutOrder: SessionRecord[] = []
+  for (const s of sessions) {
+    if (typeof s.order === 'number' && Number.isFinite(s.order)) {
+      withOrder.push(s)
+    } else {
+      withoutOrder.push(s)
+    }
+  }
+  withOrder.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+  withoutOrder.sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+  const merged = [...withOrder, ...withoutOrder]
+  return merged.map((s, i) => (s.order === i ? s : { ...s, order: i }))
+}

package/src/state/store.ts

@@ -1,4 +1,4 @@
-import type { AppAction, AppState, SessionRecord, SnippetRecord } from './types'
+import type { AppAction, AppState, SessionBarPosition, SessionRecord, SnippetRecord } from './types'
 
 import { emptyGitMode, reduceGitModeState } from './reducers/git-mode-state'
 import { emptyGitPanel, reduceGitPanelState } from './reducers/git-panel-state'
@@ -17,6 +17,8 @@ const DEFAULT_TERMINAL_ROWS = 24
 export interface InitialStateOverrides {
   gitPanelVisible?: boolean
   gitPanelRatio?: number
+  sessionBarVisible?: boolean
+  sessionBarPosition?: SessionBarPosition
 }
 
 export function createInitialState(
@@ -42,7 +44,12 @@ export function createInitialState(
       ? { editBuffer: null, selectedIndex: 0, sessionTargetId: null, type: 'session-picker' }
       : emptyModal(),
     pendingChords: null,
+    sessionBar: {
+      position: overrides.sessionBarPosition ?? 'top',
+      visible: overrides.sessionBarVisible ?? true,
+    },
     sessions,
+    sessionsBusy: {},
     sidebar: {
       gitPanelRatio: overrides.gitPanelRatio ?? 0.5,
       gitPanelVisible: overrides.gitPanelVisible ?? true,

package/src/state/types.ts

@@ -105,9 +105,17 @@ export interface SessionRecord {
   createdAt: string
   updatedAt: string
   lastOpenedAt: string
+  order?: number
   workspaceSnapshot?: WorkspaceSnapshotV1
 }
 
+export type SessionBarPosition = 'top' | 'bottom'
+
+export interface SessionBarState {
+  visible: boolean
+  position: SessionBarPosition
+}
+
 export interface TabSession {
   id: string
   assistant: AssistantId
@@ -287,6 +295,8 @@ export interface AppState {
   tabGroupMap: Record<string, string>
   sessions: SessionRecord[]
   currentSessionId: string | null
+  sessionsBusy: Record<string, boolean>
+  sessionBar: SessionBarState
   snippets: SnippetRecord[]
   focusMode: FocusMode
   sidebar: SidebarState
@@ -332,6 +342,8 @@ export type SessionAction =
   | { type: 'create-session-record'; session: SessionRecord }
   | { type: 'rename-session-record'; sessionId: string; name: string }
   | { type: 'delete-session-record'; sessionId: string }
+  | { type: 'reorder-sessions'; orderedIds: string[] }
+  | { type: 'set-session-busy'; sessionId: string; busy: boolean }
 
 // -- Tab actions --
 export type TabAction =
@@ -398,6 +410,8 @@ export type UIAction =
   | { type: 'toggle-git-panel' }
   | { type: 'resize-git-panel'; delta: number }
   | { type: 'set-pending-chords'; chords: string[] | null }
+  | { type: 'toggle-session-bar' }
+  | { type: 'set-session-bar-position'; position: SessionBarPosition }
 
 // -- Git panel actions --
 export interface GitRefreshPayload {

package/src/state/validation.ts

@@ -151,6 +151,8 @@ export function isSessionRecord(value: unknown): value is SessionRecord {
     isString(value.createdAt) &&
     isString(value.updatedAt) &&
     isString(value.lastOpenedAt) &&
+    (value.order === undefined ||
+      (typeof value.order === 'number' && Number.isFinite(value.order))) &&
     (value.workspaceSnapshot === undefined || isWorkspaceSnapshotV1(value.workspaceSnapshot))
   )
 }

package/src/state/workspace-save.ts

@@ -26,6 +26,8 @@ export function saveCurrentWorkspace(state: AppState): void {
     customCommands: state.customCommands,
     gitPanelRatio: state.sidebar.gitPanelRatio,
     gitPanelVisible: state.sidebar.gitPanelVisible,
+    sessionBarPosition: state.sessionBar.position,
+    sessionBarVisible: state.sessionBar.visible,
   })
   saveSessionCatalog(
     buildSessionsWithCurrentSnapshot(state.sessions, state.currentSessionId, state)