perf: harden sync architecture and modularize runtimes (#803)

* fix: added desktop app background throttling * perf: add streaming debug metrics panel - Show streaming performance metrics in the debug panel - Auto-enable stream profiling while the panel is open - Add JSON export for sharing UI and VS Code metrics * perf: batch streaming updates more aggressively - Buffer message deltas and metadata updates to cut render churn - Skip no-op part updates before they touch the message store - Fix the desktop debug panel shortcut binding * perf: split streaming event handling and coalesce deltas - Move streaming content events onto a dedicated fast path - Defer non-critical stream side effects off the hot path - Merge repeated message delta events before they reach the UI * perf: isolate streaming rows from chat rerenders - Memoize chat rows against render-relevant message changes only - Read live assistant text directly from store to narrow streaming updates - Split the active streaming entry from the stable message list path * perf: streamline chat streaming and SSE proxying - Reduce chat rerenders around the active streaming path - Simplify server SSE forwarding to avoid duplicate proxy work * fix: preserve the first streaming text chunk - Show the initial text chunk immediately before batched deltas arrive - Bypass batching for the first text or reasoning part update - Keep later streaming updates buffered for performance * perf: align streaming/render hot paths with opencode parity * perf: harden turn/cache stability and stale delta suppression * fix: stabilize chat rendering and disable timeline interactions - Disabled timeline dialog access from shortcuts, commands, and chat input - Reduced chat render churn by simplifying message list and turn staging behavior - Improved session-switch stability to prevent update-depth crashes * perf: track static message rerenders during streaming * perf: reduce sorted-mode activity rerender fanout * perf: reduce chat rerender fanout and add active-turn metrics - Reduced sorted-mode rerender coupling by tightening turn context propagation - Added a metric for static rerenders outside the active turn during streaming - Exposed new chat render counters in the debug panel for parity tracking * fix: keep sorted activity mounted while stream grows * fix: stabilize session and history scroll rendering * refactor: decouple server routes from index * refactor: extract fs module from server index * refactor: move opencode route ownership into module * refactor: extract notification route registration * refactor: extract opencode and notification runtimes from index * refactor: extract settings runtime and complete server modularization pass * refactor: modularize server config, skills, icons, and tunnel routes * refactor: extract server modules from monolithic index.js Split proxy, routes, runtime helpers, and notification emitter into dedicated modules under packages/web/server/lib/. * refactor: replace session/message stores with SSE-driven sync layer Delete ~9200 lines of old architecture (useEventStream, messageStore, sessionStore, useSessionStore, questionStore, useTodoStore, client SSE). New sync layer: event pipeline with coalescing + 16ms flush, pure event reducer, per-directory child stores with LRU eviction, cursor pagination, optimistic updates, deferred timeline staging, text throttle. Migrate all UI consumers to sync hooks (useSessionMessages, useSessionMessageRecords, useSessionStatus, useSessionPermissions, etc). Strip session-ui-store to UI-only state, delegate SDK ops to session-actions with abort-if-busy, optimistic store updates, and response merging for revert/fork/archive/delete. Add notification-store for SSE-driven session attention tracking, cross-directory GlobalSessionStatusStore for sidebar indicators, client-side diff snapshot sanitization to prevent memory bloat, and revert message filtering via useVisibleSessionMessages. * feat: notification store, session actions, activity detection Add notification-store.ts for SSE-driven attention tracking. Add sanitize.ts to strip diff snapshot memory bloat. Add session-actions.ts with optimistic revert/fork/archive/delete. Improve useSessionActivity with incomplete-message fallback. Delete useServerSessionStatus polling hook. * fix: add directory param to all SDK calls, fix command/shell/abort routing All SDK calls in session-actions.ts now pass directory parameter — required by OpenCode server to scope session operations. Without it, abort, commands, revert, fork, and other operations returned 500. Add routeMessage() in session-ui-store for shell mode (session.shell), slash commands (session.command), and normal prompts. Command lookup checks both sync child store and useCommandsStore. Handle /compact locally via session.summarize(). Implement getContextUsage() to restore header context usage display — reads token counts from last assistant message in sync store. * refactor: replace custom API proxy with http-proxy-middleware Remove ~280 lines of custom proxy code: forwardSseRequest, forwardGenericApiRequest, collectRequestBodyBuffer, header manipulation, hop-by-hop filtering, SSE block buffering. Replace with single createProxyMiddleware() call that handles SSE streaming, large bodies, and timeouts out of the box. Dynamic router for OpenCode port changes after restarts. Auth headers injected via proxyReq hook. Keep: readiness gate, Windows session merge, API prefix detection. * perf: targeted event draft cloning to fix streaming render cascade Event handler was eagerly cloning all state slices on every event, breaking Zustand selector referential equality. During streaming (~60 events/sec), this caused every subscriber to re-render regardless of which slice actually changed. Now only clones fields the specific event type mutates. Also extracts StatusRowContainer to isolate high-frequency useAssistantStatus subscription, removes dead messageStreamStatesMap subscription from ChatContainer, and narrows useAssistantStatus to only track last assistant message parts. MessageList renders: 1972 → 296 per streaming session (-85%). * fix: null safety for sync state slices Add defensive ?? {} guards on permission, question, session_status, and message record access. Prevents crashes when child store state is partially initialized during bootstrap. * perf: dedup inflight SDK calls, extract concurrency util, delay PR tracking Extract mapWithConcurrency to shared lib/concurrency.ts. Add in-flight dedup for loadProviders/loadAgents to prevent concurrent duplicate SDK calls. Delay initial PR background tracking by 5s to reduce startup CPU burst. * fix: header session lookup across all child stores Session title and context panel click failed when session belonged to a different directory than the current child store. Fall back to getAllSyncSessions() to search all initialized stores. * chore: bump @opencode-ai/sdk to 1.3.5 * docs: add sync event handling guide * Optimize session prefetch and improve delete/archive UX - Add settlement delay to session prefetch to avoid race conditions on rapid session switches - Reduce git diff prefetch and session cache limits for better performance - Implement optimistic UI updates for session delete/archive operations with proper rollback on failure - Wire session prefetch hook into SessionSidebar with sync integration * Add file content cache and sync optimizations - Wrap FilesAPI with in-memory LRU cache for file content with dual constraints (entry count and byte size) - Optimize chat timeline scroll restoration using useLayoutEffect - Preserve React references in message and part arrays to prevent unnecessary re-renders when prepending history - Add session prefetch TTL cache to prevent redundant fetches - Integrate session prefetch cache clearing with eviction flow * Improve session sidebar error handling and add diff prefetch filtering Load active and archived sessions independently using Promise.allSettled to prevent one failure from blocking the other. Add retry logic to session API calls and skip large files during diff prefetch to improve performance. * Replace sendMessage with optimisticSend wrapper Introduces optimistic UI updates for normal chat messages to provide instant feedback. Messages appear immediately in the UI while the API call executes in the background, with automatic rollback on errors. * perf: split stores, proper optimistic send, fix revert/directory bugs - split session-ui-store into voice/input/selection/viewport stores to reduce subscriber re-evaluation during streaming - wire optimisticSend through useSync shadow Map infrastructure matching OpenCode's pattern (no heuristic part detection) - port OpenCode Identifier.ascending ID format for correct sorting - pass messageID to promptAsync to prevent duplicate messages - fix worktree directory not propagating to session actions (dynamic dir() via opencodeClient.getDirectory) - fix setCurrentSession accepting directoryHint for new sessions - fix revert not hiding messages (session limit was 5, bumped to match loaded count) - fix revert optimistic message removal from store - fix load-more flicker (useLayoutEffect scroll compensation) - add prefetch TTL cache, file content LRU cache - add session prefetch for adjacent sessions - add instant archive/delete (optimistic before SDK call) - migrate legacy window.__zustand_session_store__ to session-ui-store - add retry + independent error handling for archived sessions - add AGENTS.md performance rules * perf: startup optimization — dedup, caching, light git status, diff rendering gates - defer diff prefetch to git tab open, reduce concurrency 4→2, skip >500 changed lines - cap project git checks concurrency (2), directory status probe (3) - dedup provider/agent loading, github auth, worktree list (in-flight + TTL caches) - delay PR tracking 5s, cache 403 search failures per-repo - coalesce settings PUT (200ms debounce), cache settings GET (2s TTL) - cache canonical directory resolution (60s TTL) - persist missing directory status to localStorage (10min TTL) - light/heavy git status: polling skips numstat+line counting+rev-list - large diff rendering gate (>500 lines → "render anyway" button) - tokenization degradation for >500KB files in Pierre - parallelize main.tsx pre-render awaits - batch sidebar file tree expanded paths restoration (3 at a time) - remove bare useConfigStore() subscription in AgentsPage - sync worktree sandboxes to OpenCode SQLite DB - fix RightSidebarTabs ternary → explicit tab matching - defensive guards on sync state (session_status, permission, question, message) * fix: add defensive guards on remaining sync state field accesses guard session_status, permission, message, todo, part, config with ?? {} in useDirectorySync selectors, session-cache, and bootstrap * fix: add missing directory dep to useCallback in use-sync.ts * fix: preserve diffStats when light-mode polling overwrites status * perf: optimize startup git status polling and diff rendering Preserves diff stats when lightweight polling updates repository status Reduces startup overhead with smarter git polling and store updates Adds detailed optimization and migration docs for next performance steps * fix: keep chat diff stats stable during git status updates Prevents lightweight git polling from dropping diff statistics Keeps MessageList diff indicators consistent while status refreshes Improves reliability of git-aware chat rendering * fix: user animation replay, queued message variant, startup provider loading - consume animation ID after first play to prevent re-animation on neighbor assistant message completion - capture send config (model/agent/variant) at queue time matching OpenCode's FollowupDraft pattern instead of re-resolving at send time - replace one-shot startup recovery effect with polling interval that retries every 2s until providers and agents load - fix optimistic bridge to avoid re-render loop (stable ref wrappers) * chore: update tauri to 2.10.3 and all plugins to latest - tauri 2.9.4 → 2.10.3 - tauri-build 2.5.3 → 2.5.6 - tauri-plugin-dialog 2.4.2 → 2.6.0 - tauri-plugin-log 2.7.1 → 2.8.0 - tauri-plugin-shell 2.3.3 → 2.3.5 - tauri-plugin-updater 2 (floating) → 2.10.0 (pinned) - @tauri-apps/api ^2.9.0 → ^2.10.1 - wry 0.53.5 → 0.54.4 (transitive) * refactor: decouple web server index orchestration runtimes * fix: align VS Code runtime behavior with web and reduce draft view CPU load - Queue VS Code bridge and SSE startup requests until API readiness to avoid false bootstrap failures - Make agent manager actions directory-aware and remove real worktrees with safer partial-failure handling - Replace heavy logo animation path with a lightweight pulse to cut draft-session CPU usage * fix: restore auto-selected file sending in chat input - Send server-selected files as proper file URLs in the message payload - Include server-backed attachments in submit flow instead of dropping them - Restore queued-message attachments through the refactored input store * fix: restore session model selection consistently on session switch - Restore agent, model, and variant from the latest loaded user message for each session - Wait for session messages before applying restored selections to avoid stale or missing state - Remove legacy session-choice inference paths that caused overlap and instability * fix: restore permission replies and auto-accept across sessions - Scope permission and question replies to the target session directory so answers take effect reliably - Make permission auto-accept immediately handle pending requests and react to new permission prompts - Keep parent-session handling working for child-session requests through the shared response path * feat: add reusable fuzzy branch fuzzy-search helper and dialog integration (#798) * feat: add reusable fuzzy branch search for worktrees * chore: drop planning docs from feature branch * feat: make worktree branch refresh manual * feat: add configurable session retention action * refactor: centralize global session state in ui store * fix: cancel debounced permission push after reply * docs: clarify global and directory session store architecture * docs: refine agent development rules and session activity guidance - Clarify agent code of conduct and durable development patterns - Add explicit shared-store rerender and live-state guidance - Narrow session activity fallback to avoid stale working state * chore: updated .gitignore --------- Co-authored-by: Iuliia Ivashko <yulia.ivashko@gmail.com>
2026-03-31 18:47:00 +03:00
parent 8dfe833faf
commit c9e31a0e6c
245 changed files with 31986 additions and 32683 deletions
@@ -0,0 +1,586 @@
+/**
+ * Session actions — SDK-calling operations for session management.
+ * Replaces the action methods from the old useSessionStore.
+ */
+
+import type { OpencodeClient, Session, Message, Part } from "@opencode-ai/sdk/v2/client"
+import { Binary } from "./binary"
+import { useSessionUIStore } from "./session-ui-store"
+import { useInputStore } from "./input-store"
+import type { DirectoryStore } from "./child-store"
+import type { StoreApi } from "zustand"
+import { opencodeClient } from "@/lib/opencode/client"
+import { useGlobalSessionsStore } from "@/stores/useGlobalSessionsStore"
+
+// Reference set by SyncProvider — allows actions to access SDK and stores
+let _sdk: OpencodeClient | null = null
+let _childStores: { ensureChild: (dir: string) => StoreApi<DirectoryStore> } | null = null
+let _getDirectory: () => string = () => ""
+let _optimisticAdd: ((input: { sessionID: string; message: Message; parts: Part[] }) => void) | null = null
+let _optimisticRemove: ((input: { sessionID: string; messageID: string }) => void) | null = null
+
+export function setActionRefs(
+  sdk: OpencodeClient,
+  childStores: { ensureChild: (dir: string) => StoreApi<DirectoryStore> },
+  getDirectory: () => string,
+) {
+  _sdk = sdk
+  _childStores = childStores
+  _getDirectory = getDirectory
+}
+
+export function setOptimisticRefs(
+  add: (input: { sessionID: string; message: Message; parts: Part[] }) => void,
+  remove: (input: { sessionID: string; messageID: string }) => void,
+) {
+  _optimisticAdd = add
+  _optimisticRemove = remove
+}
+
+function sdk() {
+  if (!_sdk) throw new Error("SDK not initialized — is SyncProvider mounted?")
+  return _sdk
+}
+
+function dirStore() {
+  if (!_childStores) throw new Error("Child stores not initialized")
+  const d = _getDirectory()
+  if (!d) throw new Error("No current directory")
+  return _childStores.ensureChild(d)
+}
+
+function dir() {
+  return _getDirectory() || undefined
+}
+
+function getSessionDirectory(sessionId: string): string | undefined {
+  return useSessionUIStore.getState().getDirectoryForSession(sessionId) || dir()
+}
+
+function getDirectoryStore(directory?: string) {
+  if (!_childStores) throw new Error("Child stores not initialized")
+  const resolvedDirectory = directory || _getDirectory()
+  if (!resolvedDirectory) throw new Error("No current directory")
+  return _childStores.ensureChild(resolvedDirectory)
+}
+
+function getSessionReplyClient(sessionId?: string): OpencodeClient {
+  const directory = sessionId
+    ? useSessionUIStore.getState().getDirectoryForSession(sessionId)
+    : null
+  if (directory) {
+    return opencodeClient.getScopedSdkClient(directory)
+  }
+  return sdk()
+}
+
+// ---------------------------------------------------------------------------
+// Session CRUD
+// ---------------------------------------------------------------------------
+
+export async function createSession(
+  title?: string,
+  directoryOverride?: string | null,
+  parentID?: string | null,
+): Promise<Session | null> {
+  try {
+    const result = await sdk().session.create({
+      directory: directoryOverride ?? dir(),
+      title,
+      parentID: parentID ?? undefined,
+    })
+    const session = result.data
+    if (!session) return null
+
+      const sessionDirectory = (session as { directory?: string }).directory ?? directoryOverride ?? null
+      useSessionUIStore.getState().setCurrentSession(session.id, sessionDirectory)
+      useSessionUIStore.getState().markSessionAsOpenChamberCreated(session.id)
+      useGlobalSessionsStore.getState().upsertSession(session)
+      return session
+  } catch (error) {
+    console.error("[session-actions] createSession failed", error)
+    return null
+  }
+}
+
+/** Optimistically remove a session from the child store list. Returns previous list for rollback. */
+function optimisticRemoveSession(sessionId: string, directory?: string): Session[] | null {
+  const store = getDirectoryStore(directory)
+  const current = store.getState()
+  const sessions = [...current.session]
+  const result = Binary.search(sessions, sessionId, (s) => s.id)
+  if (result.found) {
+    const snapshot = current.session
+    sessions.splice(result.index, 1)
+    store.setState({ session: sessions })
+    return snapshot
+  }
+  return null
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function deleteSession(sessionId: string, _options?: Record<string, unknown>): Promise<boolean> {
+  const sessionDirectory = getSessionDirectory(sessionId)
+  // Remove from UI immediately, rollback on error
+  const snapshot = optimisticRemoveSession(sessionId, sessionDirectory)
+  const ui = useSessionUIStore.getState()
+  if (ui.currentSessionId === sessionId) {
+    ui.setCurrentSession(null)
+  }
+  try {
+    await sdk().session.delete({ sessionID: sessionId, directory: sessionDirectory })
+    useGlobalSessionsStore.getState().removeSessions([sessionId])
+    return true
+  } catch (error) {
+    console.error("[session-actions] deleteSession failed", error)
+    if (snapshot) getDirectoryStore(sessionDirectory).setState({ session: snapshot })
+    return false
+  }
+}
+
+/** Delete a session specifying which directory it lives in. Used by agent groups for cross-directory deletes. */
+export async function deleteSessionInDirectory(sessionId: string, directory: string): Promise<boolean> {
+  if (!_childStores) return false
+  const store = _childStores.ensureChild(directory)
+  const current = store.getState()
+  const sessions = [...current.session]
+  const result = Binary.search(sessions, sessionId, (s) => s.id)
+  let snapshot: Session[] | null = null
+  if (result.found) {
+    snapshot = current.session
+    sessions.splice(result.index, 1)
+    store.setState({ session: sessions })
+  }
+  const ui = useSessionUIStore.getState()
+  if (ui.currentSessionId === sessionId) ui.setCurrentSession(null)
+  try {
+    await sdk().session.delete({ sessionID: sessionId, directory })
+    useGlobalSessionsStore.getState().removeSessions([sessionId])
+    return true
+  } catch (error) {
+    console.error("[session-actions] deleteSessionInDirectory failed", error)
+    if (snapshot) store.setState({ session: snapshot })
+    return false
+  }
+}
+
+export async function archiveSession(sessionId: string): Promise<boolean> {
+  const sessionDirectory = getSessionDirectory(sessionId)
+  const snapshot = optimisticRemoveSession(sessionId, sessionDirectory)
+  const ui = useSessionUIStore.getState()
+  if (ui.currentSessionId === sessionId) {
+    ui.setCurrentSession(null)
+  }
+  try {
+    const archivedAt = Date.now()
+    await sdk().session.update({ sessionID: sessionId, directory: sessionDirectory, time: { archived: archivedAt } })
+    useGlobalSessionsStore.getState().archiveSessions([sessionId], archivedAt)
+    return true
+  } catch (error) {
+    console.error("[session-actions] archiveSession failed", error)
+    if (snapshot) getDirectoryStore(sessionDirectory).setState({ session: snapshot })
+    return false
+  }
+}
+
+export async function updateSessionTitle(sessionId: string, title: string): Promise<void> {
+  const sessionDirectory = getSessionDirectory(sessionId)
+  const result = await sdk().session.update({ sessionID: sessionId, directory: sessionDirectory, title })
+  if (result.data) {
+    useGlobalSessionsStore.getState().upsertSession(result.data)
+  }
+}
+
+export async function shareSession(sessionId: string): Promise<Session | null> {
+  const sessionDirectory = getSessionDirectory(sessionId)
+  const result = await sdk().session.share({ sessionID: sessionId, directory: sessionDirectory })
+  if (result.data) {
+    useGlobalSessionsStore.getState().upsertSession(result.data)
+  }
+  return result.data ?? null
+}
+
+export async function unshareSession(sessionId: string): Promise<Session | null> {
+  const sessionDirectory = getSessionDirectory(sessionId)
+  const result = await sdk().session.unshare({ sessionID: sessionId, directory: sessionDirectory })
+  if (result.data) {
+    useGlobalSessionsStore.getState().upsertSession(result.data)
+  }
+  return result.data ?? null
+}
+
+// ---------------------------------------------------------------------------
+// Optimistic message send — insert user message before API call, rollback on error
+// ---------------------------------------------------------------------------
+
+// ID generator matching OpenCode's Identifier.ascending format.
+// Uses BigInt(timestamp) * 0x1000 + counter, encoded as 6 hex bytes + random base62.
+// This ensures client-generated IDs sort correctly with server-generated ones.
+let lastIdTimestamp = 0
+let idCounter = 0
+
+function ascendingId(prefix: string): string {
+  const now = Date.now()
+  if (now !== lastIdTimestamp) {
+    lastIdTimestamp = now
+    idCounter = 0
+  }
+  idCounter += 1
+
+  const value = BigInt(now) * BigInt(0x1000) + BigInt(idCounter)
+  const bytes = new Uint8Array(6)
+  for (let i = 0; i < 6; i++) {
+    bytes[i] = Number((value >> BigInt(40 - 8 * i)) & BigInt(0xff))
+  }
+
+  let hex = ""
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0")
+  }
+
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+  let rand = ""
+  for (let i = 0; i < 14; i++) {
+    rand += chars[Math.floor(Math.random() * 62)]
+  }
+
+  return `${prefix}_${hex}${rand}`
+}
+
+/**
+ * Wraps an async send operation with optimistic user-message insertion.
+ * Uses useSync()'s optimistic infrastructure — message + parts are inserted
+ * into the store AND registered in the shadow Map. mergeOptimisticPage
+ * handles deduplication when the server echoes back the real message.
+ */
+export async function optimisticSend(input: {
+  sessionId: string
+  content: string
+  providerID: string
+  modelID: string
+  agent?: string
+  files?: Array<{ type: "file"; mime: string; url: string; filename: string }>
+  /** The actual API call — receives the optimistic messageID so the server can use the same ID */
+  send: (messageID: string) => Promise<void>
+}): Promise<void> {
+  if (!_optimisticAdd || !_optimisticRemove) {
+    throw new Error("Optimistic refs not set — is useSync() mounted?")
+  }
+
+  const store = dirStore()
+  const messageID = ascendingId("msg")
+  const textPartId = ascendingId("prt")
+
+  const optimisticParts: Part[] = [
+    { id: textPartId, type: "text", text: input.content } as Part,
+  ]
+  if (input.files) {
+    for (const f of input.files) {
+      optimisticParts.push({ id: ascendingId("prt"), type: "file", mime: f.mime, url: f.url, filename: f.filename } as Part)
+    }
+  }
+
+  const optimisticMessage = {
+    id: messageID,
+    role: "user" as const,
+    sessionID: input.sessionId,
+    parentID: "",
+    modelID: input.modelID,
+    providerID: input.providerID,
+    system: "",
+    agent: input.agent ?? "",
+    model: `${input.providerID}/${input.modelID}`,
+    metadata: {} as Record<string, unknown>,
+    time: { created: Date.now(), completed: 0 },
+  } as unknown as Message
+
+  // Insert into store + register in shadow Map (for mergeOptimisticPage cleanup)
+  _optimisticAdd({
+    sessionID: input.sessionId,
+    message: optimisticMessage,
+    parts: optimisticParts,
+  })
+
+  // Set busy status
+  const current = store.getState()
+  store.setState({
+    session_status: {
+      ...current.session_status,
+      [input.sessionId]: { type: "busy" as const },
+    },
+  })
+
+  try {
+    await input.send(messageID)
+  } catch (error) {
+    // Rollback via optimistic infrastructure
+    _optimisticRemove({
+      sessionID: input.sessionId,
+      messageID,
+    })
+    const s = store.getState()
+    store.setState({
+      session_status: {
+        ...s.session_status,
+        [input.sessionId]: { type: "idle" as const },
+      },
+    })
+    throw error
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Abort
+// ---------------------------------------------------------------------------
+
+export async function abortCurrentOperation(sessionId: string): Promise<void> {
+  try {
+    await sdk().session.abort({ sessionID: sessionId, directory: dir() })
+  } catch (error) {
+    console.error("[session-actions] abort failed", error)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Permissions
+// ---------------------------------------------------------------------------
+
+export async function respondToPermission(
+  sessionId: string,
+  requestId: string,
+  response: "once" | "always" | "reject",
+): Promise<void> {
+  const result = await getSessionReplyClient(sessionId).permission.reply({
+    requestID: requestId,
+    reply: response,
+  })
+  if (!result.data) {
+    throw new Error("Permission reply failed")
+  }
+}
+
+export async function dismissPermission(
+  sessionId: string,
+  requestId: string,
+): Promise<void> {
+  const result = await getSessionReplyClient(sessionId).permission.reply({
+    requestID: requestId,
+    reply: "reject",
+  })
+  if (!result.data) {
+    throw new Error("Permission dismissal failed")
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Questions
+// ---------------------------------------------------------------------------
+
+export async function respondToQuestion(
+  sessionId: string,
+  requestId: string,
+  answers: string[] | string[][],
+): Promise<void> {
+  const result = await getSessionReplyClient(sessionId).question.reply({
+    requestID: requestId,
+    answers: answers as Array<Array<string>>,
+  })
+  if (!result.data) {
+    throw new Error("Question reply failed")
+  }
+}
+
+export async function rejectQuestion(
+  sessionId: string,
+  requestId: string,
+): Promise<void> {
+  const result = await getSessionReplyClient(sessionId).question.reject({
+    requestID: requestId,
+  })
+  if (!result.data) {
+    throw new Error("Question rejection failed")
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Message history
+// ---------------------------------------------------------------------------
+
+/**
+ * Revert to a specific user message.
+ *
+ * 1. Abort if session is busy
+ * 2. Extract text from the target message for prompt restoration
+ * 3. Optimistically set revert marker so messages hide immediately
+ * 4. Call SDK session.revert() and merge returned session
+ * 5. Set pendingInputText so the reverted message text appears in the input
+ */
+export async function revertToMessage(sessionId: string, messageId: string): Promise<void> {
+  const store = dirStore()
+  const state = store.getState()
+
+  // Abort if busy before mutating session state
+  const status = state.session_status[sessionId]
+  if (status && status.type !== "idle") {
+    try {
+      await sdk().session.abort({ sessionID: sessionId, directory: dir() })
+    } catch {
+      // ignore abort errors
+    }
+  }
+
+  // Extract message text for prompt restoration
+  const messages = state.message[sessionId] ?? []
+  const targetMsg = messages.find((m) => m.id === messageId)
+  let messageText = ""
+  if (targetMsg && targetMsg.role === "user") {
+    const parts = state.part[messageId] ?? []
+    const textParts = parts.filter((p) => p.type === "text")
+    messageText = textParts
+      .map((p: Record<string, unknown>) => (p as { text?: string }).text || (p as { content?: string }).content || "")
+      .join("\n")
+      .trim()
+  }
+
+  // Optimistically remove reverted messages + set marker
+  const prevRevert = (() => {
+    const s = state.session.find((s) => s.id === sessionId)
+    return (s as Session & { revert?: unknown })?.revert
+  })()
+  const sessions = [...state.session]
+  const sessionIdx = sessions.findIndex((s) => s.id === sessionId)
+
+  // Remove messages at and after the revert point from the store
+  const prevMessages = state.message[sessionId] ?? []
+  const prevPart = { ...state.part }
+  const keptMessages = prevMessages.filter((m) => m.id < messageId)
+  const removedMessages = prevMessages.filter((m) => m.id >= messageId)
+  for (const m of removedMessages) {
+    delete prevPart[m.id]
+  }
+
+  const patch: Record<string, unknown> = {
+    message: { ...state.message, [sessionId]: keptMessages },
+    part: prevPart,
+  }
+
+  if (sessionIdx >= 0) {
+    sessions[sessionIdx] = { ...sessions[sessionIdx], revert: { messageID: messageId } } as Session
+    patch.session = sessions
+  }
+
+  store.setState(patch)
+
+  // Restore reverted message text to input
+  if (messageText) {
+    useInputStore.setState({
+      pendingInputText: messageText,
+      pendingInputMode: "replace" as const,
+    })
+  }
+
+  // Call SDK and merge authoritative result into store
+  try {
+    const result = await sdk().session.revert({ sessionID: sessionId, directory: dir(), messageID: messageId })
+    if (result.data) {
+      const current = store.getState()
+      const updated = [...current.session]
+      const idx = updated.findIndex((s) => s.id === sessionId)
+      if (idx >= 0) {
+        updated[idx] = result.data
+        store.setState({ session: updated })
+      }
+    }
+  } catch (err) {
+    // Rollback: restore removed messages + revert marker
+    const current = store.getState()
+    const rollback = [...current.session]
+    const idx = rollback.findIndex((s) => s.id === sessionId)
+    if (idx >= 0) {
+      rollback[idx] = { ...rollback[idx], revert: prevRevert } as Session
+    }
+    store.setState({
+      session: rollback,
+      message: { ...current.message, [sessionId]: prevMessages },
+      part: { ...current.part, ...Object.fromEntries(removedMessages.map((m) => [m.id, state.part[m.id] ?? []])) },
+    })
+    throw err
+  }
+}
+
+/**
+ * Unrevert — restore all previously reverted messages.
+ * Restore all previously reverted messages. Aborts if busy, merges result.
+ */
+export async function unrevertSession(sessionId: string): Promise<void> {
+  const store = dirStore()
+  const state = store.getState()
+
+  // Abort if busy
+  const status = state.session_status[sessionId]
+  if (status && status.type !== "idle") {
+    try {
+      await sdk().session.abort({ sessionID: sessionId, directory: dir() })
+    } catch {
+      // ignore
+    }
+  }
+
+  const result = await sdk().session.unrevert({ sessionID: sessionId, directory: dir() })
+  if (result.data) {
+    const current = store.getState()
+    const sessions = [...current.session]
+    const idx = sessions.findIndex((s) => s.id === sessionId)
+    if (idx >= 0) {
+      sessions[idx] = result.data
+      store.setState({ session: sessions })
+    }
+  }
+}
+
+/**
+ * Fork from a user message.
+ *
+ * 1. Extract text from the message for input restoration
+ * 2. Call SDK session.fork()
+ * 3. Insert the new session into the child store (so sidebar updates immediately)
+ * 4. Switch to new session and set pending input text
+ */
+export async function forkFromMessage(sessionId: string, messageId: string): Promise<void> {
+  const store = dirStore()
+  const state = store.getState()
+
+  // Extract message text for input restoration
+  const parts = state.part[messageId] ?? []
+  let messageText = ""
+  const textParts = parts.filter((p) => p.type === "text")
+  messageText = textParts
+    .map((p: Part) => ((p as Record<string, unknown>).text as string) || ((p as Record<string, unknown>).content as string) || "")
+    .join("\n")
+    .trim()
+
+  const result = await sdk().session.fork({ sessionID: sessionId, directory: dir(), messageID: messageId })
+  if (!result.data) return
+
+  const forkedSession = result.data
+
+  // Insert new session into child store so sidebar updates immediately
+  const current = store.getState()
+  const sessions = [...current.session]
+  const searchResult = Binary.search(sessions, forkedSession.id, (s) => s.id)
+  if (!searchResult.found) {
+    sessions.splice(searchResult.index, 0, forkedSession)
+    store.setState({ session: sessions })
+  }
+
+  // Switch to new session
+  useSessionUIStore.getState().setCurrentSession(forkedSession.id)
+
+  // Restore forked message text to input
+  if (messageText) {
+    useInputStore.setState({
+      pendingInputText: messageText,
+      pendingInputMode: "replace" as const,
+    })
+  }
+}